Prérequis pour construire Firefox OS

Avant d'obtenir les codes sources pour construire Firefox OS, vous avez besoin de préparer votre système pour la compilation. Vous pouvez construire le système Firefox OS sur une distribution Linux 64 bits et OS X.

Note : Pour compiler et installer Firefox OS sur un téléphone cellulaire (smartphone), dans un premier temps votre téléphone NE DOIT PAS être relié à votre ordinateur. Nous vous le signalerons lorsque vous pourrez.

Disposer d'un appareil ou d'un émulateur compatible

Vous avez besoin de posséder un appareil compatible pour l'installation du système, vous pouvez aussi utiliser un émulateur. Bien que nous supportons le système pour différents types de téléphones, beaucoup sont différents. Nous supportons plus spécifiquement certaines variations et certains appareils plus facilement que d'autres:

Note : Le code source de B2G de Mozilla représente l'implémentation de référence pour B2G. Cependant, les distributeurs de téléphones peuvent apporter des correctifs et/ou des changements. Par exemple, lorsque vous achetez un Alcatel One Touch, il contient une version de B2G modifiée par le distributeur. Ces modifications n'ont aucune conséquence pour les applications mais peuvent avoir un impact sur sur la plate-forme. Le portage pour le Nexus 4 est directement maintenu par Mozilla, il y a donc plus de chances que cet appareil fonctionne efficacement avec la version de Gecko de Mozilla par rapport aux appareils de troisième rang.

Premier rang (Tier 1)

Les équipements de premier rang représentent la cible principale des développements et seront typiquement parmi les premiers à recevoir les corrections de bugs et les mises à jour.

Keon
Keon est un téléphone Geeksphone et fut parmi les premiers téléphones utilisés pour le développement. On notera que les versions pour cet appareil sont fournies par Geeksphone
Inari
Inari est un autre appareil utilisé pour les tests. Sa configuration peut être utilisée pour compiler une version pour les appareiles ZTE Open. Attention : les dernières versions de Firefox OS peuvent rencontrer des problèmes lors du démarrage (boot) avec la partition par défaut utilisée par les appareils ZTE Open lors du boot
Flame
Le Flame est le nouveau téléphone de référence pour Firefox OS. Vous pouvez utiliser la configuration du Flame si vous souhaitez construire une version pour le ZTE Open C, les deux étant basés sur le système Android Jellybean.
Émulateur (ARM et x86)
Deux émulateurs sont disponibles, un permet d'utiliser du code sur une architecture de type ARM, l'autre permet d'utiliser du code fonctionnant sur une architecture x86. Plus d'informations sur l'installation et l'utilisation des simulateurs.
Attention, le simulateur pour x86 est difficile à installer et moins bien supporté que l'autre.
Pour bureau (Desktop)
Il est possible de construire une version de Firefox OS pour ordinateur de bureau. Celle-ci lancera Gecko dans une application XULRunner application et vous permettra d'utiliser Gaia pour tester l'ergonomie.
Flatfish
Flatfish est la première tablette visée par Firefox OS. Certaines fonctionnalités téléphoniques ne fonctionneront pas sur la tablette. Pour construire la version du code dédiée, des paramètres supplémentaires seront nécessaires.

Bien sûr, vous pouvez utiliser le client pour bureau ou un des émulateurs sans avoir de téléphone.

Deuxième rang (Tier 2)

