Pré-requisitos para compilar o Firefox OS

Antes de adquirir o código para compilar o Firefox OS, você precisa de um sistema de desenvolvimento configurado  — esse artigo mostra a você como fazer isso. Você pode construí-los em uma distribuição Linux 64-bit e OS X.

Tenha um dispositivo/emulador compatível

Você precisa ter um dispositivo compatível ou usar um emulador. Embora muitos telefones são suportados, existem variações. Atualmante nós suportamos variações específicas e alguns aparelhos tem um suporte melhor que outros.

Nível 1

Os aparelhos do nível 1 são aqueles que estão sendo ativamente suportados como foco primario para o desenvolvimento. Funcionalidades irão chegar com mais frequência, e problemas serão corrigidos, primeiramente nestes aparelhos.

Keon

Keon é desenvolvido pela Geeksphone, que é um dos telefones de desenvolvimento de entrada. Observe que a compilação para esse dispositivo é fornecediro pela Geeksphone.

Inari

Inari é um outro dispositivo de teste. Use essa configuração para compilar para um dispositivo ZTE Open. Atenção: compilações mais recentes do Firefox OS pode apresentar problemas na inicialização na partição de boot padrão do ZTE Open.

Flame

Flame é o novo padrão da Mozilla de um telefene de referência para Firefox OS, você pode usar a configuração do Flame se você está compilando uma imagem para o ZTE Open C, uma vez que o Flame e o Open C são baseados no Android JellyBean.

Unagi

Unagi é um telefone sendo utilizando para testes e desenvolvimento da plataforma, como um smartphone de baixo-medio custo. Vários dos desenvolvedores principais do Firefox OS estão trabalhando com um Unagi.

Pandaboard

O Pandaboard é uma placa de desenvolvimento baseada na arquitetura OMAP 4, utilizada para desenvolvimento em plataformas mobile.

Emulador (ARM and x86)

Existem dois emuladores disponíveis: um emula código ARM e outro executa qualquer coisa em código x86.

Desktop

Você também pode compilar uma versão desktop do Firefox OS, ela roda o Gecko em uma aplicação XULRunner, e você então usa a experiência do usuário Gaia.

Flatfish

Flatfish é o primeiro programa de tablet do Firefox OS, embora algumas das funcionalidades de telefonia não funcionem no flatfish. Você vai precisar de algumas configurações extras para compilar o código.

Você também pode, é claro, compilar no cliente desktop ou em algum dos  emuladores sem necessitar de um telefone.

Nível 2

Os aparelhos do Nível 2 são geralmente funcionais e usados por muitos desenvolvedores de aplicativos, porém esses aparelhos recebem as atualizações em um segundo momento.

Samsung Nexus S

Os números de modelos conhecidos dos telefones Nexus S são GT-I9020A e GT-I9023. Outros códigos podem funcionar.

Samsung Nexus S 4G

O modelo SPH-D720 é suportado como um telefone nível 2.

Nível 3

Esses dispositivos são aqueles que podem ter o Firefox OS compilado mas não são trabalhados ativamente por uma base de desenvolvedores do núcleo do sistema, por isso sua confiabilidade e conjunto de recursos fica atrás dos telefones nível 1 e até mesmo dos aparelhos do Nível 2.

Samsung Galaxy S2

O único modelo que roda o Firefox OS é o i9100, nenhuma outra variante é oficialmente compatível. (i9100P deve funcionar, uma vez que a única diferença é o acréscimo de um chip NFC - Near Field Communication).

Samsung Galaxy Nexus

Nós não temos informações de alguma variação que não seja compatível.

Nexus 4

Alguns usuários no IRC testaram com sucesso. Pode ou não fazer o flash para o Android 4.3 primeiro se estiver rodando o 4.4 (imagens do Android disponíveis para download no Google)

Nexus 5

Alguns usuários no IRC testaram com sucesso.

Tara

Tara é outro dispositivo de teste. O manifesto do Tara está somente no branch master. O script para conseguir o código do Tara é "BRANCH=master ./config.sh tara".

Unagi

Unagi é um telefone usado como uma plataforma de teste e desenvolvimento de smartphones low-to-midrange. Muitos desenvolvedores do core do Firefox OS trabalham no Unagi.

Pandaboard

