Please note, this is a STATIC archive of website developer.mozilla.org from 03 Nov 2016, cach3.com does not collect or store any user information, there is no "phishing" involved.
B2G OS
Vos résultats de recherche

    Porter Boot to Gecko

    B2G OS utilise un noyau dérivé d'Android, avec par dessus une interface utilisateur basée sur Gecko. Cet article fournit un guide de base sur la façon de porter le système d'exploitation sur de nouveaux appareils.

    Ce guide suppose que vous faite un portage sur un nouvel appareil qui exécute déjà Android; si vous faites un portage vers un autre type d'appareil, le travail va nécessiter davantage d'investissement.

    Note : Vous pouvez trouver de l'aide concernant le portage sur le canal IRC #fxos et sur Mozilla Discourse.

    Configurer votre système de build

    La première étape consiste à configurer votre système de buid; vous pouvez suivre le guide pré-requis pour compiler B2G OS.

    Créer une sauvegarde locale du système Android d'origine

    Ensuite, vous devez faire une sauvegarde de votre appareil Android avant de commencer à l'atomiser avec vos builds de test de B2G. De plus, certaines parties seront nécessaires pour le processus de build et d'installation. Pour le nom de l'appareil, nous recommandons l'utilisation de "_" au lieu de "-". Voir le bug 1243349 pour les raisons de ce choix. 

    mkdir sauvegarde_de_mon_appareil
cd sauvegarde_de_mon_appareil
adb pull /system system

    Cloner les répertoires B2G

    La première étape consiste à cloner le dépôt B2G ainsi que le dépôt contenant les manifestes.

    git clone https://github.com/mozilla-b2g/B2G.git
git clone https://github.com/mozilla-b2g/b2g-manifest.git

    Ajouter un nouvel appareil à config.sh

    L'étape suivante consiste à ajouter un nouvel appareil à config.sh dans le dépôt B2G;  vous pouvez utiliser un de ceux qui existent comme modèle. Ceci implique simplement de fournir les instructions permettant de récupérer les bons fichiers pour faire le build.

    Créer un manifeste pour le nouvel appareil

    Mainenant, vous devez ajouter un fichier manifeste pour le nouvel appareil. Utilisez l'un des manifestes existant comme modèle. Vous pouvez utiliser le manifeste hamachi comme référence. Une fois que c'est fait, vous pouvez ajouter et livrer votre nouveau manifeste dans votre dépôt local b2g-manifest :

    git add mon-nouvel-appareil.xml
git commit

    Ensuite, il faudra indiquer au fichier config.sh d'utiliser votre dépôt local b2g-manifest à la place du dépôt officiel. Pour réaliser cela, modifiez la valeur des variables GITREPO et BRANCH dans le fichier config.sh pour qu'elles pointent vers l'emplacement de votre dépôt local et de la branche souhaitée, par exemple :

    GITREPO=${GITREPO:-"file:///home/votrenom/b2g-manifest"}
BRANCH=${BRANCH:-master}

    Créer une arborescence de configuration pour le nouvel appareil

    Créer une nouvelle arborescence pour le nouvel appareil. Elle doit se trouver dans device/<manufacturer>/<device_id>. Cette arborescence doit inclure au moins :

    • AndroidBoard.mk
    • AndroidProducts.mk
    • BoardConfig.mk
    • extract-files.sh
    • full_<device_id>.mk
    • fichiers idc pour l'écran tactile
    • fichiers init (init.rc, init.<target>.rc, uevent.rc, ...)

    Ici, le contenu peut grandement différer d'un appareil à l'autre. En particulier, les fichiers BoardConfig.mk et extract-files.sh peuvent différer significativement. Cette partie nécessite pas mal de modifications, de test et de débogage pour déterminer quels blobs binaires doivent être extraits. Pour avoir une meilleure idée de qu'on est supposé trouver ici, jetez un oeil à configuration pour l'appareil hamachi. Rappelez-vous de référencer correctement votre propre arborescence de configuration dans le manifeste aue vous avez créé pour votre nouvel appareil.

    Note: Si vous pouvez trouver une référence existante sur CyanogenMod pour votre appareil, ces informations accélèreront le processus de portage. Le forum XDA est un autre bon endroit pour discuter et vérifier des informations.

    Reconstruire boot.img

    Une fois que tout cà est fait, vous devez reconstruire l'image de boot. Ce n'est habituellement pas nécessaire pour le noyau lui-même mais pour récupérer les modifications dans init.rc.

    Modifications dans init.rc

    Le init.rc que vous utilisez n'est pas celui fourni par B2G; à la place, vous devez le récupérer depuis votre appareil.

    Les principales choses que vous aurez besoin de modifier sont :

    Importer init.b2g.rc

    Ajouter les lignes suivantes pour importer init.b2g.rc:

    on early-init
    start ueventd
    import /init.b2g.rc

    Corriger les permissions

    Corrigez les permissions des fichiers /system/b2g/b2g, /system/b2g/updater et /system/b2g/plugin-container; ceci doit être fait après les lignes qui montent le système de fichier en lecture/écriture:

    chmod 0755 /system/b2g/b2g