Les appareils de rang 2 sont fonctionnels et beaucoup de développeurs les utilisent (principalement des développeurs d'applications). Ce seront ces appareils qui recevront les mises à jour et correction dans un second temps.

Samsung Nexus S
Les modèles GT-I9020A et GT-I9023 sont les versions de Nexus S qui fonctionnent avec Firefox OS. Les autres versions pourraient fonctionner.
Samsung Nexus S 4G
Le modèle SPH-D720 est supporté comme appareil de deuxième rang.

Troisième rang (Tier 3)

Firefox OS peut être compilé pour ces appareils bien qu'ils ne soient pas activement maintenus par les principaux développeurs. Les fonctionnalités supportées et la fiabilité de ces appareils, sous Firefox OS, peuvent être inférieures aux appareils de rang 1 et 2.

Samsung Galaxy S2
Le seul modèle reconnu comme compatible est le modèle i9100. Les autres variantes ne sont pas officiellement compatibles (le modèle i9100P pourrait fonctionner car il ne diffère que par la puce NFC ajoutée).
Samsung Galaxy Nexus
Les différents modèles sont censés être compatibles.
Nexus 4
Certains utilisateurs ont communiqué sur IRC qu'ils avaient pu faire fonctionner Firefox OS sur ce type d'appareil. Il peut être nécessaire de flasher l'appareil sur Android 4.3 auparavant s'il fonctionnait sur Android 4.4 (des images Android sont distribuées par Google)
Nexus 5
Certains utilisateurs ont communiqué sur IRCqu'ils avaient pu faire fonctionner Firefox OS sur ce type d'appareil.
Tara
Tara est un autre appareil utilisé pour les tests. Le manifeste de Tara correspond à la brance master. Pour obtenir le code de Tara, le script est "BRANCH=master ./config.sh tara".
Unagi
Unagi est un téléphone utilisé comme plate-forme de test et de développement pour représenter les appareils de gamme moyenne à basse. Plusieurs développeurs principaux de Firefox OS travaillent avec un appareil Unagi.
Pandaboard
Le Pandaboard est un tableau fonctionnant sur une architecture OMAP 4. Il est utilisé pour le travail de développement sur les plate-formes mobiles.
Important : Seuls les appareills qui peuvent faire fonctionner Android 4 (Ice Cream Sandwich, Jelly-bean ou Kitkat) sont supportés. Si votre appareil est listé ci-avant et que vous utilisez une version antérieure d'Android, veuillez le mettre à jour vers Android 4 avant toute autre chose.

Prérequis pour le Flame et le Nexus 5 : libxml2-utils

Si vous construisez Firefox OS pour le Flame ou le Nexus 5, vous devrez installer libxml2-utils en lançant la commande suivante (pour les distributions utilisant apt-get) :

sudo apt-get install libxml2-utils

Retour à l'écran d'accueil : bouton matériel, bouton logiciel et mouvement

Tous les appareils de rang 1 disposent d'un bouton matériel pour accéder à l'écran d'accueil. La plupart des appareils Android utilisant Ice Cream Sandwich (ICS) utilisent des boutons tactiles sur l'écran. Un bouton virtuel (logiciel) est activé pour accéder à l'écran d'accueil si l'appareil n'a pas de bouton matériel. Si ce bouton n'est pas activé automatiquement, allez dans l'application Réglages, Paramètres pour les développeurs, puis activer l'option Activer le bouton logiciel pour l'accueil.

Les appareils de rang 2 et 3 disposent d'un bouton logiciel pour l'écran d'accueil.

Dans Firefox OS 1.4, il existe une option de développement pour activer le « Geste de retour à l'écran d'accueil ». Pour effectuer ce geste, il suffit de glisser son doigt depuis le bas de l'écran vers le haut.

Prérequis pour les systèmes GNU/Linux

Pour construire Firefox OS sur un système type Linux, vous devez avoir :

  • une distribution GNU/Linux 64 bits (la distribution Ubuntu 12.04 est recommandée),
  • Au moins 4 Go de mémoire vive,
  • Au moins 30 Go de mémoire sur votre disque dur.

Nous vous conseillons fortement d'avoir bien plus que ce que nous demandons au minimum car la construction de Firefox OS peut échouer en raison d'un manque de ressource mémoire. Une erreur typique pour ce problème est : "arm-linux-androideabi-g++: Internal error: Killed (program cc1plus)".

Vous devrez aussi posséder ou installer sur votre système les outils suivants :

  • autoconf 2.13
  • bison
  • bzip2
  • ccache
  • curl
  • flex
  • gawk
  • git
  • gcc / g++ / g++-multilib
  • make
  • bibliothèques partagées OpenGL
  • patch
  • X11 headers
  • 32-bit ncurses
  • 32-bit zlib

Installation des prérequis (64 bits)

Cette section liste les lignes de commande nécessaires pour installer les prérequis sur les différentes distribution Linux pour construire Firefox OS.

Ubuntu 12.04 / Linux Mint 13 / Debian 6

Dans une console, tapez les lignes de commandes suivantes:

sudo apt-get update
sudo apt-get install autoconf2.13 bison bzip2 ccache curl flex gawk gcc g++ g++-multilib git ia32-libs lib32ncurses5-dev lib32z1-dev libgl1-mesa-dev libx11-dev make zip

Si vous construisez une version pour le Flame ou le Nexus 5, vous aurez besoin de lancer la commande suivante :

sudo apt-get install libxml2-utils

Vous pouvez installer le JDK grâce à ce ppa.

Ubuntu 12.10 / Debian 7

Dans un terminal, lancez la commande :

$ sudo apt-get install autoconf2.13 bison bzip2 ccache curl flex gawk gcc g++ g++-multilib gcc-4.6 g++-4.6 g++-4.6-multilib git ia32-libs lib32ncurses5-dev lib32z1-dev libgl1-mesa-dev libx11-dev make zip

En plus des problèmes d'émulateur évoqués précédemment, le compilateur utilisé par défaut sera gcc-4.7. Il peut ne pas fonctionner correctement, ne pas lancer la compilation et afficher les lignes suivantes:

"KeyedVector.h:193:31: error: indexOfKey was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"

Pour résoudre ce problème, vous devez spécifier GCC 4.6 comme le compilateur par défaut après avoir récupéré les sources de B2G. Lisez changez le compilateur par défaut pour savoir comment faire.

Lors d'une récente installation de Ubuntu12.10, vous obtiendrez une erreur de dépendance pour le paquet ia32-libs. Les commandes suivantes permettent de réparer ce problème :

sudo dpkg --add-architecture i386
sudo apt-get update
sudo apt-get install ia32-libs

Vous pouvez installer le JDK grâce à ce ppa.

Ubuntu 13.04

Lancez la commande suivante dans un terminal :

$ sudo apt-get install --no-install-recommends autoconf2.13 bison bzip2 ccache curl flex gawk gcc g++ g++-multilib gcc-4.6 g++-4.6 g++-4.6-multilib git ia32-libs lib32ncurses5-dev lib32z1-dev zlib1g:amd64 zlib1g-dev:amd64 zlib1g:i386 zlib1g-dev:i386 libgl1-mesa-dev libx11-dev make zip

En plus des problèmes d'émulateur évoqués précédemment, le compilateur par défaut gcc-4.7, peut ne pas fonctionner correctement, ne pas lancer la compilation et afficher les lignes suivantes :

En plus des problèmes d'émulateur évoqués précédemment, le compilateur utilisé par défaut sera gcc-4.7. Il peut ne pas fonctionner correctement, ne pas lancer la compilation et afficher les lignes suivantes:

"KeyedVector.h:193:31: error: indexOfKey was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"

Pour résoudre ce problème, vous devez spécifier GCC 4.6 comme le compilateur par défaut après avoir récupéré les sources de B2G. Lisez changez le compilateur par défaut pour savoir comment faire.

Ubuntu 13.10

Pour Ubuntu 13.10, les paquets multi-architectures (multi-arch packages) permettent de supporter des paquets 32 bits sur des installations 64 bits. Il est nécessaire de signaler à Ubuntu que vous souhaitez également supporter les paquets 32 bits avec la commande qui suit (puis de mettre à jour) :
 

sudo dpkg --add-architecture i386
sudo apt-get update

Une fois que ces commandes sont terminées, vous pouvez installer les paquets nécessaires grâce aux commandes suivantes :

sudo apt-get install --no-install-recommends autoconf2.13 bison bzip2 ccache curl flex gawk gcc g++ g++-multilib gcc-4.6 g++-4.6 g++-4.6-multilib git lib32ncurses5-dev lib32z1-dev zlib1g:amd64 zlib1g-dev:amd64 zlib1g:i386 zlib1g-dev:i386 libgl1-mesa-dev libx11-dev make zip libxml2-utils 

sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.6 1 

sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 2 

sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.6 1 

sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 2 

sudo update-alternatives --set gcc "/usr/bin/gcc-4.6" 

sudo update-alternatives --set g++ "/usr/bin/g++-4.6"

Le JDK peut être installé depuis ce ppa.

Ubuntu 14.04

Suivre les instructions pour Ubuntu 13.10.

Ubuntu 14.10

Suivre les instructions pour Ubuntu 13.10.

La version de Make livrée avec le système est la 4.0, laquelle est incompatible avec le processus de compilation. Il est nécessaire d'effectuer un downgrad vers la version 3.81.

Téléchargez le paquet DEB de la version 3.81.
Puis allez dans le dossier contenant le fichier, suprimez la version 4.0 de make (si installée) et installez la version 3.81 :

cd <dossier du fichier téléchargé>
sudo apt-get purge make -y
sudo dpkg -i make*.deb

Fedora 19/20

Lancer la commande suivante dans un terminal :

sudo yum install autoconf213 bison bzip2 ccache curl flex gawk gcc-c++ git glibc-devel glibc-static libstdc++-static libX11-devel make mesa-libGL-devel ncurses-devel patch zlib-devel ncurses-devel.i686 readline-devel.i686 zlib-devel.i686 libX11-devel.i686 mesa-libGL-devel.i686 glibc-devel.i686 libstdc++.i686 libXrandr.i686 zip perl-Digest-SHA wget

La compilation du projet devrait fonctionner avec le compilateur par défaut pour Fedora. Si vous rencontrez des erreurs, essayez d'installer GCC 4.6.x :

Télécharger l'archive puis l'installer sous le répertoire /opt en utilisant la commande suivante :

curl -O http://people.mozilla.org/~gsvelto/gcc-4.6.4-fc19.tar.xz
sudo tar -x -a -C /opt -f gcc-4.6.4-fc19.tar.xz

Pour utiliser GCC 4.6.x comme compilateur par défaut, vous devrez le définir comme tel une fois que vous avez récupéré les sources de B2. Lire la page modifier le compilateur par défaut pour savoir comment faire.

Arch Linux

Lancer la commande suivante dans un terminal :

sudo pacman -S --needed alsa-lib autoconf2.13 bison ccache curl firefox flex gcc-multilib git gperf libnotify libxt libx11 mesa multilib-devel wget wireless_tools yasm zip lib32-mesa lib32-mesa-libgl lib32-ncurses lib32-readline lib32-zlib

Pour installer les paquets lib32-* vous devrez avoir activé le dépôt multi-bibliothèque (multilib repository).

Note : Compiler B2G à l'aide de gcc-multilib devrait fonctionner normalement sauf si vous souhaiter construire d'ancienne version de Firefox OS. Dans ce cas, vous pouvez installer gcc46-multilib depuis AUR. Vous devrez éditer le PKGBUILD et ajouter l'élément staticlibs au tableau options. Si vous n'effectuez pas cette étape, gcc ne pourra pas compiler B2G et cela provoquera une erreur cannot find -lgcc lors de la compilation. Vous devrez également ajouter les lignes suivantes dans votre fichier .userconfig :

export CC=gcc-4.6.4
export CXX=g++-4.6.4

Par défaut, Arch Linux utilise Python 3. Il faudra forcer l'utilisation de Python 2. Plutôt que de changer le lien de python vers l'exécutable python2, il est conseillé d'utiliser un environnement virtuel  virtualenv/virtualenvwrapper :

sudo pacman -S python-virtualenvwrapper
source /usr/bin/virtualenvwrapper.sh
mkvirtualenv -p `which python2` firefoxos
workon firefoxos

Android aura également besoin de la version 3.81 ou 3.82 pour make (plutôt que de la 4.0). Vous pouvez télécharger make 3.81 depuis AUR. Cela vous permettra d'installer make-3.81 et de l'intégrer à la variable d'environnement PATH, il sera alors nécessaire de créer un lien symbolique nommé make pour utiliser la bonne version pour la compilation :

mkdir -p ~/bin
ln -s `which make-3.81` ~/bin/make
export PATH=~/bin:$PATH

Android nécessite également la présence du SDK Java 6. Vous pouvez installer jdk6 depuis AUR  et changer les variables d'environnement grâce à la commande  archlinux-java :

# archlinux-java set java-6-jdk
 

Note: Vous pouvez dans un premier temps tenter de compiler avec OpenJDK 7 des dépots officiels si votre téléphone "cible" est basé sur Android 4.3+ (JellyBean) et supérieur.

 

Gentoo Linux

Installer ccache

Il sera nécessaire d'installer ccache, c'est un outil qui permet de mettre en cache les versions partiellement compilées (partial builds).

# emerge -av ccache

ccache est connu pour poser certains problèmes fréquemment. Gentoo encourage les personnes à l'utiliser explicitement et avec parcimonie.

Pour activer l'utilisation de ccache, lors de l'étape suivante de ce guide où ./build.sh est appelé. Les utilisateurs de Gentoo devraient utiliser la commande avec un PATH explicitement étendu avec ccache :

PATH=/usr/lib64/ccache/bin:$PATH ./build.sh
Générer des images de partition

Si vous compilez des versions de B2G pour un appareil (matériel), vous souhaiterez éventuellement générer des images de partition à télécharger sur votre appareil. (Par exemple, pour restaurer des fichiers sur l'appareil grâce à l'outil fastboot)

Le système de fichier utilisé pour l'image est YAFFS2 (Yet Another Filesystem 2). Gentoo supporte la toute dernière version de yaffs2-utils est (ie. git HEAD). (Note : vous pourrez avoir besoin de correctifs pour le noyau si vous souhaitez monter des images YAFFS2, cela n'est pas nécessairement obligatoir car vous pouvez déconstruire et reconstruire les images à la place.)