O Pandaboard é uma placa de desenvolvimento baseado na arquitetura OMAP 4

sudo apt-get install libxml2-utils

Requisitos para GNU/Linux

Para compilar no Linux, você precisará de um sistema com a seguinte configuração:

• Uma distribuição GNU/Linux de 64 bits (nós recomendamos o Ubuntu 12.04).
• Pelo menos 4GB de ram/swap.
• Pelo menos 30GB de espaço em disco.

Isso é mais que o mínimo necessário, mas algumas vezes a compilação pode falhar exatamente por falta de recursos.

É possível utilizar outras distribuições, mas nós recomendamos Ubuntu uma vez que é a distro mais comumente utilizada com sucesso. Distribuições que não devem funcionar: distros 32 bits e distros recentes por causa do gcc 4.7 (Ubuntu 12.10, Fedora 17/18, Arch Linux).

Você também vai necessitar das seguintes ferramentas instaladas:

• autoconf 2.13
• bison
• bzip2
• ccache
• curl
• flex
• gawk
• git
• gcc / g++ / g++-multilib (4.6.3 or older)
• make
• OpenGL headers
• X11 headers
• 32-bit ncurses
• 32-bit zlib

Problemas na compilação do Emulador

Se você está compilando um emulador, você precisa prestar atenção a esses problemas:

Observe também que o sistema de compilação para o emulador compila ambas as versões do emulador: 32bit e 64bit. Como o emulador depende do OpenGL, isso significa que você precisa ter as versões 32bit e 64bit das bibliotecas do OpenGL instaladas no seu sistema. Veja a discussão no bug 897727.

Existem duas formas de resolver esse problema:

1ª Solucão: Ter as bibliotecas OpenGL nas versões 32bit e 64bit instaladas, com os links simbólicos corretos

Se sua distro tem pacotes multilib para OpenGl, você pode tentar instalá-las. Você deve, nesse caso, criar alguns links simbólicos manualmente.

Por exemplo, há uma situação no Ubuntu 12.04 LTS x86-64. Nessa distribuição, o pacote libgl1-mesa-dev não pode ser instalado simultaneamente nas versões x86-64 e i386, mas você pode ter a seguinte combinação de pacotes simultaneamente instalados:

sudo apt-get install libgl1-mesa-dev libglapi-mesa:i386 libgl1-mesa-glx:i386

Após executar esse comando, você ainda tem que criar alguns links simbólicos manualmente para que a compilação do emulador funcione:

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

2ª Solução: aplicar uma correção (patch) para que o emuladodr somente compile em 64bit

Aplicando essa correção no sdk/ repositório git abaixo do repositório B2G. Isso fará com que o emulador B2G somente tentar compilar o emulador 64bit se você estiver num sistema 64bit, evitando assim quaisquer problemas relacionados com multlib. Dessa forma, o emulador de 32 bits não é usado em um sistema de 64 bits. Esta é a solução mais simples, até que, eventualmente, essa correção pare de funcionar.

Requisitos de instalação de 64 bit

Essa seção lista os comandos que você precisa executar para instalar todos os requisitos necessários para compilar o Firefox OS.

Ubuntu 12.04 / Linux Mint 13 / Debian 6

Execute os seguintes comandos no terminal:

sudo apt-get updatesudo 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

Se você vai compilar para o "Flame" ou Nexus 5, execute o seguinte comando:

sudo apt-get install libxml2-utils 

E veja os comentários acima sobre problemas na compilação do emulador!

Ubuntu 12.10 / Debian 7

Execute o seguinte comando no terminal:

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

Adicionalmente aos problemas do emulador discutidos acima, o compilador tem como padrão o gcc-4.7, o que não permitirá a compilação gerando o seguinte erro:

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

Para resolver esse problema, você deve especificar o gcc 4.6 como o compilador padrão depois de baixar os arquivos fontes do B2G. Leia Modificando o compilador padrão para descobrir como fazer isso.

Em uma recente instalação Ubuntu 12.10, você receberá um erro relacionado com dependências não encontradas para ia32-libs. Os comandos a seguir resolvem esse problema:

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

Ubuntu 13.04

Execute o seguinte comando no 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

