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 apenas construi-lo em uma distribuição Linux 64-bit e OS X.

Nota: Para compilar o Firefox OS para um telefone, comece com seu telefone SEM CONECTÁ-LO ao seu computador. Nós os avisaremos quando fazer isso.

Tenha telefones compatíveis ou use o Emulador

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

Nota: O código fonte do B2G efetivamente é a referência na implementacão do B2G, mas fabricantes estão livres para adicionar patches ou fazer alterações. Quando você compra um Alcatel One Touch, por exemplo, ele contém a versão do fabricante. Isso não faz diferença para os aplicativos instalados, mas pode fazer a diferença no nível da plataforma. A portabilidade do Nexus 4 é mantida diretamente pela Mozilla, por isso são muito mais propensos a trabalhar com a nossa versão do Gecko do que outros dispositivos no Nível 3.

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.
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.
Otoro
Otoro é 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 Otoro.
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.

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 somos informados de alguma variação que não seja compatível.
Importante: Somente dispositivos rodando o Android versão 4 (também conhecida como Ice Cream Sandwich) ou superior são suportados. Se seu telefone estiver na lista acima mas esteja rodando uma versão anterior do android, atualize-a antes de fazer qualquer coisa.

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:

Primeiro, note que você não deve usar o emulador x86 — é difícil de instalar e não é bem suportado.

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:

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

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" 


Fedora 17/18/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

Adicionalmente, você precisa do gcc 4.6.x para compilar o projeto:

Baixe a versão de acordo com sua instalação Fedora, então instale em /opt, com os seguintes comandos:

No Fedora 17/18:
curl -O http://people.mozilla.org/~gsvelto/gcc-4.6.4-fc18.tar.xz
sudo tar -x -a -C /opt -f gcc-4.6.4-fc18.tar.xz
No Fedora 19/20:
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

Você deve especificar o gcc 4.6.x como o compilador padrão depois de baixar os arquivos fontes do B2G. Leia Modificando o compilador padrão para descobrir como fazer isso.

Se na compilação você receber um erro informando não ter encontrado libmpc.so.2, instale o pacote compat-libmpc.

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).

Nota: Você necessitará correções do kernel se for montar imagens YAFFS2, mas não é realmente exigido uma vez que é possível desconstruir e recompilar.

# 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 Mac 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.

Nota: Configuração e Compilação para Keon NÃO FUNCIONA no Mac. Para isso é necessário utilizar o Linux para compilar o B2G para esse aparelho.

Nota: Mac OS X 10.9 (Mavericks) ainda não é suportado - veja bug 935776.

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

Para compilar o Firefox OS no Mac 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, Mac OS X10.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.

Screenshot of Xcode Downloads Command Line Tools

Nota: O emulador do Firefox OS exige pelo menos um processador Core 2 Duo, ou seja, um sistema compatível com Mac OS X 10.7 "Lion". Na verdade você não precisa rodar no Lion, basta ser compatível. Assim, você pode compilar o Firefox OS em diversos Macs mais antigos.

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

Se você já tiver atualizado para o Xcode 4.4 + e aparecer a mensagem de que o Xcode está desatualizado, verificar o caminho (path) Xcode com:

xcode-select -print-path

Se o resultado mostrar /Developer você pode alterar o caminho (path) com:

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

Após, verifique se você tem o Mac OS X 10.6 SDK disponível:

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

Caso não esteja disponível, você precisa baixar o arquivo DMG Xcode 4.3 disponível no portal Apple Developer. Você pode usar o utilitário Pacifist para extrair o 10.6 SDK. Não se esqueça de incluir um link simbólico para o diretório /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/.

Atenção com o sistema de arquivos do Mac: Não é case sensitivity

Como padrão, o Mac OS X vem com o sistema de arquivos case insensitive. Isso é um problema porque o kernel do Linux tem diversos arquivos com o mesmo nome porém com diferenças nas maiúsculas e minúsculas. Por exemplo, os arquivos cabeçalhos xt_CONNMARK.h e xt_connmark.h são distintos. Essa situação causa diversos transtornos.

Em muitos casos você compila e aparentemente tudo correu bem, mas você pode encontrar o seguinte erro:

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

ERROR: Patching of kernel/ failed.

Veja o bug 867259 com discussões sobre o tema e possíveis soluções para esse problema.