# emerge --autounmask-write yaffs2-utils; etc-update; emerge -av yaffs2-utils

Pour générer une image, il suffit de changer le répertoire parent de la partition du système de fichier que vous souhaitez packager puis d'utiliser une commande semblable à :

monimageyaffs2 system/ system.img

Installation des prérequis pour OS X

Pour construire Firefox OS sur OS X, plusieurs étapes sont nécessaires : elles sont détaillées ci-après. Dans ce paragraphe, nous verrons également les écueils possibles et les solutions pour ces problèmes.

Note : Configurer et construire B2G pour un Keon NE FONCTIONNERA PAS sur Mac. Il est nécessaire d'utiliser une distribution Linux pour construire B2G pour cet appareil.

Compatibilité de versions

Les versions 4.2 et antérieures de Xcode ne sont pas compatibles avec OS X 10.9 (Mavericks), ce qui peut poser problème lors de la compilation de Firefox OS. so you may be surp et rise et d to find build failures of Firefox OS. L'émulateur Ice Scream Sandwich ne pourra pas être compilé pour OS X 10.9 ou ultérieur. flatfish ne pourra pas être compilé avec les versions 5.x de Xcode above, and flatfish fails to build with XCode 5.x series.

Compatibilité de versions pour OS X 10.9.x
  emulator (ICS) flatfish/vixen (JB-4.2) emulator-jb (JB-4.3) emulator-kk (KitKat-4.4)