Adicionalmente aos problemas do emulador discutidos acima, o compilador tem como padrão o gcc-4.7, o que não permitirá a compilação gerando o seguinte erro:

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

Para resolver esse problema, você deve especificar o gcc 4.6 como o compilador padrão depois de baixar os arquivos fontes do B2G. Leia Modificando o compilador padrão para descobrir como fazer isso.

Ubuntu 13.10

Com o Ubuntu 13.10, os pacotes multiarquitetura são agora a principal maneira de suportar diferentes arquiteturas (por exemplo, versão 32bit numa instalação 64bit). Você deve informar ao sistema que deseja também suportar pacotes 32bit:

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

Uma vez que você executou esse comando, você pode instalar os pacotes necessários:

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" 

Ubuntu 14.04

Siga as mesmas instruções do Ubuntu 13.10.

Fedora 19/20

Execute o seguinte comando no 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

O projeto deve compilar corretamente com o compilador padrão do Fedora, mas se ocorrer algum erro de compilação você deve instalar o GCC 4.6.x:

• GCC 4.6.x pré-compilado para o Fedora 19/20

Baixe o tarball e instale-o no diretório /opt, com o seguinte comando no Fedora 19/20:

curl -O https://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

Para usar o GCC 4.6.x como o compilador padrão você deve configurá-lo explicitamente depois de baixar os fontes do B2G: leia o artigo Alterando o compilador padrão para saber como fazer isso.

Arch Linux

Execute o seguinte comando no 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

Para instalar os pacotes lib32-* você precisa um repositóririo multilib habilitado.

B2G somente pode ser compilado com gcc 4.6.4, e como o Arch Linux possui softwares com tecnologia de ponta é necessário instalar gcc46-multilib from AUR. Observe que deve-se editar o arquivo PKGBUILD e adicionar staticlibs ao array  options, do contrário o gcc não conseguirá compilar o B2G and apresentará o erro: cannot find -lgcc. Será necessário também, incluir as seguintes linhas ao arquivo .userconfig:

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

O Arch Linux utiliza como padrão o Python3. Mas você deverá forçar o uso do Python2. Você pode fazer isso criando um link simbólico, mas não é recomendável por ser propenso a erros. Mesmo porque desabilita o uso do Python 3 se estiver instalado no sistema. Uma melhor forma é usar virtualenv/virtualenvwrapper:

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

Android exige que seja utilizado make 3.81 ou make 3.82 ou invés da versão 4.0. Você pode baixar o make 3.81 do AUR. Isso vai instalar o binário make-3.81 no seu path, você precisa criar um link simbólico chamado makem numa localização no início da variável PATH para compilar a versão correta.

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

Android também necessita Java6 SDK e Arch somente tem Java7. Você pode baixar o Java 6 SDK e instalá-lo manualmente. Você precisa colocá-lo no seu path.

cp ~/Downloads/jdk-6u45-linux-x64.bin /opt
su
cd /opt
chmod +x jdk-6u45-linux-x64.bin
./jdk-6u45-linux-x64.bin
exit
ln -s /opt/jdk1.6.0_45/bin/java ~/bin/java

Gentoo Linux

Installing ccache

É necessário instalar ccache, uma ferramenta para fazer cache de compilações parciais.

# emerge -av ccache

Devido ao fato de ccache ser conhecido como frequente causador de problemas, Gentoo encoraja a usá-lo explicitamente e com moderação.

Para habilitar o uso do ccache, na etapa subsequente desse guia onde o script ./build.sh é chamado, os usuários do Gentoo devem executar o comando com o path explicitamente estendido, ou seja:

PATH=/usr/lib64/ccache/bin:$PATH ./build.sh

Gerando imagens de partições

Se você está compilando o B2G para um hardware físico real, então em algum momento você pode querer gerar algumas imagens de partições para instalar no seu dispositivo. (Por exemplo, para restaurar os arquivos de backup do aparelho via o utilitário fastboot).

A imagem do sistema de arquivos usada nesse caso é YAFFS2 (Yet Another Filesystem 2). Gentoo tem suporte para o pacote mais recente do yaffs2-utils (ou seja, git HEAD).

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

Para gerar essa imagem, basta mudar para o diretório principal da árvore do sistema de arquivos que você deseja empacotar e executar esse comando:

mkyaffs2image system/ system.img

