Join MDN and developers like you at Mozilla's View Source conference, 12-14 September in Berlin, Germany. Learn more at https://viewsourceconf.org

Portando o Boot to Gecko

O Firefox OS (Boot to Gecko) usa um kernel derivado do Android, com uma interface do usuário baseado no Gecko no seu topo. Esse artigo fornece um guia básico de como portar o sistema operacional para novos dispositivos.

Esse guia assume que você está portando para um novo dispositivo que já roda Android. Se você estiver portando para um outro dispositivo o trabalho será mais compilcado.

Configurando o sistema de compilação

O primeiro passo é configurar seu ambiente e o sistema de compilação. Você pode seguir o guia no artigo Pré-requisitos para compilar o Firefox OS.

Crie uma cópia de segurança local do sistema Android original

O próximo passo deve ser criar uma cópia de segurança do seu dispositivo Android antes de começar a realizar os testes de compilação do B2G. Adicionalmente alguns desses bits salvos serão úteis no processo de compilação e instalação.

mkdir my_device_backup
cd my_device_backup
adb pull /system system

Clone os repositórios B2G

Para clonar o repositório B2G e os seus manifestos execute os comandos:

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

Adicione o novo dispositivo ao arquivo config.sh

O próximo passo é adicionar o novo dispositivo ao arquivo config.sh no repositório B2G. Você pode utilizar algum já existente como modelo. Essa tarefa basicamente consiste em fornecer as instruções para buscar os arquivos corretos para a compilação.

Crie um arquivo de manifesto para o novo dispositivo

Agora você precisa incluir um arquivo de manifesto para o novo dispositivo. Utilze um manifesto existente como modelo. Você pode usar o manifesto hamachi como referência. Uma vez pronto, adicione e faça o commit seu novo arquivo no repositório local b2g-manifest:

git add my-new-device.xml
git commit

Nesse momento, você vai precisar que o script config.sh utilize seu repositório local b2g-manifest no lugar do oficial. Para fazer isso, altere os valores das variáveis GITREPO e BRANCH no arquivo config.sh para o seu repositório local e o branch desejeado,  por exemplo:

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

Crie uma árvore de configuração para o novo dispositivo

Isso deve estar em device/<manufacturer>/<device_id>. Essa árvore deve incluir no mínimo:

  • AndroidBoard.mk
  • AndroidProducts.mk
  • BoardConfig.mk
  • extract-files.sh
  • full_<device_id>.mk
  • arquivos idc para touchscreen
  • arquivos de inicialização (init.rc, init.<target>.rc, uevent.rc, ...)

O conteúdo aqui pode ser muito diferente de um dispositivo para outro. Em particular BoardConfig.mk e extract-files.sh devem ser significativamente diferentes. Essa parte requer um bom conhecimento técnico, investigação, testes de depuração para descobrir quais BLOBs devem ser extraídos. Para ter uma melhor ideia do que supostamente essa árvore deve conter dê uma olhada em configuração para o dispositivo hamachi. Lembre-se de referenciar corretamente sua própria árvore de configuração no manifesto que você criou para o seu novo dispositivo.

Nota: Se você encontrar uma referência existente no CyanogenMod para seu dispositivo, isso acelerará o processo. O Forum XDA é um outro bom local para discussão e conseguir informações.

Recompile o boot.img

Uma vez que tudo está pronto, você precisa recompilar a imagem de inicialização (boot.img). Isso normalmente não é necessário para o kernel, mas pegar as alterações realizadas no arquivo init.rc.

Alterações no arquivo init.rc

O arquivo init.rc que você vai usar não é fornecido pelo B2G, então você deve utilizar o que existe no seu dispositivo.

As principais coisas que você necessita modificar são:

Importar init.b2g.rc

Adicione as seguintes linhas para importar init.b2g.rc:

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

Corrigir permissões

Corrija as permissões nos arquivos /system/b2g/b2g, /system/b2g/updater, /system/b2g/plugin-container. Isso deve ser feito após as linhas que montam o sistema de arquivos. Use a permissão 0755:

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

Você deve começar modificando o arquivo init.rc do seu dispositivo ao invés de usar o arquivo init.rc fornecido pelo sistema de compilação. Para isso, você deve lembrar de configurar TARGET_PROVIDES_INIT_RC em BoardConfig.mk.

Utilização de um kernel pré-compilado versus compilar o kernel desde o fonte.

Para compilar um kernel desde o fonte, inclua AndroidKernel.mk e a configuração do kernel à árvore de configuração do dispositivo.

O maguro no sistema de compilação antigo é um exemplo de compilação do kernel a partir do fonte.

Extraindo e modificando uma imagem de incialização (boot image)

É possível recuperar a imagem de inicialização de um telefone analisando o conteúdo dos dispositivos /dev/mtd/mtd1 ou /dev/mtd/mtd2, a imagem pode ser facilmente recuperada:

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

Uma vez que a imagem foi obtida ela pode ser descompactada via uma ferramenta como unmkbootimg. A ferramente irá extrair tanto a imagem do kernel (zimage) como o ramdisk (initramfs.cpio.gz) bem como irá apresentar o comando para recompilar a imagem com os mesmos parâmetros usados na compilação original, por exemplo:

$ 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
---------------

Para modificar o arquivo ramdisk, crie um diretório de saída e faça a extração lá:

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

Faça todas as alterações necessárias (como a modificação no init.rc) e reempacote o ramdisk usando mkbootfs. Certifique-se de usar a versão compilada com as outras ferramentas do B2G atual:

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

Finalmente volte ao diretório de nível mais alto e reempacote a imagem de inicializacão usando mkbootimg, certifique-se também que você está usando a mesma versão compilada com as outras ferramentas do B2G atual:

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

Se agora você copiar a nova imagem de inicializacão em out/target/product/$DEVICE/boot.img (onde $DEVICE é o nome do dispositivo) ele automaticamente irá copiar (flash) quando você executar flash.sh. Alternativamente você poderá copiar (flash) manualmente com os seguintes comandos:

adb reboot bootloader
fastboot flash boot newboot.img
fastboot reboot

Adicione o novo dispositivo ao flash.sh

Os detalhes de como fazer isso irá depender das ferramentas necessárias para fazer a cópia para o novo dispositivo.

Configure, compile e copie (flash) para o novo dispositivo

Agora você pode tentar executar os seguintes comandos:

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

Teste e depure

Nós precisamos incluir detalhes aqui, mas esse artigo já pode ser alguma ajuda.

Perguntas frequentes

Em breve

Veja também

Etiquetas do documento e colaboradores

 Colaboradores desta página: jwhitlock, rbrandao
 Última atualização por: jwhitlock,