Xcode 4.3.3 X X X X
Xcode 4.4.1 X O[1] O O
Xcode 4.5.2 X O[1] O O
Xcode 4.6.3 X O[1] O O
Xcode 5.0.2 X X O O
Xcode 5.1.1 X X O O
Xcode 6.0.1 X X X X
Xcode 6.1beta2 X X X X
  1. La variable d'environnement BUILD_MAC_SDK_EXPERIMENTAL=1 doit être exportée pour pouvoir construire/compiler flatfish/vixen.

Installer les outils en ligne de commande Xcode

Pour la compilation, vous aurez besoin d'installer les outils en ligne de commande Xcode. Vous pouvez installer uniquement les outils en ligne de commande depuis la page de téléchargement pour les développeurs Apple ou, si vous le souhaitez, vous pouvez installer la suite d'applications Xcode via l'App Store.

Xcode 4.3.1 (OS X 10.7 Lion) et les versions plus récentes comme la version 4.4.1+ (Mac OS X 10.8 Mountain Lion), ne disposent pas nécessairement des outils en ligne de commande. Lors de l'installation d'Xcode, il faudra aller dans l'écran Préférences, l'onglet Téléchargements et cliquer sur Installer sur la ligne adéquate. En plus de cette installation, assurez vous de disposer d'au moins 20 Go d'espace disponible.