Requisitos para Mac OS X

Para compilar o Firefox OS no OS X, existe uma série de pré-requisitos que deve ser atendidos que serão detalhados a seguir. Também serão discutidos erros comuns que você pode se deparar em situações particulares, e suas soluções.

Compatibilidade de versões

O XCode 4.2 não está mais disponível para OS X 10.9 (também conhecido como "Mavericks"), então você pode se surpreender ao encontrar falhas ao compilar o Firefox OS. Basicamente não conseguir compilar emulador ICS no Mavericks e superiores e também não compilar flatfish com a série do XCode 5.x.

1. Você deve configurar a variável de ambiente  BUILD_MAC_SDK_EXPERIMENTAL=1 exportada para compilar o flatfish.

Instalação do Utilitário de Linha de Comando

Para compilar o Firefox OS no OS X você precisa instalar o Utilitário de Linha de Comando do XCode. É possível baixar apenas o Utilitário na página de desenvolvedores da Apple para sua versão do OS X, ou instalar a suíte completa do XCode pelo Mac AppStore.

Xcode 4.3.1 (OS X 10.7 "Lion") e versões posteriores como a 4.4.1+ (that is, OS X 10.8 "Mountain Lion"), não vêm com o Utilitário de Linha de Comando. Quando você instalar o XCode, certifique-se de ir em Preferências, Painel Downloads e instala "Command Line Utilities". Deve ter pelo menos 20GB de espaço disponível no seu disco.

Instalando o Bootstrap do Firefox OS no Mac

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

Rode o comando acima no terminal. Isso vai baixar e rodar o script do bootstrap e certificar-se de que o seu ambiente atende todos os pré-requisitos.

Isso vai checar se você possui todas as coisas que você precisa para compilar o emulador, e ao longo do script solicitará permissão para instalar algo que não tenha encontrado.

Os itens que o script irá checar se estão instalados na sua máquina são os seguintes:

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

xcode-select -print-path

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

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

ln -s /Users/<yourusername>/Desktop/MacOSX10.6.sdk /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/

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

ERROR: Patching of kernel/ failed.

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

open ~/firefoxos.sparseimage

cd /Volumes/firefoxos/

external/qemu/android/skin/trackball.c:130:25: error: 'M_PI' undeclared (first use in this function)

MY_CFLAGS += -DM_PI=3.14159265358979323846264338327950288   #/* B2G_fix: not finding M_PI constant */

clang: error: unable to execute command: Segmentation fault: 11

brew install mpfr --use-gcc

Samsung Galaxy S2

Se você planeja compilar para o Samsung Galaxy S2, será necessário instalar o aplicativo heimdall. Veja Instalando heimdall para maiores detalhes. Esse procedimento não é realizado pelo script bootstrap!

Como consertar a dependência da biblioteca libmpc

O gcc 4.6 foi compilado com libmpc 0.9. Se você usou o homebrew para atualizar os pacotes o libmpc foi atualizado para a versão 1.0, mas o homebrew não recompila o gcc 4.6 depois da atualização da biblioteca. Assim, você precisa criar um link simbólico para fazer as coisas funcionarem novamente dessa forma:

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

Opcional: Instalação do HAX

A Intel fornece um driver especial que permite que o emulador B2G execute seu código nativamente no seu Mac ao invés de ser emulado, quando você usa o emulador x86. Se vocie deseja usá-lo você pode baixar e instalar nesse link. Não é obrigatório, mas pode melhorar a performance e estabilidade.

Instalação do adb

O processo de compilação necessita copiar BLOBS (Binary Large OBjectS) da instalação do Android para o telefone antes de compilar o B2G (a menos, é claro, que você esteja utilizando o emulador). Para isso você necessita do adb, o Android Debug Bridge. Nosso arigo Instalando o ADB explica como instalar o adb.

Instalação do heimdall

Heimdall é um utilitério para copiar (flashing) o Samsung Galaxy S2. É usado ppara substituir o conteúdo do telefone pelo Firefox OS bem como copiar (flash) versões atualizadas do B2G e Gaia para o aparelho. Você precisará dele se desejar instalar o Firefox OS no Galaxy S2. Não é necessário para outro aparelho.

Para outros aparelhos nós compilamos e usamos o utilitário fastboot.

