mozilla
Os seus resultados da pesquisa

    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.

    Nota: Para compilar o Firefox OS para um telefone, comece com seu telefone SEM CONECTÁ-LO ao seu computador. Nós o avisaremos quando tiver que plugá-lo.

    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.

    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.
    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
    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 Flame e Nexus 5 libxml2-utils

    Se você está compilando para o dispositivo de referência Flame ou para o Nexus 5, antes de iniciar você deve executar o seguinte comando no terminal:

    sudo apt-get install libxml2-utils

    Botão Home: botão físico versus botão por software versus gesto

    Todos os dispositivos nível 1 possuem um botão home físico que leva o usuário para a tela de início. Muitos dispositivos baseados no Android ICS usam botões de toque na tela para a navegação. Nós temos um botão home virtual para os dispositivos que não possuem um botão físico. Se não estiver habilitado automaticamente, vá para o aplicativo Preferências em Configurações do desenvolvedor e ative a opção Botão home por software.

    Dispositivos do nível 2 e 3 possuem botão home por software.

    A partir da versão 1.4 do Firefox OS existe também a opção de "Habilitar Gesto para Home", ao habilitar essa opção o botão home será removido da tela e para ir para a tela de início o usuário deve deslizar o dedo na tela de baixo para cima.

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

    Baixe o tarball e instale-o no diretório /opt, com o seguinte comando 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
    

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

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

    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.

    Compatibilidade de versões do OS X 10.9.x
      emulador (ICS) emulador-jb (JB-4.2) emulador-kk (KitKat-4.4) flatfish (JB-4.2)
    XCode 4.3.3 X X X X
    XCode 4.4.1 X O O O
    XCode 4.5.2 X O O O
    XCode 4.6.3 X O O O
    XCode 5.0.2 X O O X
    XCode 5.1.1 X O O 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.

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

    Nota: O XCode 4.2.x ou anteriores não é compatível com OS X 10.9 ou superior, e XCode 4.3.x não possui plataforma SDK para 10.8. Instale uma nova versão. Se você está trabalhando no flatfish, certifique-se de ter disponível XCode 4.4, 4.5, ou 4.6.

    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

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

    Tornando o OS X 10.6 SDK disponível

    O SDK necessário está disponível em:

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

    Se não for encontrado você precisa extrair e copiá-lo do Xcode 4.3. Para fazer isso:

    1. Baixe o arquivo XCode 4.3 .dmg file do portal Apple Developer (você vai precisar de uma conta de desenvolvedor Apple).
    2. Baixe o utilitário Pacifist e use-o para extrai o SDK 10.6 SDK do arquivo XCode 4.3 .dmg. Clique no botão "Open Package", encontre do SDK procurando pela string 10.6 no campo de procura, selecione o diretório "MacOSX10.6.sdk" e extraia-o para um local adequado com o botão "Extract To...".
    3. Adicione um link simbólico no diretório /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/ para o local do 10.6 SDK. Por exemplo, se você copiar o 10.6 SDK no seu desktop o comando para criar o link simbólico será:
    ln -s /Users/<yourusername>/Desktop/MacOSX10.6.sdk /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/

    Nota: Isso não é necessário no OS X 10.9 ou superior, uma vez que 10.6 SDK é para o ICS e ICS não suporta OS X 10.9.

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

    Como padrão, o 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. Nosso arigo Instalando o ADB explica como instalar o adb.

    Observação para quando você for usar o adb: o adb necessita que a tela esteja desbloqueada para você ver o telefone (ao menos nas versões mais recentes do Firefox OS). Você provavelmente irá preferir desabilitar o bloqueio de tela (nós veremos mais tarde como fazer isso nas instruções de compilação).

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

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

    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"

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

    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

    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.

    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!

    Etiquetas do documento e colaboradores

    Contribuíram para esta página: tessomc, teoli, MatCAlves, gutierri, rbrandao
    Última atualização por: gutierri,
    Esconder painel