Uma outra forma de compilar sem problema num sistema de arquivos case sensitive é criar uma imagem de disco separada com o case sensitivity habilitado. Pode-se usar a aplicação Utilitário de Disco ou a partir da linha de comando:

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

Montar o drive com:

open ~/firefoxos.sparseimage

Acessar o drive montado com:

cd /Volumes/firefoxos/

Feito isso é possível baixar o código e compilar a partir desse diretório sem se preocupar com problemas decorrentes do case sensivity.

Mountain Lion

Se você estiver compilando no OS X 10.8 "Mountain Lion" (Xcode 4.4.1 ou posterior) e encontrar o seguinte erro:

external/qemu/android/skin/trackball.c:130:25: error: 'M_PI' undeclared (first use in this function)
Edite o arquivo: B2G/external/qemu/makefile.android e adicione na linha 78:
MY_CFLAGS += -DM_PI=3.14159265358979323846264338327950288   #/* B2G_fix: not finding M_PI constant */

Pegadinha do homebrew no Mountain Lion

Se você estiver no Mountain Lion e receber um erro durante a instalação de dependências no homebrew como:
clang: error: unable to execute command: Segmentation fault: 11
... tente reinstalar as dependências manualmente adicionando o parâmetro --use-gcc, por exemplo:
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!

Note: Se você tem o aplicativo Samsung Kies instalado na sua máquina, que é utilizado para gerenciar o conteúdo de muitos telefones Samsung, você precisará removê-lo antes de copiar o Firefox OS no seu telefone. Você pode usar o aplicativo padrão de remoção de programas no Windows. No Mac, a imagem de instalação do Kies tem um aplicativo que remove completamente o Kies do seu computador. A cópia do Sistema (Flashing) não funcionará se o Kies estiver instalado. Se você esquecer de remover o Kies, o procedimento de compilação detectará e o avisará para desinstalá-lo. Observer também que o utilitário de desinstalação não remove corretamente o diretório ~/Library/Application Support/.FUS, e deixa uma referência para um utilitário na lista de inicialização do usuário. Será necessário remover isso manualmente.

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.

Então, você precisa instalar o pacote Android SDK starter package para sua plataforma. Após instalar, execute o gerenciador de pacotes $SDK_HOME/tools/android, use a GUI (Graphic User Interface) para instalar o "Android SDK Platform-tools".

adb será então instalado em $SDK_HOME/platform_tools. Certifique-se de adicionar esse diretório ao seu PATH. Isso pode ser feito adicionando essa linha no arquivo ~/.bashrc ou equivalente:

PATH=$SDK_HOME/platform_tools:$PATH

substituindo $SDK_HOME com o diretório onde o SDK do Android foi instalado. 

Para fazer uma cópia de segurança da partição do sistema do seu telefone, execute o seguinte comando:

adb pull /system <diretório destino>/system

Isso irá criar uma cópia dos BLOBS do Android no caso de você apagar sua árvore B2G. Dependendo do telefone, você precisará copiar os diretórios /data e/ou /vendor.

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

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.

Nota: Novamente, é importante frisar que isso somente é necessário para instalação do Firefox OS no Samsung Galaxy S2.

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 tamanho padrão do cache é 1GB. O B2G facilmente irá saturar isso. Você pode configurar o tamanho do cache dessa forma:

$ ccache --max-size 2GB

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

Nota: Essa seção é específica para Linux; Mac OS X tem as permissões de acesso ao dispositivo já configuradas.

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"

Se o arquivo não existir, crie-o. O diretório rules.d normalmente possui permissão apenas de leitura como padrão, então você deve usar chmod para alterar a permissão do diretório, do arquivo ou ambos.

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. Por exemplo, no Ubuntu:

sudo service udev restart

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

Nota: Você deve fazer isso antes de compilar seu dispositivo caso você nnao tenha uma cópia de segurança do sistema. Algumas bibliotecas são referenciadas em tempo de compilação, essas bibliotecas podem ser proprietárias e nós não podemos fornecer seu código fonte.

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

Vocie 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ê configuou 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!

Anexos

Arquivo Tamanho Data Anexado por
Xcode Downloads Command Line Tools
Screenshot of Xcode Downloads Command Line Tools
100455 bytes 2013-01-02 14:44:13 groovecoder

Document Tags and Contributors

Contributors to this page: tessomc, teoli, rbrandao
Última atualização por: rbrandao,
Esconder painel