Existem duas formas de instalar o heimdall:

• Baixar o código no GitHub e compilar você mesmo.
• Usar um gerenciador de pacote para instalá-lo.
  • No Linux: sudo apt-get install libusb-1.0-0 libusb-1.0-0-dev
  • No Mac, basta baixar o instalador e usá-lo.

Configuração do ccache

O processo de compilação do B2G usa ccache. O tamanho de cache padrão para o ccache é 1GB, mas o B2G satura esse falor facilmente, então 10GB é o valor recomendado. Você pode configurar seu cache executando o seguinte comando no terminal:

$ ccache --max-size 10GB

Para o Linux: configure a regra do serviço udev para seu telefone

A seguir, você precisa configurar a regra udev para o seu telefone.

Você consegue a identificação USB do fabricante executando lsusb com o seu telefone conectado para porta USB. Alguns exemplos de USB vendor ID: Google 18d1, Samsung 04e8, ZTE 19d2, Geeksphone/Qualcomm 05c6.

Com o código, inclua essa linha no arquivo /etc/udev/rules.d/android.rules (substituindo XXXX com o ID do seu aparelho):

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

Usando o ZTE como exemplo, o conteúdo no arquivo android.rules será:

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

No Firefox Flame, deve ser

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

Por favor, observe que o dispositivo fastboot device (que é usado quando você faz o flashing) deve ter uma Identificação do fabricante, e que você deve ter uma regra para ele. Por exemplo, o Firefox Flame também precisa do Identificador do Fabricante Google.

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

Uma vez editado e salvo, altere a permissão do arquivo:

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

Agora que a regra foi alterada, reinicie o serviço udev.\

Ubuntu

sudo service udev restart

Fedora 20

sudo systemctl restart systemd-udevd.service

Por último, desconecte o cabo USB e não reconecte até habilitar o modo de depuração remota no aparelho.

Habilitando a depuração remota

Antes de conectar o telefone à porta USB, coloque o aparelho no modo desenvolvedor. Isso possibilita depurar e copiar o sistema operacional para o telefone (flash). Para habilitar o modo desenvolvedor habilite Depuração Remota  em Configurações de Desenvolvedor (nas versões antigas era chamado Modo Desenvolvedor). Uma vez que a opção esteja marcada, a depuração remota está habilitada e você está pronto para seguir adiante.

Feito isso, conecte seu telefone ao computador usando o cabo USB (se antes foi criada a regra para o udev, o serviço detectará o telefone e criará um nó do dispositivo com as permissões corretas). Nesse momento é possível checar se o dispositivo foi reconhecido através do comando adb devices. Se tudo estiver funcionando perfeitamente, você verá algo semelhante a isso (o exemplo a seguir é de um Geeksphone Keon):

$ adb devices
List of devices attached
full_keon       device

Se o telefone não aparecer como o esperado, verifique se o nome do arquivo e o script estão corretos (veja seção anterior), então reinicie o computador e digite o comando novamente. Observe também que se o dispositivo utiliza fastboot, o bootloader pode identificar como um ID do fabricante diferente  do que você vê quando o dispositivo é inicializado normalmente.

Faça uma cópia de segurança da partição de sistema do telefone

É altamente recomendado que você tenha uma cópia de segurança completa da partição do sistema Android do seu telefone.

Você pode usar a cópia dos BLOBs do Android caso a árvore do B2G seja apagada. Para fazer isso, execute:

adb pull /system <diretório de backup>/system

Dependendo do telefone, pode ser necessário copiar os diretórios /data e/ou /vendor:

adb pull /data <diretório de backup>/data
adb pull /vendor <diretório de backup>/vendor

Se os comandos acima falharem com a mensagem "insufficient permission" tente o seguinte:

• pare e reinicie o serviço adb, ou se isso não funcionar,
• certifique-se de que você concedeu permissões de root à ferramenta adb na ROM customizada (por exemplo, em CyanogenMod, altere Settings > System > Developer Options > Root Access to Apps and ADB or ADB only).
• Verifique se você configurou a regra do serviço udev corretamente (veja Para o Linux: configure a regra do serviço udev para seu telefone.

Para a próxima etapa

Nesse ponto você deve estar preparado para sua primeira compilação do Firefox OS!