Screenshot of Xcode Downloads Command Line Tools

Note : Pour faire fonctionner l'émulateur Firefox OS, il est nécessaire d'avoir un processeur Core 2 Duo ou plus puissant. Cela correspond au niveau de compatibilité attendu pour faire fonctionner Mac OS X 10.7 Lion. Bien entendu, il n'est pas nécessaire d'utiliser Lion, il suffit d'être compatible avec cette version d'un point de vue matériel. Vous pouvez donc très bien construire des versions de Firefox OS en utilisant des versions de Mac plus anciennes.

Note : Les versions 4.2.x ou antérieures de Xcode 4.2.x ne sont pas compatibles avec les versions 10.9 et ultérieures d'OS X. Xcode 4.3.x ne dispose pas du SDK plate-forme pour 10.8. C'est pourquoi il faut utiliser une version plus récente. Si vous souhaitez construire une version pour flatfish, assurez-vous de pouvoir utiliser Xcode 4.4, 4.5, ou 4.6.

Installer les prérequis Firefox OS pour Mac

Pour installer les prérequis, il suffit d'ouvrir un terminal et de lancer la commande suivante :

curl -fsSL https://raw.github.com/mozilla-b2g/B2G/master/scripts/bootstrap-mac.sh | bash

Cela lancera un script de mise en route (bootstrap) qui s'assurera que les composants prérequis sont installés. Ce script pourra demander votre permission afin d'installer des éléments manquants, afficher des messages d'avertissements et suggérer des actions à effectuer pour résoudre des problèmes. Ce script vérifiera et/ou installera les éléments suivants :

  • git
  • gpg
  • ccache
  • yasm
  • autoconf-213
  • gcc-4.6
  • gnu-tar
  • homebrew

Erreur de version Xcode

Si vous utilisez déjà Xcode 4.4+ et que vous obtenez un message indiquant que Xcode n'est pas à jour, vérifiez le chemin vers Xcode avec la commande suivante :

xcode-select -print-path

Si ce chemin pointe toujours vers le répertoire /Developer, vous pouvez le mettre à jour grâce à la commande suivante :

sudo xcode-select -switch /Applications/Xcode.app

Rendre le SDK Mac OS X 10.6 disponible