chmod 0755 /system/b2g/updater
chmod 0755 /system/b2g/plugin-container

    Vous pourriez vouloir commencer en modifiant init.rc provenent du nouvel appareil au lieu d'utiliser le init.rc fourni par le système de build; dans ce cas, vous devez vous rappeler de renseigner TARGET_PROVIDES_INIT_RC dans BoardConfig.mk.

    Noyau pré-compilé vs. compiler le noyau depuis le code source

    Vous pouvez utiliser un noyau pré-compilé ou vous pouvez compiler le noyau à partir du code source. Pour compiler le noyau à partir du code source, ajoutez AndroidKernel.mk et la configuration du noyau dans l'arborescence de configuration de l'appareil.

    Le maguro sur l'ancien système de build est un exemple qui compile le noyau à partir du code source.

    Extraire et modifier une image de boot existante

    Il est possible de récupérer l'image de boot d'un téléphone en extrayant le contenu des devices /dev/mtd/mtd1 ou /dev/mtd/mtd2, le fichier image résultat peut ensuite être facilement récupéré :

    adb shell 'cat /dev/mtd/mtd1 > /sdcard/boot.img'
adb pull /sdcard/boot.img

    Une fois que le fichier de l'image de boot a été obtenu, il peut être décompressé à l'aide d'un utilitaire tel que unmkbootimg. L'outil va extraire à la fois l'image du noyau (zimage) et le disque mémoire (ramdisk initramfs.cpio.gz) et également afficher une commande permettant de re-compiler l'image avec les mêmes paramètres que ceux utilisés pour l'image d'origine, par exemple :

    $ unmkbootimg boot.img 
Kernel size 3872576
Kernel address 0x208000
Ramdisk size 265102
Ramdisk address 0x1500000
Secondary size 0
Secondary address 0x1100000
Kernel tags address 0x200100
Flash page size 2048
Board name is ""
Command line "androidboot.hardware=aphone"
Extracting kernel to file zImage ...
Extracting root filesystem to file initramfs.cpio.gz ...
All done.
---------------
To recompile this image, use:
  mkbootimg --kernel zImage --ramdisk initramfs.cpio.gz --base 0x200000 --cmdline 'androidboot.hardware=aphone' -o new_boot.img
---------------

    Pour modifier le fichier ramdisk, créez un répertoire destination et extrayez-le dedans:

    mkdir initramfs_dir
cd initramfs_dir
gunzip -c ../initramfs.cpio.gz | cpio -i

    Faîtes toutes les modifications nécessaires (telles que la modification de init.rc) puis recompressez le ramdisk en utilisant mkbootfs et assurez-vous que la version a été compilée avec les outils B2G de l'hôte :

    /path/vers/votre/B2G/out/host/linux-x86/bin/mkbootfs . | gzip > ../newinitramfs.cpio.gz

    Enfin, retournez au répertoire de premier niveau et re-compressez l'image de boot en utilisant mkbootimg; assurez-vous également que vous utilisez la version compilée avec loutils de l'autre hôte B2G:

    /path/vers/votre/B2G/out/host/linux-x86/bin/mkbootimg --kernel zImage --ramdisk newinitramfs.cpio.gz --base 0x200000 --cmdline 'androidboot.hardware=aphone' -o newboot.img

    Si vous copiez maintenant votre nouvelle image de boot dans out/target/product/$DEVICE/boot.img (où $DEVICE est le nom de votre device), elle sera automatiquement flashée quand flash.sh est appelé. Alternativement, vous pouvez la flasher à la main avec les commandes suivantes :

    adb reboot bootloader
fastboot flash boot newboot.img
fastboot reboot

    Ajouter le nouvel appareil à flash.sh

    Ajoutez le nouvel appareil à flash.sh; les spécificités sur la façon de faire cela dépendront des outils qui seront utilisés pour flasher le nouvel appareil.

    Configurer, compiler et flasher le nouvel appareil

    Maintenant, vous pouvez essayer de compiler et de flasher votre nouvel appareil:

    ANDROIDFS_DIR=sauvegarde_de_mon_appareil ./config.sh <device_id> '../b2g-manifest/default.xml'
./build.sh
./flash.sh

    Test et débogage

    Nous avons besoin d'ajouter certains détails ici; en fait, c'est tout l'article qui pourrait nécessiter de l'aide.

    FAQ

    À venir.

    Voir également

    Étiquettes et contributeurs liés au document

    Étiquettes : 
     Contributeurs à cette page : jwhitlock, xdelatour, dattaz, poum
     Dernière mise à jour par : jwhitlock,