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.mkAndroidProducts.mkBoardConfig.mkextract-files.shfull_<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
- Firefox OS
- Arquivos fonte do B2G no Github
- Página oficial do Android
- Uma lista de projetos existentes no blog do Dietrich Ayala de portabilidade do Firefox OS em alguns dispositivos