Pour la compilation, il faudra que le SDK de OS X 10.6 SDK soit disponible. Le SDK doit être disponible à l'emplacement suivant :

/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/

S'il ne se trouve pas à cet emplacement, il sera nécessaire de l'extraire puis de le copier depuis Xcode 4.3 :

  1. Télécharger le fichier .dmg pour Xcode 4.3 depuis le portail Apple pour les développeurs (vous aurez besoin d'un compte Apple Developer).
  2. Télécharger l'outil Pacifist puis l'utiliser pour extraire le SDK 10.6 du fichier .dmg. Cliquer sur "Ouvrir le paquet", rechercher le SDK grâce à la chaîne "10.6" dans le champ de recherche, sélectionner le répertoire "MacOSX10.6.sdk" puis l'extraire à un emplacement adéquat grâce au bouton "Extraire vers".
  3. Ensuite, ajouter un lien symbolique (symlink) depuis l'emplacement choisi vers le répertoire /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/. Si vous avez extrait le SDK 10.6 sur le bureau, la ligne de commande serait semblable à :
ln -s /Users/<nomutilisateur>/Desktop/MacOSX10.6.sdk /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/

Note : Cette étape n'est pas nécessaire pour OS X 10.9 et les versions ultérieures. Le SDK 10.6 est utilisé pour Ice Scream Sandwich, qui n'est pas supporté par OS X 10.9.

Sensibilité à la casse du système de fichiers Mac

Par défaut, le système de fichiers utilisé par OS X n'est pas sensible à la casse (il ne fait pas la différence entre les minuscules et les majuscules). Étant donné que le noyau Linux possède certains fichiers dont le nom est le même mais pour lesquels la casse est différente, cela peut poser certains problèmes. Par exemple, on aura deux fichiers d'en-tête xt_CONNMARK.h et xt_connmark.h.  En conséquence, certains fichiers seront modifiés dans /kernel après une première utilisation de ./config.sh.

Dans la plupart des cas, la construction se déroulera correctement. Cependant, pour certaines plate-formes, l'erreur suivante pourrait se produire :

ERROR: You have uncommited changes in kernel
You may force overwriting these changes
with |source build/envsetup.sh force|

ERROR: Patching of kernel/ failed.

Voir le bug 867259 pour les discussions et méthodes éventuelles pour résoudre ce problème.

De façon plus générale, il est plus indiqué de compiler le code sur un système de fichiers sensible à la casse. La façon la plus simple d'y parvenir est de créer une image disque montable, séparée, pour laquelle la sensibilité à la casse est activé. Pour ce faire, vous pouvez utiliser l'utilitaire de disques d'Apple ou la ligne de commande :

hdiutil create -volname 'firefoxos' -type SPARSE -fs 'Case-sensitive Journaled HFS+' -size 40g ~/firefoxos.sparseimage

Ensuite montez l'image :

open ~/firefoxos.sparseimage

Puis déplacez vous dans le nouveau volume avec :

cd /Volumes/firefoxos/

À partir de cet emplacement, vous pourrez récupérer le code et le compiler sans que la sensibilité à la casse pose de problèmes.

Erreur clang et homebrew sur Mountain Lion

Si vous utilisez Mountain Lion et que vous obtenez une erreur lors de l'installation des dépendances avec homebrew :
clang: error: unable to execute command: Segmentation fault: 11
... essayez de réinstaller la dépendance manuellement en ajoutant le drapeau (flag) --use-gcc :
brew install mpfr --use-gcc

Étapes additionnelles pour le Samsung Galaxy S2

Si vous souhaitez construire une image pour le Samsung Galaxy S2, vous aurez besoin d'installer heimdall (voir Installing heimdall ci-après pour les détails). Cette étape n'est pas effectuée par le script de mise en route !

En plus de cela, il faut garder à l'esprit que :

  1. Lors de l'installation de votre version sur un appareil S2, avant de lancer le script  flash.sh, vous aurez besoin de modifier les occurences de factoryfs en FACTORYFS, de même pour kernel en KERNEL (vérifier la sortie de la commande pit pour confirmer que ça a bien fonctionné), sinon ça ne fonctionnera pas.
  2. La ROM Siyah-s2 fonctionne le mieux. CWM fonctionne également mais cause quelques problèmes.
  3. Si vous flasher votre S2 avec flash.sh, cela permettra au système d'exploitation de base de fonctionner. Cependant Gaia peut rencontrer quelques problèmes. Pour les régler, il est conseillé de rafraîchir l'ensemble avec la commande  make reset-gaia PRODUCTION=1.
Note : Si vous avez installé l'outil Samsung Kies, utilisé pour gérer le contenu de nombreux téléphones Samsung, vous devrez le désinstaller avant de pouvoir flasher Firefox OS sur votre appareil. Sur Windows, vous pouvez utiliser l'outil de désinstallation classique, sur Mac, l'image disque d'installtion de Kies possède un utilitaire qui permet de le désinstaller entièrement. L'installation (flashing) de Firefox OS ne fonctionnera pas si Kies est installé. Si vous avez oublié de désinstaller Kies, le système de construction le détectera et vous rappellera de l'enlever. Note : l'outil de désinstallation ne retire pas correctement le dossier ~/Library/Application Support/.FUS, ce qui laisse une référence vers l'outil dans la liste des applications présentes au démarrage. Vous pouvez retirer ces fichiers manuellement si vous le souhaitez.

Réparer la dépendance à libmpc

gcc 4.6 a été construit avec libmpc 0.9. Si vous avez utilisé homebrew pour mettre à jour les paquets, libmpc sera mis à jour avec la version 1.0 mais homebrew ne recompilera pas gcc 4.6. Pour que cela fonctionne à nouveau, vous devrez créer un lien symbolique :

cd /usr/local/lib/
ln -s libmpc.3.dylib libmpc.2.dylib

Optionnel : Installer HAX

Intel fournit un pilote spécial qui permet à l'émulateur B2G (x86) d'exécuter du code de façon native sur un Mac plutôt que de l'émuler. Si vous souhaitez l'utiliser, vous pouvez le télécharger et l'installer. Ce pilote n'est pas obligatoire mais il peut permettre d'améliorer les performances et la stabilité de l'émulateur.

Avant d'installer HAX, vous devrez installer le SDK Android.

Installation de adb

Lors de la construction, il est nécessaire de récuperer certains blobs binaires de l'installation Android sur le téléphone pour pouvoir construire B2G (sauf, bien sûr, si vous utilisez un émulateur). Pour cette étape, vous aurez besoin d'avoir adb (Android Debug Bridge). Voir l'article installer ADB pour en savoir plus sur l'installation.

Note : Pour les prochaines fois où vous utiliserez adb pour déboguer : l'écran de verrouillage doit être désactivé ou le téléphone déverrouillé pour qu'adb puisse communiquer avec votre téléphone (du moins pour les versions les plus récentes de Firefox OS). Pour éviter les manipulations répétitives, vous pouvez désactiver l'écran de verrouillage (ce qui sera abordé dans les articles sur les instructions pour la construction de Gaia).

Installation de heimdall pour Samsung Galaxy S2

Heimdall est un outil utilisé pour flasher le Samsung Galaxy S2. Il est utilisé par l'outil de flash de Boot to Gecko pour remplacer le contenu du téléphone par Firefox OS mais aussi pour installer des mises à jour de versions de B2G et de Gaia sur l'appareil. Si vous souhaitez installer Firefox OS sur un Galaxy S2, vous aurez besoin d'heimdall. Si vous souhaitez installer Firefox OS sur un autre appareil, ce ne sera pas nécessaire (l'outil fastboot sera utilisé à la place).

Note : Encore une fois, heimdall n'est nécessaire uniquement pour l'installation de Firefox OS sur un Samsung Galaxy S2.

Il y a deux méthodes pour installer heimdall :

Configuration de ccache

Le processus de construction de B2G utilise ccache. Par défaut, la taille du cache pour ccache est de 1 Go, il arrive rapidement que B2G sature ce volume. C'est pourquoi il est recommandé que le cache puisse contenir environ 10 Go. Vous pouvez configurer votre cache de cette façon grâce à la commande suivante :

ccache --max-size 10GB

Pour Linux : configurer la règle udev liée au téléphone

Note : Cette section ne concerne que Linux. Les systèmes OS X disposent des permissions nécessaires.

Vous aurez besoin d'éditer la règle udev utilisée pour votre téléphone.

L'identifiant du fabricant USB peut être trouvé en lançant la commande lsusb une fois que votre téléphone est connecté par USB. Généralement, on retrouve ces identifiants :

Liste des fabricants et de leurs identifiants USB (les plus fréquents uniquement)
Fabricant (vendor) Identifiant associé
Google 18d1
Samsung 04e8
ZTE 19d2
Geeksphone/Qualcomm 05c6

ll faut ajouter la ligne suivante dans le fichier /etc/udev/rules.d/android.rules (en remplaçant XXXX avec l'identifiant correspondant à votre appareil) :

SUBSYSTEM=="usb", ATTR{idVendor}=="XXXX", MODE="0666", GROUP="plugdev"

Si ce fichier n'existe pas, vous devrez le créer. Le répertoire rules.d est généralement en lecture seule et il faut donc utiliser chmod pour pouvoir écrire dans un fichier ou dans un dossier (ou les deux).

Par exemple, pour un appareil ZTE, la ligne serait :

SUBSYSTEM=="usb", ATTR{idVendor}=="19d2", MODE="0666", GROUP="plugdev"

Sur le Firefox Flame, la ligne serait :

SUBSYSTEM=="usb", ATTR{idVendor}=="05c6", MODE="0666", GROUP="plugdev"

Attention : l'appareil fastboot (utilisé lors du flash) peut avoir un autre identifiant. Il faudra également un règle pour celui-ci. C'est pourquoi, le Flame a également de l'ID correspondant à Google et qu'il faut ajouter en plus la ligne suivante :

SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", MODE="0666", GROUP="plugdev"

Une fois que vous avez enregistré le fichier puis l'avez fermé, il faut rendre le fichier accessible en lecture :

sudo chmod a+r /etc/udev/rules.d/android.rules

Une fois que les règles udev ont été mises à jour, il faut redémarrer le démon udev.

Ubuntu

sudo service udev restart

Fedora 20

sudo systemctl restart systemd-udevd.service

ARCH

sudo udevadm control --reload-rules

Note : Selon les distributions, cela peut prendre plus de temps et il vous faudra utiliser les commandes suivantes :

sudo vi /etc/udev/rules.d/android.rules
sudo service udev restart
sudo /etc/init.d/udev restart
sudo reload udev
sudo udevadm trigger

Enfin, vous pouvez débrancher l'appareil et le câble USB. Ne le rebranchez pas tout de suite car il est nécessaire d'activer le débogage à distance sur le téléphone..

Activer le débogage à distance

Avant de rebrancher le téléphone sur le port USB, il est nécessaire d'activer le mode de développement USB. Cela vous permettra de déboguer et de flasher le téléphone. Pour activer le mode développeur, allez dans le menu Paramètres pour les développeurs puis activer Débogage à distance (cette option était nommée "Mode développeur" auparavant). Une fois que l'option est cochée, le débogage à distance est activée et vous pouvez continuer.

Vous pouvez alors connecter votre appareil à votre ordinateur via le port USB (si vous avez correctement éditer la règle udev, cela permettra à udev de détecter le téléphone et de créer le nœud associé avec les permissions adéquates). Vous pouvez vérifier le bon fonctionnement grâce à la commande adb devices (rappel : adb ne peut détecter le téléphone que si l'écran du téléphone est déverrouillé). Si tout se déroule correctement, vous devriez pouvoir avoir une liste semblable à celle-ci (qui correspond à un Geeksphone Keon) :

$ adb devices
List of devices attached
full_keon       device

Si l'appareil n'apparaît pas dans cette liste : vérifiez que le nom du fichier et du script soient corrects (voir le paragraphe précédent). Redémarrez votre ordinateur et saisissez la commande à nouveau. Note : si votre appareil utilise fastboot, le bootloader pourra s'identifier avec un autre ID que celui utilisé lorsque l'appareil démarre normalement.

Sauvegarde de la partition système du téléphone

Note : Si vous n'avez pas déjà de sauvegarde système, cette étape est nécessaire avant la construction de la version pour votre appareil. En effet, certaines bibliothèques seront utilisées lors de la constrution. Ces bibliothèques sont propriétaires et ne peuvent pas être intégrées dans notre code.

Avant toute chose, il est conseillé de sauvegarder la partition système Android de votre téléphone.

Vous pourrez utiliser une copie des blobs binaires d'Android au cas où vous supprimeriez l'arborescence B2G. Pour cela, lancer la commande :

adb pull /system <repertoire de sauvegarde>/system

Selon le téléphone, il pourra être nécessaire de copier également les répertoires /data et/ou /vendor :

adb pull /data <backup target dir>/data
adb pull /vendor <backup target dir>/vendor

Si la commande pull échoue car les permissions sont insuffisantes, vous pouvez essayer les actions suivantes :

  • arrêtez puis redémarrez le server adb, si ça échoue :
  • vérifiez que vous avez fourni les permissions root à adb pour votre ROM (par exemple, dans CyanogenMod : il faut changer Paramètres > Système > Options pour les développeurs >Accès Root et passer de Applications à ADB ou ADB uniquement).
  • vérifiez que la règle udev est correctement paramétrée (voir For Linux: configure the udev rule for your phone).

Prochaine étape

Vous pouvez désormais récupérer le code Firefox OS !

Étiquettes et contributeurs liés au document

Dernière mise à jour par : fabbox,
Masquer la barre latérale