initial commit

12 files changed, 1073 insertions, 0 deletions

diff --git a/files/pt-br/archive/b2g_os/debugging/conectando_um_dispositivo_com_firefox_os_no_desktop/index.html b/files/pt-br/archive/b2g_os/debugging/conectando_um_dispositivo_com_firefox_os_no_desktop/index.html
new file mode 100644
index 0000000000..5226b777ed
--- /dev/null
+++ b/files/pt-br/archive/b2g_os/debugging/conectando_um_dispositivo_com_firefox_os_no_desktop/index.html
@@ -0,0 +1,38 @@
+---
+title: Conectando um dispositivo com Firefox OS no desktop
+slug: Archive/B2G_OS/Debugging/Conectando_um_dispositivo_com_Firefox_OS_no_desktop
+translation_of: Archive/B2G_OS/Debugging/Connecting_a_Firefox_OS_device_to_the_desktop
+---
+<div class="summary">
+ <p><span class="seoSummary"><span id="result_box" lang="pt"><span class="hps">Este guia</span> <span class="hps">explica como conectar</span> <span class="hps">um dispositivo</span> <span class="hps">Firefox</span> <span class="hps">OS</span> <span class="hps">em seu desktop</span> <span class="hps">através do USB.</span></span></span></p>
+</div>
+<div class="note">
+ <p><strong>Nota</strong>: Se você quiser apenas depurar aplicações em um dispositivo com Firefox OS e estiver executando uma versão do Firefox 1.2 ou superior. Sua melhor opção é usar o App Manager. Leia o artigo <a href="https://developer.mozilla.org/pt-BR/docs/Mozilla/Firefox_OS/Usando_o_App_Manager">Usando o App Manager</a> para mais detalhes. Se sua versão for inferior à 1.2, leia <a href="https://developer.mozilla.org/pt-BR/docs/Mozilla/Firefox_OS/Debugging/Configurando">Configurando o Firefox OS para depurar usando as ferramentas de desenvolvimento do Firefox</a> para aprender sobre o uso da depuração remota padrão.</p>
+</div>
+<h2 id="Configurar_o_dispositivo">Configurar o dispositivo</h2>
+<p>No seu Firefox OS (<a href="/en-US/docs/Mozilla/Firefox_OS/Debugging/Developer_settings#The_Developer_panel">ver a ilustração</a>):</p>
+<ol>
+ <li>Abrir o aplicativo Configurações, em seguida: <code>Informações</code> &gt; <code>Mais Informações</code> &gt; <code>Desenvolvedor</code>.</li>
+ <li>No menu de desenvolvedores, marque a opção: "Depuração Remota".</li>
+</ol>
+<h2 id="Configurar_o_Desktop">Configurar o Desktop</h2>
+<p>Para conectar o dispositivo ao desktop, você precisa do <a class="external" href="http://developer.android.com/tools/help/adb.html" title="http://developer.android.com/tools/help/adb.html">Android Debug Bridge (adb)</a> instalado. Note que o <a href="https://developer.mozilla.org/en-US/docs/Tools/Firefox_OS_Simulator" title="/en-US/docs/Tools/Firefox_OS_Simulator">Simulador do Firefox OS</a> adiciona o pacote <em>adb</em> para você.</p>
+<p>As instruções para a criação do seu ambiente de trabalho são específicas para o seu sistema operacional e são detalhadas no ponto 3 do <a class="external" href="https://developer.android.com/tools/device.html" title="https://developer.android.com/tools/device.html">"Configurando um Dispositivo para Desenvolvimento (em inglês)"</a> no site do desenvolvedor Android. Nós listamos algumas instruções adicionais abaixo.</p>
+<h3 id="Instruções_Especiais_para_Mac_OS_X">Instruções Especiais para Mac OS X</h3>
+<p>Se você estiver executando o Mac OS X, você deve ter baixado um pacote com um nome longo <code>adt-bundle-mac-x86_64-20130522</code>. Coloque essa pasta dentro de <em>Applications</em>, de moto que você tenha <code>/Applications/adt-bundle-mac-x86_64-20130522/</code> que contém dois diretórios: <code>eclipse</code> e <code>sdk</code>. Depois, você pode editar seu <code>~/.bashrc</code> e adicionar:</p>
+<pre>export PATH="/Applications/adt-bundle-mac-x86_64-20130522/sdk/platform-tools:$PATH"</pre>
+<p><span id="result_box" lang="pt"><span class="hps atn">(</span><span>Ele estará pronto</span> <span class="hps">na próxima vez</span> <span class="hps">que você iniciar o</span> <span class="hps">shell)</span><span>.</span> <span class="hps">Agora você pode</span> <span class="hps">digitar no</span> <span class="hps">CLI</span> <span class="hps">do</span> <span class="hps">shell:</span></span></p>
+<pre>adb devices
+</pre>
+<p><span id="result_box" lang="pt"><span class="hps">e ele irá retornar</span> <span class="hps">uma lista de</span> <span class="hps">dispositivos conectados</span><span>, tais como:</span></span></p>
+<pre>List of devices attached
+AA:BB:A5:B5:AA:BB    device</pre>
+<h3 id="Instruções_Especiais_para_Linux">Instruções Especiais para Linux</h3>
+<p>Se você estiver executando o Linux, a identificação do fornecedor para usar os dispositivos Geeksphone com Firefox OS é <code>05c6</code>, assim seu arquivo <code>/etc/udev/rules.d/51-android.rules</code> deverá conter uma entrada similar a:</p>
+<pre class="bash" style="font-family: monospace;"><span style="color: #007800;">SUBSYSTEM</span>==”usb”, ATTR<span style="color: #7a0874; font-weight: bold;">{</span>idVendor<span style="color: #7a0874; font-weight: bold;">}</span>==”05c6”, <span style="color: #007800;">MODE</span>=”0666”, <span style="color: #007800;">GROUP</span>=”plugdev”</pre>
+<h3 id="Instruções_Especiais_para_Windows">Instruções Especiais para Windows</h3>
+<p>Você pode realizar download dos drivers para Windows através do site da fabricante <a href="http://www.geeksphone.com/downloads/fos/fos_usb_driver.zip" title="http://www.geeksphone.com/downloads/fos/fos_usb_driver.zip">Geeksphone</a>.</p>
+<p>Se você utiliza o Windows 8, por padrão ele não permitirá a instalação de drivers sem assinatura. Para isso veja um tutorial em <a href="http://www.craftedge.com/tutorials/driver_install_windows8/driver_install_win8.html" title="http://www.craftedge.com/tutorials/driver_install_windows8/driver_install_win8.html">"<span id="result_box" lang="pt"><span class="hps">Como</span> <span class="hps">instalar</span> <span class="hps">um driver não assinado</span> <span class="hps">no Windows</span> <span class="hps">8 (em inglês)</span></span>"</a>.</p>
+<p>Uma vez que o Windows XP Home Edition não possui o arquivo <code>tasklist.exe</code>, o simulador pode não detectar o dispositivo. Isso pode ser solucionado baixando esse arquivo do site <a href="http://www.computerhope.com/download/winxp.htm">ComputerHope</a> e colocá-lo na pasta <code>Windows\System32</code>.</p>
+<h2 id="Verificando_sua_Configuração">Verificando sua Configuração</h2>
+<p>Depois de ter seguido as instruções, conecte o dispositivo no computador usando o cabo USB, abra um prompt de comando e digite "<code>adb devices</code>" (<span id="result_box" lang="pt"><span>garantindo que</span> <span class="hps">adb</span> <span class="hps">está no seu caminho</span></span>). <span id="result_box" lang="pt"><span class="hps">Você deverá ver</span> <span class="hps">o seu dispositivo</span> <span class="hps">Firefox</span> <span class="hps">OS</span> <span class="hps">listado na saída</span><span>.</span></span></p>
diff --git a/files/pt-br/archive/b2g_os/debugging/configurando/index.html b/files/pt-br/archive/b2g_os/debugging/configurando/index.html
new file mode 100644
index 0000000000..6d2b1f4d48
--- /dev/null
+++ b/files/pt-br/archive/b2g_os/debugging/configurando/index.html
@@ -0,0 +1,39 @@
+---
+title: >-
+  Configurando o Firefox OS para depurar usando as ferramentas de
+  desenvolvimento do Firefox
+slug: Archive/B2G_OS/Debugging/Configurando
+translation_of: Archive/B2G_OS/Debugging/Setting_up
+---
+<div class="summary">
+ <p><span id="result_box" lang="pt"><span class="hps">O</span> <span class="hps">Firefox</span> <span class="hps">OS suporta</span> <span class="hps">o mesmo protocolo de</span> <span class="hps">depuração remota</span><span class="hps"> presente no Firefox</span> para<span class="hps"> Android.</span></span> <span id="result_box" lang="pt"><span class="hps">Isto significa que você</span> <span class="hps">pode usar as</span> <span class="hps">ferramentas de desenvolvimento do</span> <span class="hps">Firefox</span> <span class="hps">para depurar aplicativos</span> do <span class="hps">Gaia</span> <span class="hps">executado em um dispositivo</span> <span class="hps">Firefox</span> <span class="hps">OS</span> <span class="hps">ou simulador. <span id="result_box" lang="pt"><span class="hps">Para</span> <span class="hps">depurar</span> <span class="hps">o Firefox</span> <span class="hps">OS</span> <span class="hps">rodando no seu</span> <span class="hps">dispositivo ou no</span> <span class="hps">Firefox</span> <span class="hps">OS</span> <span class="hps">Simulator,</span> <span class="hps">você precisa usar</span> <span class="hps">o Firefox</span> <span class="hps">18</span> <span class="hps">ou superior</span> <span class="hps">e, além disso</span><span>, existem</span> <span class="hps">configurações</span> <span class="hps">que precisam ser</span> <span class="hps">alteradas, tanto</span> <span class="hps">na configuração do Firefox quanto </span><span class="hps">no dispositivo</span> <span class="hps">Firefox</span> <span class="hps">OS</span> <span class="hps">ou</span> <span class="hps">simulador</span><span>.</span></span></span></span></p>
+</div>
+<div class="note">
+ <p><strong>Nota</strong>: <span id="result_box" lang="pt"><span class="hps">Se</span> <span class="hps">você deseja depurar</span> <span class="hps">aplicações</span> <span class="hps">em um dispositivo</span> com <span class="hps">Firefox</span> <span class="hps">OS</span><span class="hps"> em versão 1.2</span> <span class="hps">ou superior.</span><span> Sua melhor opção</span> <span class="hps">é usar o</span> </span><a href="/pt-BR/docs/Mozilla/Firefox_OS/Usando_o_App_Manager">App Manager</a>.</p>
+</div>
+<h2 id="Firefox">Firefox</h2>
+<p><span id="result_box" lang="pt"><span class="hps">Você</span> <span class="hps">precisa ter certeza de</span> <span class="hps">que você tem</span> <span class="hps">uma versão do</span> <span class="hps">Firefox</span> <span class="hps">18</span> <span class="hps">ou superior</span><span>, a fim de</span> <span class="hps">ter suporte</span> <span class="hps">à depuração remota</span><span>.</span> <span class="hps">Se você</span> <span class="hps">ainda não tem</span> <span class="hps">uma versão</span> <span class="hps">recente</span><span>, baixe</span> <span class="hps">a última versão</span> </span><a href="http://nightly.mozilla.org/" title="http://nightly.mozilla.org/">Nightly</a> <span id="result_box" lang="pt"><span class="hps">para obter</span> <span class="hps">acesso à todos os</span> <span class="hps">recursos mais recentes.</span></span></p>
+<p>Uma vez que você esteja executando uma versão apropriada do Firefox em seu computador, digite <code>about:config</code> na barra de endereços, aceite o termo e pesquise por <code>devtools.debugger.remote-enabled</code> em seguida altere o seu valor para <code>true</code>. Feito isso, você deve reiniciar o seu navegador para que a depuração remota seja de fato habilitada. Após reiniciar o Firefox, no menu Desenvolvedor Web você verá uma nova opção, <code>Ferramentas</code> &gt; <code>Conectar</code>.</p>
+<h2 id="Habilitando_a_depuração">Habilitando a depuração</h2>
+<p><span id="result_box" lang="pt"><span class="hps">Ao usar o</span> <a href="/pt-BR/docs/Tools/Simulador_Firefox_OS"><span class="hps">Firefox</span> <span class="hps">OS</span> <span class="hps">Simulator</span></a> <span class="hps">(</span><span class="hps">B2G</span> <span class="hps">Desktop)</span><span>, a configuração</span> para <span class="hps">depuração</span> <span class="hps">é muito fácil.</span> <span class="hps">Você não</span> <span class="hps">precisa fazer</span> <span class="hps">encaminhamento de porta</span><span>, como você faz</span> <span class="hps">quando a depuração</span> é <span class="hps">em um dispositivo</span> <span class="hps">físico.</span> </span>Basta abrir o aplicativo Configurações, em seguida: <code>Informações</code> &gt; <code>Mais Informações</code> &gt; <code>Desenvolvedor</code> ative <em><code>Depuração remota</code></em>.</p>
+<div class="warning">
+ <p>Nota: Isso não funciona mais em dispositivos com Firefox OS desde 10 de Janeiro de 2013. <span id="result_box" lang="pt"><span class="hps">Eventualmente, haverá</span> <span class="hps">uma maneira de</span> <span class="hps">construir a sua própria</span> <span class="hps">compilação com</span> <span class="hps">ele</span> <span class="hps atn">re-</span><span>ativado,</span> <span class="hps">mas isso</span> <span class="hps">ainda não existe</span><span>.</span> <span class="hps">Este documento será</span> <span class="hps">atualizado assim que </span><span class="hps">acontecer.</span> <span class="hps">Além disso,</span> <span class="hps">a preferência</span> <span class="hps">para desligar</span> <span class="hps">o suporte</span> <span class="hps">"out-of</span><span>-process"</span> <span class="hps">foi removido.</span> <span class="hps">Por enquanto</span><span>, você</span> <span class="hps">precisa fazer a sua</span> <span class="hps">depuração no</span> <span class="hps">Firefox</span> <span class="hps">OS</span> <span class="hps">Simulator.</span></span></p>
+</div>
+<p>Se estiver usando um dispositivo com Firefox OS, abra as <a href="/pt-BR/docs/Mozilla/Firefox_OS/Debugging/Configura%C3%A7%C3%B5es_do_Desenvolvedor">Configurações do Desenvolvedor</a> e:</p>
+<ul>
+ <li>Ativar a <em>Depuração Remota</em>.</li>
+ <li><span id="result_box" lang="pt"><span class="hps">Desativar o suporte<em> Out-of-process</em></span><span>,</span> <span class="hps">até</span> {{bug(797627)}}<span class="hps"> é fixo.</span> <span class="hps">Se não </span><span class="hps">fazer isto,</span> <span class="hps">apenas</span> <span class="hps">os scripts</span> <span class="hps">do sistema poderão ser</span> <span class="hps">depurados.</span></span></li>
+</ul>
+<div class="note">
+ <p><strong>Nota:</strong> <span id="result_box" lang="pt"><span class="hps">Se você</span> aplicar as definições de fábrica n<span class="hps">o dispositivo,</span> <span class="hps">você terá que</span> <span class="hps">refazer</span> <span class="hps">essas alterações de configuração</span><span>.</span></span></p>
+</div>
+<p><span class="short_text" id="result_box" lang="pt"><span class="hps">Agora</span> <span class="hps">você está pronto para</span> <span class="hps">usar o <a href="/pt-BR/docs/Tools/Depurador">depurador</a></span><span>!</span></span></p>
+<h2 id="Habilitando_o_log_do_console_em_um_dispositivo_Firefox_OS"><span id="result_box" lang="pt"><span class="hps">Habilitando o log</span> <span class="hps">do console</span> <span class="hps">em um dispositivo</span> <span class="hps">Firefox</span> <span class="hps">OS</span></span></h2>
+<p><span id="result_box" lang="pt"><span class="hps">Na</span> <span class="hps">produção de</span> <span class="hps">versões do Firefox</span> <span class="hps">OS</span><span>, o log do</span> <span class="hps atn">console (</span><span>por exemplo</span> <span>{{domxref("console.log()")}}) é</span> <span class="hps">desativado por padrão.</span> <span class="hps">Para</span> <span class="hps">ativá-lo,</span> <span class="hps">vá para <a href="https://developer.mozilla.org/pt-BR/docs/Mozilla/Firefox_OS/Debugging/Configura%C3%A7%C3%B5es_do_Desenvolvedor">Configurações</a></span><a href="/pt-BR/docs/Mozilla/Firefox_OS/Debugging/Configura%C3%A7%C3%B5es_do_Desenvolvedor"> <span class="hps">do Desenvolvedor</span></a> <span class="hps">no seu dispositivo</span> <span class="hps">e</span> <span class="hps">habilite</span> <em>Console Ativado</em>.</span></p>
+<p>Nota: Leia o artigo <a href="/en-US/docs/Mozilla/Firefox_OS/Debugging/On-device_console_logging">On-device console logging</a> para mais detalhes sobre como usar o console logging on Firefox OS.</p>
+<h2 id="Veja_também">Veja também</h2>
+<ul>
+ <li><a href="/pt-BR/docs/Mozilla/Firefox_OS/Debugging" title="/en-US/docs/Mozilla/Firefox_OS/Debugging">Depurando no Firefox OS</a></li>
+ <li><a href="/pt-BR/docs/Tools/Depurador" title="/en-US/docs/Tools/Debugger">Depurador</a></li>
+ <li><a href="/pt-BR/docs/Mozilla/Firefox_OS/Debugging/Configura%C3%A7%C3%B5es_do_Desenvolvedor" title="/en-US/docs/Mozilla/Firefox_OS/Debugging/Developer_settings">Configurações do Desenvolvedor para Firefox OS</a></li>
+</ul>
diff --git a/files/pt-br/archive/b2g_os/debugging/configurações_do_desenvolvedor/index.html b/files/pt-br/archive/b2g_os/debugging/configurações_do_desenvolvedor/index.html
new file mode 100644
index 0000000000..de82a2026d
--- /dev/null
+++ b/files/pt-br/archive/b2g_os/debugging/configurações_do_desenvolvedor/index.html
@@ -0,0 +1,164 @@
+---
+title: Configurações do Desenvolvedor para Firefox OS
+slug: Archive/B2G_OS/Debugging/Configurações_do_Desenvolvedor
+translation_of: Archive/B2G_OS/Debugging/Developer_settings
+---
+<div class="summary">
+ <p><span class="seoSummary">O painel do desenvolvedor fica dentro do aplicativo de configurações do Firefox OS. Este painel oferece uma série de opções que podem tornar <span id="result_box" lang="pt"><span class="hps gt-trans-draggable">a depuração de sua</span> <span class="hps gt-trans-draggable">aplicação web</span> <span class="hps gt-trans-draggable">no</span> <span class="hps gt-trans-draggable">Firefox</span> <span class="hps gt-trans-draggable">OS</span> <span class="hps gt-trans-draggable">mais fácil</span></span>.</span> <span id="result_box" lang="pt"><span class="hps">Este artigo aborda</span> <span class="hps">as opções disponíveis</span> <span class="hps">e</span> <span class="hps">como fazer</span> <span class="hps">uso deles.</span></span></p>
+</div>
+<p><span id="result_box" lang="pt"><span class="hps">O</span> <span class="hps">painel de configurações</span> <span class="hps">para as opções de</span> <span class="hps">desenvolvedor</span> <span class="hps">é intencionalmente</span> <span class="hps">"trancando a sete chaves"</span> <span class="hps">para evitar que</span> <span class="hps">os usuários finais</span> <span class="hps">que não têm necessidade</span> <span class="hps">de fazer uso dessas opções</span><span>, inadvertidamente,</span> <span class="hps">realizem a ativação de opções</span> <span class="hps">que farão o </span><span class="hps">dispositivo</span> <span class="hps">funcionar mais</span> <span class="hps">lentamente</span> <span class="hps">ou adicionar</span> <span class="hps">efeitos visuais</span> <span class="hps">estranhos</span> <span class="hps">as suas telas</span><span class="hps">.</span> <span class="hps">O painel</span> <span class="hps">é algo como</span> <span class="hps atn">isto (</span><span>o</span> <span class="hps">que se segue é</span> uma captura de tela retirada de um Geeksphone Keon com Firefox OS 2.0 em abril de 2014, a sua versão pode apresentar algumas diferenças<span class="hps">):</span></span></p>
+<p><img alt="" src="https://mdn.mozillademos.org/files/7801/developermenu-short.png" style="width: 320px; height: 480px; display: block; margin: 0px auto;"></p>
+<p><span id="result_box" lang="pt"><span class="hps">O painel de</span> <span class="hps">desenvolvedor</span> <span class="hps">é acessado</span> <span class="hps">da seguinte forma:</span></span></p>
+<ul>
+ <li>Em versões inferiores ao Firefox OS 1.4, você pode abrir o painel do desenvolvedor via <em>Configurações &gt; Informações do Dispositivo &gt; Mais Informações &gt; Desenvolvedor</em>.</li>
+ <li>Em versões superiores ao Firefox 1.4, você pode abrir o painel do desenvolvedor via <em>Configurações &gt; Informações do Dispositivo &gt; Mais Informações &gt; <span class="short_text" id="result_box" lang="pt"><span class="hps">Marque a caixa</span> <span class="hps">de menu</span> <span class="hps">desenvolvedor</span></span></em>. Feito isso, você pode acessar o painel do desenvolvedor via <em>Configurações &gt; Desenvolvedor</em>.</li>
+</ul>
+<p><span id="result_box" lang="pt"><span class="hps">As</span> <span class="hps">seções a seguir abordam</span> <span class="hps">cada uma das</span> <span class="hps">opções presentes no painel do desenvolvedor</span><span class="hps">.</span> <span class="hps">Explicando</span> <span class="hps">o que elas fazem</span> <span class="hps">e descrevendo suas utilidade</span><span>s.</span></span></p>
+<div class="note">
+ <p><strong>Nota do tradutor</strong>: Nem todas as opções de configuração estão traduzidas na versão em Português-BR dos dispositivos. Os títulos das opções a seguir estão de acordo com os títulos encontrados no dispostivo.</p>
+</div>
+<h2 id="Configurações_das_ferramentas_de_desenvolvimento">Configurações das ferramentas de desenvolvimento</h2>
+<h3 id="Depurando_via_USB"><a name="Debugging_via_USB"></a>Depurando via USB</h3>
+<p><a name="Remote_debugging"></a>A opção "Depuração Remota" habilita o suporte para <a href="https://developer.mozilla.org/pt-BR/docs/Tools/Debugger" title="/en-US/docs/Tools/Debugger">depurar remotamente </a>seu dispositivo Firefox OS. Isso também habilitar os comandos <a href="https://developer.mozilla.org/pt-BR/Firefox_OS/Debugging/Installing_ADB">ADB</a><strong>.</strong> Nas versões anteriores à 1.4 existe somente um checkbox, no Firefox 1.4 existem três opções disponíves em uma select box:</p>
+<ul>
+ <li>Desabilitado: Depuração remota desligada (padrão)</li>
+ <li>Somente ADB: Possibilita acesso ao dispositivo pelo ADB.</li>
+ <li>ADB e Devtools: Possibilita acesso ao dispositivo pelo ADB e pelas ferramentas de desenvolvimento do Firefox como o <a href="https://developer.mozilla.org/pt-BR/Firefox_OS/Using_the_App_Manager">App Manager</a>.</li>
+</ul>
+<h3 id="HUD_(Head_Up_Display)_do_desenvolvedor">HUD (<a href="http://pt.wikipedia.org/wiki/Head_up_display">Head Up Display</a>) do desenvolvedor</h3>
+<p>Disponível nas versões Firefox OS 1.4 e posteriores.</p>
+<p><img alt="" src="https://mdn.mozillademos.org/files/7803/developerhud-new.png" style="width: 320px; height: 480px; margin: 0px auto; display: block;"></p>
+<p>Existe um checkbox que você pode usar para habilitar ou desabilitar o HUD do Desenvolvedor (uma seção no tipo da Interface do Usuário do Firefox OS para mostrar informações para o desenvolvedor). São cinco checkboxes a serem habilitados ou desabilitados:</p>
+<ul>
+ <li><strong>L<strong>og changes in adb</strong></strong>: Habilita o log de alterações do dispositivo no adb logcat.</li>
+ <li><strong>Warnings</strong>: Mostra avisos do console.</li>
+ <li><strong>Errors</strong>: Mostra erros do console.</li>
+ <li><strong>Security issues</strong>: Mostra potenciais falhas de segurança.</li>
+ <li><strong>Reflows</strong>: Mostra refluxos quando ocorrem.</li>
+ <li><strong><a href="/pt-BR/Firefox_OS/Platform/Architecture#Jank">Jank</a>/Jank threshold</strong>: Notifica o usuário sobre ocorrências de alto <em>jank</em> (demora visível na renderização) o valor indica o limiar para o qual pode ser customizado.</li>
+ <li><strong>Frames per second</strong>: Mostra frames por segundo como explicado na seção {{ anch("Frames_per_second") }}.</li>
+ <li><strong>Time to load</strong>: Mostra o tempo para carregar a informação como explicado na seção {{ anch("Time_to_load") }}.</li>
+ <li><strong>App memory</strong>: Mostra o quanto de memória o aplicativo está utilizando, e possibilita habilitar ou desabilitar os diferentes fatores de uso da memória. Veja a seção {{ anch("App_memory") }} para maiores detalhes.</li>
+</ul>
+<h4 id="Frames_per_second">Frames per second</h4>
+<p>Ao habilitar essa opção serão apresentados três números no canto superior esquerdo da tela do Firefox OX, os valores são a média dos últimos resultados dentro de uma janela de tempo, podem ser considerados valores instantâneos com uma boa margem de erro. </p>
+<ul>
+ <li>O número da esquerda é a <strong>taxa de composição (<em>composition rate</em>)</strong>: número estimado de vezes por segundo que o Firefox OS desenha frames no <em>framebuffer</em> do hardware. É uma estimativa da percepção do usuário do <em>framerate</em>, e somente uma estimativa. Por exemplo, o contador pode reportar 60 composições por segundo mesmo sem a tela ter sido alterada. Nesse caso a percepção do usuário poderia ser 0. Porem, quando utilizado com esta ressalva e corroborado com outras medidas, o monitor pode ser uma ferramenta útil e simples.</li>
+ <li>O número do meio é a <strong>taxa de transação da camada (<em>layer transaction rate</em></strong>): número estimado de vezes por segundo que o processo monta a tela e notifica o compositor. Esse número é mais útil para os engenheiros da plataforma Gecko, e deve ser menor ou igual à taxa de composição apresentado à esquerda.</li>
+ <li>O número à direita é uma medida do número de pixels desenhados como um percentual do tamanho da tela. Por exemplo, o número 273 indica que a tela é escrita 2,73 vezes. Idealmente esse número deve estar o mais próximo de 100.</li>
+</ul>
+<p><img alt="A screenshot of Firefox OS, showing three numbers in the top left hand corner that are measurements of app framerate." src="https://mdn.mozillademos.org/files/6889/framerate-fxos.jpg" style="width: 357px; height: 640px; display: block; margin: 0px auto;"></p>
+<h4 id="Time_to_load">Time to load</h4>
+<p>Firefox OS também tem uma ferramenta que ajuda a medir o tempo de inicialização, especificamente o tempo do "<em>first paint</em>". O valor apresentado pela ferramenta — no canto superior direito da tela do Firefox OS — é o tempo decorrido (em milisegundos) entre o lançamento da aplicação mais recente e o momento estimado de quando a aplicação foi desenhada na Interface do Usuário. Esse número é aproximado ao real tempo de "<em>first paint</em>", e é particularmente subestimada. Porem, ao baixar este número quase sempre indica no tempo de inicialização real, por isso pode ser útil para medir melhorias na otimização.</p>
+<p><img alt="A screenshot of Firefox OS, showing a number in the top right hand corner that is a measurement of the current app startup time, in milliseconds." src="https://mdn.mozillademos.org/files/6891/startup-time-fxos.jpg" style="width: 378px; height: 640px; display: block; margin: 0px auto;"></p>
+<h4 id="App_memory">App memory</h4>
+<p>Mostra o quanto de memória o aplicativo está usando e possibilita habilitar ou desabilitar os diferentes itens que usam memória para mostrar o quanto de memória cada item desses usa no aplicativo corrente. Por exemplo, de acordo com a configuração apresentada na tela abaixo só será mostrado o uso de memória por objetos JS. O número no canto inferior direito indica que o aplicativo de configuração está usando 414.778KB para objetos JS.</p>
+<p><img alt="" src="https://mdn.mozillademos.org/files/7731/memory-usage.png" style="width: 320px; height: 480px; display: block; margin: 0px auto;"></p>
+<h3 id="Piscar_área_desenhada">Piscar área desenhada</h3>
+<p>Nesse modo, toda vez que uma região da tela é desenhada pelo Gecko, acontece uma piscada de uma cor randômica translúcida sobre a região desenhada. Idealmente, somente as partes da tela que mudaram visualmente piscarão com a nova cor. Mas algumas vezes uma área maior é necessária ser redesenhada, causando uma piscada em áreas maiores. Esse sintoma pode indicar que o código da aplicação está forçando uma atualização da tela maior que o necessário. Isso também pode indicar um bug no próprio Gecko.</p>
+<p><img alt="A screenshot of Firefox OS with a number of transparent overlays, showing the parts of the screen repainted with each new animation frame." src="https://mdn.mozillademos.org/files/6893/paint-update-fxos.jpg" style="width: 378px; height: 640px; display: block; margin: 0px auto;"></p>
+<h2 id="Configurações_gráficas">Configurações gráficas</h2>
+<h3 id="Habilitar_APZ_para_todo_conteúdo_(era_Async_PanZoom)">Habilitar APZ para todo conteúdo (era Async Pan/Zoom)</h3>
+<p>Quando habilitado, o módulo Async Pan/Zoom permite pan e zoom assíncrono, em outra thread, com algumas diferenças perceptíveis no comportamento de renderização. Para saber mais, leia o artigo <a href="https://wiki.mozilla.org/Platform/GFX/APZ">MozillaWiki APZ</a>.</p>
+<h3 id="Tiling_(era_Layers_Enable_tiles)">Tiling (era Layers: Enable tiles)</h3>
+<p>Introduzido no Firefox OS 1.4, esse recurso possibilita o desenho do conteúdo na tela em pedaços pequenos ("<em>tiles</em>") ao invés de desenhar a tela inteira de uma vez. Isso é útil para a área de QA (Quality Assurance) da plataforma envolvendo a redução de checkerboarding e encontrando janalas de regressão.</p>
+<h3 id="Simple_tiling_(era_Layers_Simple_tiles)">Simple tiling (era Layers: Simple tiles)</h3>
+<p>Inverte entre as duas implementações diferentes do desenho de conteúdo descritos na seção acima.</p>
+<h3 id="Hardware_composer_(era_Enable_hardware_compositing)">Hardware composer (era Enable hardware compositing)</h3>
+<p>Quando habilitado, faz o dispositivo usar o <a href="https://source.android.com/devices/graphics.html#hwc">Hardware Composer</a> para compor elementos visuais (superfícies) na tela.</p>
+<h3 id="Draw_tile_borders_(era_Layers_Draw_tile_borders)">Draw tile borders (era Layers: Draw tile borders)</h3>
+<p>Muito similar à opção {{ anch("Draw layer borders") }}, a diferença é que nessa opção são desenhadas bordas para os "tiles" individuais bem como as bordas ao redor das camadas.</p>
+<h3 id="Mostrar_layers">Mostrar layers</h3>
+<p>Desenha uma borda brilhande e colorida ao redor das diferentes camadas desenhadas na tela — bom para diagnosticar problemas de layout.</p>
+<p><img alt="A screenshot from Firefox OS showing an opened select form with the draw layers borders option enabled, resulting in colored borders being drawn on all the different rendered layers." src="https://mdn.mozillademos.org/files/6897/paint-layers-borders.png" style="width: 320px; height: 480px; display: block; margin: 0px auto;"></p>
+<h3 id="Dump_layers_tree">Dump layers tree</h3>
+<p>Essa opção faz uma cópia da árvore de camadas do compositor a ser enviado para o logcat a cada camada (layer) composto na tela. Isso é útil para verificar a performance gráfica da plataforma.</p>
+<h3 id="Cards_View_Cópia_de_tela">Cards View: Cópia de tela</h3>
+<p>Quando habilitado, cópias de tela serão feitas quando o usuário entrar na visão de cartões para visualizar os aplicativos abertos. Se desabilitado, ícones das aplicações serão mostrados no centro de cartões em branco durante a visão de cartões.</p>
+<h2 id="Configurações_do_gerenciamento_de_janelas">Configurações do gerenciamento de janelas</h2>
+<h3 id="Botão_Home_por_Software"><a name="Enable_software_home_button"></a>Botão Home por Software</h3>
+<p>Essa opção cria um botão Home por software que possui a mesma funcionalidade que o seu equivalente externo. A intenção é o uso em dispositivo que provavelmente não venham com botões externos, como em tablets.</p>
+<h3 id="Gesto_para_tela_de_início_ativado">Gesto para tela de início ativado</h3>
+<p>Ao habilitar essa opção o usuário pode arrastar o dedo do centro para fora da tela para abrir a tela de início. Isso fornece a mesma funcionalidade que o botão externo caso ele não esteja disponível.</p>
+<h3 id="Gesto_de_canto">Gesto de canto</h3>
+<p>Ao habilitar essa opção o usuário pode arrastar o dedo para esquerda ou direita a partir dos cantos para o centro para navegar entre as páginas (como acontece nas páginas do seu navegador, ou visões dentro de um aplicativo). Basicamente funciona como a barra de navegacão do Firefox.</p>
+<h3 id="Continuous_transition">Continuous transition</h3>
+<p>Possibilita você decidir se o teclado abra imediatamente ou continuamente (com uma transição). Desabilitar os efeitos da transição é útil para equipamentos low-end uma vez que pode degradar a performance.</p>
+<h3 id="App_transition">App transition</h3>
+<p>Habilita ou desabilita transições ao iniciar ou encerrar um aplicativo. Sem a transição os aplicativos serão apresentados imediatamente sem uma animação suave bem como o teclado. Assim como o item anterior, ao desabilitar os dispositivos low-end terão uma performance melhor.</p>
+<h3 id="App_suspending">App suspending</h3>
+<p>Se habilitado, quando um aplicativo for encerrado em segundo plano, ele permanecerá no histórico e será reaberto quando você abrí-lo na tela inicial ou visão de cartões. Se desabilitado os aplicativos não serão mantidos no histórico ou na visão de cartões.</p>
+<h2 id="Configuração_de_depuração">Configuração de depuração</h2>
+<h3 id="Reg._animaçõe_lentas">Reg. animaçõe lentas</h3>
+<p>Essa ferramenta tenta ajudar aos desenvolvedores entenderem porque as animações não são transferidas ao compositos para serem executadas o mais eficientemente possível. Registra "bugs" como tentar animar elementos que são muito grandes, ou tentar animar propriedades CSS que ão podem ser transferidas. As mensagens que você receberá no dispositivo são semelhantes a essas:</p>
+<pre class="language-html">I/Gecko   ( 5644): Performance warning: Async animation disabled because frame size (1280, 410) is bigger than the viewport (360, 518) [div with id 'views']
+</pre>
+<h3 id="Saída_Wi-Fi_para_adb">Saída Wi-Fi para adb</h3>
+<p>Ao habilitar essa opção informações sobre Wi-Fi são incluídas nos logs do adb (logs de erro podem ser acessados pelo console usando <code>adb logcat | grep "Error"</code>)</p>
+<h3 id="Bluetooth_output_in_adb">Bluetooth output in adb</h3>
+<p>Ao habilitar essa opção informações sobre Bluetooth são incluídas nos logs do adb (logs de erro podem ser acessados pelo console usando <code>adb logcat | grep "Error"</code>)</p>
+<h3 id="Console_ativado">Console ativado</h3>
+<p>Quando habilitado, essa opção permite usar o <a href="https://developer.mozilla.org/pt-BR/docs/Mozilla/Firefox_OS/Debugging/Using_the_Remote_Web_Console" title="/en-US/docs/Mozilla/Firefox_OS/Debugging/Using_the_Remote_Web_Console">Web Console</a> no Firefox para acessa remotamente o console do dispositivo, sem essa opção habilitada, a função {{domxref("console.log()")}} não faz nada.</p>
+<h3 id="Gaia_debug_traces">Gaia debug traces</h3>
+<p>Isso habilita diretamente DEBUG traces no Gaia; veja {{ bug("881672") }} para mais detalhes.</p>
+<div class="note">
+ <p><strong>Note</strong>: Infelizmente, nem todo aplicativo suporta esse mecanismo para gravar seu log de depuração. Ao invés disso, eles controlam a opção "DEBUG" diretamente no código, assm, ao habilitar essa opção não há como garantir que serão gerados todos os logs de depuração.</p>
+</div>
+<h3 id="Show_accessibility_settings">Show accessibility settings</h3>
+<p>Habilitar o menu de configurações de acessibilidade, que poderá ser acessado em <em>Configurações &gt; Accessibilidade</em>. As opções são as seguintes:</p>
+<h4 id="Leitor_de_Tela">Leitor de Tela</h4>
+<p>Essa opção transforma o Firefox OS em um leitor de tela. Atualmente em um estágio inicial ele altera o modo que os eventos de toque funcionam. Quando o leitor de tela está habilitado você pode interagir com a tela das seguintes maneiras:</p>
+<ul>
+ <li>Toque em qualquer lugar para transferir o foco para o aplicativo e seja avisado do que ele é. A notificação é feita tanto sonramente como por um retângulo ao redor do item selecionado. Um duplo toque em qualquer lugar da tela (dois toques numa rápida sucessão) ativa o ítem rodeado pelo retângulo.</li>
+ <li>Arraste o dedo da esquerda para a direita sequencialmente através dos itens na tela faz com que sejam movidos da esquerda para a direita, se for de cima para baixo, inclui um scroll vertical is houver mais itens a serem mostrados, e você será alertado do nome de cada item sonoramente e pelo retângulo. Da direita para a esquerda move os itens na ordem reversa. Novamente um toque duplo executa o item selecionado.</li>
+ <li>Arraste com dois dedos — esquerda, direita, para cima ou para baixo — para rolar a tela na direção desejada. Isso é equivalente a arrastar um dedo através da tela quando o leitor de tela não está ativo. Por exemplo, um arrasto com dois dedos para esquerda na tela inicial leva para a segunda tela, o mesmo movimento para cima rolará a tela para mostrar mais conteúdo.</li>
+</ul>
+<div class="note">
+ <p><strong>Nota</strong>: Se o leitor de tela estiver funcionando e você deseja desabilitá-lo, você deve navegar até as configurações através desses novos gestos e dar um toque duplo no checkbox uma vez para desligá-lo. O que vai restaurar o comportamento da tela sensível ao toque ao seu comportamento padrão.</p>
+</div>
+<p><strong>Nota</strong>: No Firefox 1.4 e superior, existe uma maneira rápida para ligar e desligar o leitor de tela. Ele o instruirá para que seja executada a mesma ação novamente (botões volume: cima, baixo, cima, baixo, cima, baixo) para ligar ou desligar.Assim, você pode testar sua aplicação web para acessibilidade sem ter que navegar no menu de preferências a cada vez que quiser alterá-la.</p>
+<h4 id="Speech_volume">Speech volume</h4>
+<p>Controle deslizante do volume da voz.</p>
+<h4 id="Speech_rate">Speech rate</h4>
+<p>Controle deslizante da velocidade da voz.</p>
+<h3 id="Abrir_a_primeira_utilização">Abrir a primeira utilização</h3>
+<p>Executa o programa de primeira configuração, que nada mais é que conduz o usuário à configurar as opções básicas e um tutorial. É útil quando você quer testar esse processo, ou se você quer reconfigurar seu dispositivo.</p>
+<h2 id="Configurações_obsoletas">Configurações obsoletas</h2>
+<p>Essa seção apresenta as configurações que não estão mais disponíveis, ou são apresentadas de uma forma diferente, mas pode ser interessante se estiver executando uma versão antiga do Firefox OS.</p>
+<h3 id="Accessibilidade">Accessibilidade</h3>
+<p>Nas versões anteriores à 1.4, essa opção apresentava as configurações explicadas na seção {{ anch("Show_accessibility_settings") }}.</p>
+<h3 id="Grid">Grid</h3>
+<p>Quando habilitada, a tela do Firefox era sobreposta por um grid padrão que ajudava o posicionamento e alinhamento dos itens. Abaixo um exemplo da tela com o grid ativado.</p>
+<p><img alt="" src="https://mdn.mozillademos.org/files/5071/Grid.png" style="width: 320px; height: 480px; display: block; margin: 0px auto;"></p>
+<p>As linhas mais largas são separadas por 32 pixels, tanto horizontal quanto verticalmente.</p>
+<h3 id="Show_frames_per_second">Show frames per second</h3>
+<p>Nas versões anteriores à 1.4 ao  habilitar essa opção mostrava os frames por segundo como explicado na seção {{ anch("Frames_per_second") }}.</p>
+<h3 id="Show_time_to_load">Show time to load</h3>
+<p>Nas versões anteriores à 1.4 ao  habilitar essa opção mostrava o tempo para carregar a informação como explicado na seção {{ anch("Time_to_load") }} .</p>
+<h3 id="Rocketbar_enabled">Rocketbar enabled</h3>
+<p>Nas versões anteriores à 1.4, essa opção habilita o novo <a href="https://groups.google.com/forum/#%21topic/mozilla.dev.gaia/Nlfbrq1KMP0">Firefox Rocketbar</a> no seu dispositivo, que fornece uma nova forma de trocar entre aplicativos, procurar e mais. Você pode encontrar um ícono no canto superior esquerdo do dispositivo e o RocketBar pode executá-lo arrastando do canto superior esquerdo para o canto inferior esquerdo.</p>
+<div class="note">
+ <p><strong>Nota</strong>: Nas novas versões do Firefox OS, Rocketbar é habilitado automaticamente e não pode ser desabilitado.</p>
+</div>
+<h3 id="Contacts_debugging_output_in_adb">Contacts debugging output in adb</h3>
+<p>Ao habilitar essa opção informações sobre contatos são adicionadas ao log do adb (logs de erro podem ser acessados digitando <code>adb logcat | grep "Error"</code> no terminal.)</p>
+<h3 id="Progressive_paint_(era_Layers_Progressive_paint)">Progressive paint (era Layers: Progressive paint)</h3>
+<p>Essa opção foi introduzida para ajudar a depuração do <a href="https://wiki.mozilla.org/Platform/GFX/APZ">módulo Async Panning/Zoom module</a> (APZ) durante sua implementação. Agora que a implementação está pronta, essa opção está obsoleta e será removida das próximas versões (veja {{ Bug("1003228") }}).</p>
+<h3 id="Displayport_Heuristics">Displayport Heuristics</h3>
+<ul>
+ <li>Default</li>
+ <li>Center displayport</li>
+ <li>Assume perfect paints</li>
+ <li>Taller displayport</li>
+ <li>Faster paints</li>
+ <li>No checkerboarding</li>
+</ul>
+<p>Essas opções foram introduzidas para ajudar a depuração do <a href="https://wiki.mozilla.org/Platform/GFX/APZ">Async Panning/Zoom module</a> (APZ) durante sua implementação especificamente para possibilitar a equipe de QA testar diferentes heurísticas para verificar qual resultado era o melhor. gora que a implementação está pronta, essa opção está obsoleta e será removida das próximas versões (veja {{ Bug("1003228") }}).</p>
+<h2 id="Keyboard_layouts">Keyboard layouts</h2>
+<p>Adicionalmente às opções específicas para desenvolvedores as versões anteriores à 1.4 apresentava opções de teclado. Isso permitia a realização de testes dos métodos de entrada do idioma chinês:</p>
+<p><img alt="" src="https://mdn.mozillademos.org/files/5079/InputMethods.png"></p>
+<p>No Firefox 1.4, essas opções foram removidas. Isso é porque a implementação de layout de teclados chineses (zhuyin and pinyin) não terminaram.</p>
+<div class="note">
+ <p><strong>Note</strong>: Para outros layoutes de teclado que ainda estão em desenvolvimento, como o japonês por exemplo, existe uma opção em tempo de compilação para incluí-los na imagem.</p>
+</div>
+<p> </p>
diff --git a/files/pt-br/archive/b2g_os/debugging/debugging_b2g_using_valgrind/index.html b/files/pt-br/archive/b2g_os/debugging/debugging_b2g_using_valgrind/index.html
new file mode 100644
index 0000000000..78082a8793
--- /dev/null
+++ b/files/pt-br/archive/b2g_os/debugging/debugging_b2g_using_valgrind/index.html
@@ -0,0 +1,88 @@
+---
+title: Depurando o B2G usando Valgrind
+slug: Archive/B2G_OS/Debugging/Debugging_B2G_using_valgrind
+translation_of: Archive/B2G_OS/Debugging/Debugging_B2G_using_valgrind
+---
+<p><span style="position: fixed ! important; top: 0px ! important; left: 0px ! important; font-size: xx-small ! important; line-height: 130% ! important; border-color: black ! important; border-width: 1px ! important; border-style: solid ! important; padding: 0px 2px ! important; background-color: rgb(214, 227, 254) ! important; display: none;">S</span></p>
+<div class="summary">
+ <p><a href="http://valgrind.org">Valgrind<span style="font-family: arial,sans-serif; font-size: xx-small ! important; line-height: 130% ! important; border-width: 1px ! important; border-style: solid ! important; padding: 0px 2px ! important; margin-left: 2px; max-width: 20px; overflow: visible ! important; float: none ! important; display: none;">DSS</span></a> dá acesso aos desenvolvedores à informações sobre alocação de memória, threads/processos, e outras coisas relevantes à performance do programa. Está incluído na árvore do Firefox OS, e pode ser executado por telefones que tem os recursos adequados. Esse artigo explica como usá-lo.</p>
+</div>
+<h2 id="Requisitos">Requisitos</h2>
+<p>Antes de executar o Valgrind no Firefox OS, é recomendado que os desenvolvedores familiarizem-se com o artigo <a href="/pt-BR/docs/Debugging_Mozilla_with_Valgrind">Depurando Mozilla com Valgrind<span style="font-family: arial,sans-serif; font-size: xx-small ! important; line-height: 130% ! important; border-width: 1px ! important; border-style: solid ! important; padding: 0px 2px ! important; margin-left: 2px; max-width: 20px; overflow: visible ! important; float: none ! important; display: none;">DSD</span><span style="font-family: arial,sans-serif; font-size: xx-small ! important; line-height: 130% ! important; border-width: 1px ! important; border-style: solid ! important; padding: 0px 2px ! important; margin-left: 2px; max-width: 20px; overflow: visible ! important; float: none ! important; display: none;">DSD</span><span style="font-family: arial,sans-serif; font-size: xx-small ! important; line-height: 130% ! important; border-width: 1px ! important; border-style: solid ! important; padding: 0px 2px ! important; margin-left: 2px; max-width: 20px; overflow: visible ! important; float: none ! important; display: none;">DSG</span></a>. Muitas das informações desse artigo são relevantes ao executar o Valgrind no Firefox OS, embora muitas das etapas de compilação e linhas de comando são atendidos pela imagem Firefox OS e os scripts de execução.</p>
+<p>Para rodar o Valgrind no telefone com Firefox OS, é necessário um aparelho com especificações maiores que o normal. Valgrind é um recurso que consome muita memória, geralmente causando falhas de falta de memória em aparelhos com menos de 1GB de RAM. Nesse artigo (de 2013-12-04), Valgrind foi testado em um aparelho Nexus 4 rodando Firefox OS com 2GB de RAM, mas pode ser executado em aparelhos Geeksphone Keons ou similares. Verifique em <a href="/pt-BR/Firefox_OS/Phones">Especificações de Telefones</a> para maiores detalhes dos aparelhos disponíveis.</p>
+<h2 id="Executando_Valgrind_em_telefones_com_FxOS">Executando Valgrind em telefones com FxOS</h2>
+<h3 id="Compilando">Compilando</h3>
+<p>Para compilar o Firefox OS com o valgrind habilitado, inclua no arquivo<a href="/pt-BR/Firefox_OS/Customization_with_the_.userconfig_file"><code>.userconfig</code></a>.</p>
+<pre>export B2G_VALGRIND=1 </pre>
+<p>Compilar com debug (<code>B2G_DEBUG</code>) também é recomendado. Compilação sem otimizações (<code>B2G_NOOPT</code>) torna a usabilidade um pouco mais lenta, e não é reomendado a não ser nos casos onde as otimizações podem ofuscar os erros.</p>
+<h3 id="Executando">Executando</h3>
+<div class="note">
+ <p><strong>Nota:</strong> A execução do Valgrind em um telefone Firefox OS é realizada no contexto do telefone, não no sistema operacional hospedeiro. Isso siginifica que os desenvolvedores podem usar qualquer plataforma com o <a href="/pt-BR/Firefox_OS/Debugging/Installing_ADB">adb</a> disponível e executar o script <code>run-valgrind.sh</code> para iniciar o valgrind no telefone.</p>
+</div>
+<p>Para executar o Firefox OS sob o valgrind, use o script <a href="https://github.com/mozilla-b2g/B2G/blob/master/run-valgrind.sh"><code>run-valgrind.sh</code></a> a partir do diretório B2G. Esse script faz o seguinte:</p>
+<ol>
+ <li>Remonta o sistema de arquivos do telefone com r/w.</li>
+ <li>Copia a biblioteca atual <code>libxul.so</code> com os símbolos completos do telefone. Como esse arquivo tem centenas de MB esse passo leva muito tempo para terminar. E precisa ser refeito a cada vez que uma nova compilação é feita. Para executar o valgrind sem copiar <code>libxul</code> execute esse comando:<br>
+  <pre class="brush: bash">run-valgrind.sh nocopy</pre>
+ </li>
+ <li>Reinicia o telefone.</li>
+ <li>Encerra os processos b2g que foram iniciados.</li>
+ <li>Executa o seu próprio processo b2g sob o valgrind.</li>
+</ol>
+<p>Toda a saída do valgrind é escrita em <code>stdout</code> do terminal que executou o script <code>run-valgrind.sh</code>. Essa saída pode ser lida no terminal ou direcionada para um arquivo.</p>
+<div class="note">
+ <p><strong>Nota</strong>: Uma vez que o script <code>run-valgrind.sh</code> é o proprietário do processo adb que executa o processo b2g, ao encerrar o script, os processos b2g e valgind também serão encerrados no telefone. É recomendado que o telefone seja reiniciado após o término de uma sessão do valgrind, para evitar problemas.</p>
+</div>
+<h2 id="Executando_Valgrind_no_Firefox_OS_Desktop">Executando Valgrind no Firefox OS Desktop</h2>
+<p>Executar o valgrind no Firefox OS Desktop funciona da mesma forma que excutar o Firefox (navegador). Consulte o artigo <a href="/pt-BR/docs/Debugging_Mozilla_with_Valgrind">Depurando o  Mozilla com Valgrind<span style="font-family: arial,sans-serif; font-size: xx-small ! important; line-height: 130% ! important; border-width: 1px ! important; border-style: solid ! important; padding: 0px 2px ! important; margin-left: 2px; max-width: 20px; overflow: visible ! important; float: none ! important; display: none;">DDS</span></a> para mais informações. Todos os flags de compilação relevantes necessários a ser incluídos no <code>mozconfig</code>, e todos os problemas específicos das plataformas descritos na página devem ser aplicados.</p>
+<p>Observe que ao executar Valgrind no desktop em modo <em>OOP/process-per-tab </em>requer adicionar as seguintes opções para certificar-se que os processos-filho também estão sendo monitorados:</p>
+<pre class="brush: bash">--trace-children=yes</pre>
+<h2 id="Mantendo_e_atualizando_o_Firefox_OS_Valgrind">Mantendo e atualizando o Firefox OS Valgrind</h2>
+<p>Durante as liberações de correções, Valgrind para Firefox OS é mantido em um repositório <em>forked</em> para mantê-lo o mais atualizado possível enquanto as excentricidades do Firefox OS são adequadas às mais novas versões.</p>
+<h3 id="Atualizando_Repositórios_Valgrind">Atualizando Repositórios Valgrind</h3>
+<div class="warning">
+ <p><strong>AVISO:</strong> NECESSÁRIO EXPERIÊNCIA COM GIT. Não tente atualizar o repositório Valgrind se você não dominar operações complexas do Git. Qualquer atualização no repositório do GitHub será refletida em <code>git.mozilla.org</code>, que por sua vez irão para os desenvolvedores que usam o HEAD dos repositórios de manifesto.</p>
+</div>
+<p>Os repositórios principais do Firefox OS valgrind e VEX são</p>
+<ul>
+ <li><a href="http://github.com/mozilla-b2g/valgrind">http://github.com/mozilla-b2g/valgrind</a></li>
+ <li><a href="http://github.com/mozilla-b2g/vex">http://github.com/mozilla-b2g/vex</a></li>
+</ul>
+<p>O <em>master branch </em>é uma versão antiga do <em>trunk</em> SVN de cada um desses repos, enquanto que o <em>branch</em> Firefox OS contém correções específicas do Firefox OS baseadas no topo do <em>trunk</em>.</p>
+<div class="note">
+ <p><strong>Nota: SEMPRE ATUALIZE AMBOS OS REPOS NO MESMO MOMENTO</strong>. Apesar de serem dois repos separados, VEX normalmente é um submódulo do Valgrind, e o HEAD do Valgrind normalmente aponta para o HEAD do VEX.</p>
+</div>
+<p>Esses estão replicados no domínio <code>git.mozilla.org</code> para se usado nos manifestos  B2G:</p>
+<ul>
+ <li><a href="http://git.mozilla.org/?p=b2g/valgrind.git;a=summary">http://git.mozilla.org/?p=b2g/valgrind.git;a=summary</a></li>
+ <li><a href="http://git.mozilla.org/?p=b2g/valgrind.git;a=summary">http://git.mozilla.org/?p=b2g/vex.git;a=summary</a></li>
+</ul>
+<ol>
+ <li>Os repos principais são mantidos em sincronismo com o valgrind SVN com git svn. Para carregar as atualizações nos repos, clone os repos valgrind e vex do github, então execute o comando abaixo:
+  <pre class="brush: bash">git svn init -s [subversion repo url]
+</pre>
+ </li>
+ <li>Envira as alterações para o SVN pode levar horas, mas quando for feito sua árvore deve estar sincronizada com a árvore principal do SVN.</li>
+ <li>Para enviar futuras atualizações, utilize o seguinte grupo de comandos:
+  <pre class="brush: bash">git checkout master
+git svn fetch
+git svn rebase
+git push [github-remote-name] master
+git checkout fxos
+git rebase master
+</pre>
+ </li>
+ <li>Existe a chance de existir conflitos entre as correções durante o <em>rebase</em> do <em>branch</em> do Firefox OS. Se não conseguir resolver os conflitos, envie um email para o autor para que ele resolva os conflitos encontrados.</li>
+ <li>Depois do <em>rebase</em>, execute uma compilação completa do Firefox OS com a opção <code>B2G_VALGRIND</code> para certificar-se que ainda funciona. Os consertos mais comuns são listados na seção a seguir.</li>
+ <li>Uma vez feito o <em>rebase</em> E TESTADA a compilação contra a árvore Firefox OS, você deve forçar um <em>push</em> para o branch Firefox OS devido à alteração do head.
+  <pre>git push -f [github-remote-name] fxos</pre>
+ </li>
+</ol>
+<h3 id="Scripts_de_compilação_instalação_e_execução">Scripts de compilação, instalação e execução</h3>
+<p>Existem diversos scripts que fazem parte do <em>branch</em> Valgrind Firefox OS ou do repo B2Gque podem necessitar serem alterados após um <em>fetch</em> do repo.</p>
+<h4 id="externalvalgrindandroid.mk">external/valgrind/android.mk</h4>
+<p>Esse é um script de compilação do sistema Android. As alterações nesse script são devido ao de arquivos que são adicionados ou removidos da árvore Valgrind. Use uma compilação com <code>-j1</code> para verificar quais os alvos falham na compilação e se foi esquecido algum arquivo ou há alguma referência a um arquivo inexistente.</p>
+<h4 id="externalvalgrindvalgrind.mk">external/valgrind/valgrind.mk</h4>
+<p>Contém uma lista de pacotes que necessitam ser compilados e adicionados à imagem do FxOS, referenciada por <code>gonk-misc/b2g.mk</code>. Normalmente esse script não necessita ser alterado uma vez que é raro que o Valgrind inclua novos pacotes, mas se isso acontecer, informe nesse arquivo.</p>
+<h4 id="run-valgrind.sh">run-valgrind.sh</h4>
+<p>Script para executar o Valgrind no telefone. Se exitem novos argumentos na linha de comando necessários para rodar o Valgrind no telefone, inclua-os aqui. Isso também é utilizado quando nós copiamos a biblioteca com depuração, assim qualquer ajuste ou alteração a esse processo deve acontecer aqui.</p>
diff --git a/files/pt-br/archive/b2g_os/debugging/depurando_b2g_usando_gdb/index.html b/files/pt-br/archive/b2g_os/debugging/depurando_b2g_usando_gdb/index.html
new file mode 100644
index 0000000000..df386261ac
--- /dev/null
+++ b/files/pt-br/archive/b2g_os/debugging/depurando_b2g_usando_gdb/index.html
@@ -0,0 +1,84 @@
+---
+title: Depurando o B2G usando gdb e ferramentas relacionadas
+slug: Archive/B2G_OS/Debugging/Depurando_B2G_usando_gdb
+translation_of: Archive/B2G_OS/Debugging/Debugging_B2G_using_gdb
+---
+<div class="summary">
+ <p><strong><code>gdb</code></strong> é um depurador de linha de comando que fornece um grande número de opções úteis para depurar aplicações Firefox OS. Outras ferramentas também estão disponíveis como <code>b2g-ps</code>, que é um empacotador da ferramanta padrão ps que mostra os nomes dos aplicativos que estão sendo executados numa instância do B2G. Esse artigo mostra como executar tarefas de depuração com essas ferramentas.</p>
+</div>
+<h2 id="Começando_a_depurar_no_modo_single-process">Começando a depurar no modo <em>single-process</em></h2>
+<div class="note">
+ <p><strong>Nota:</strong> Antes de executar o depurador você pode configurar o arquivo<code> .userconfig</code> para customizar algumas coisas. Veja o artigo <a href="/pt-BR/docs/Mozilla/Boot_to_Gecko/Customization_with_the_.userconfig_file" title="/en-US/docs/Mozilla/Boot_to_Gecko/Customization_with_the_.userconfig_file">Customização com o arquivo .userconfig</a> para maiores detalhes.</p>
+</div>
+<p>Para reiniciar Firefox OS e executá-lo sob o controle do gdb, simplesmente use o scritp <code>run-gdb.sh</code>:</p>
+<pre>./run-gdb.sh
+</pre>
+<div class="note">
+ <p><strong>Nota:</strong> Se você quiser depurar no emulador, certifique-se que não há telefones conectados ao computador, isso pode gerar conflitos ao gdb tentar conectar ao emulador.</p>
+</div>
+<p>Se o Firefox OS já estiver rodando e você quiser conectar o gdb sem reiniciá-lo, você pode fazer algo como isso:</p>
+<pre>./run-gdb.sh attach
+</pre>
+<h2 id="Depurando_tarefas_fora_do_processo">Depurando tarefas fora do processo</h2>
+<p>Devido ao fato da natureza multiprocessamento do Firefox OS, frequentemente você necessitará depurar tarefas que não a tarefa B2G. Para fazer isso, o modo mais simples é usar o comando <code>b2g-ps</code> para descobrir o PID do processo que você precisa depurar:</p>
+<pre>$ adb shell b2g-ps
+b2g              root      106   1     189828 56956 ffffffff 40101330 S /system/b2g/b2g
+Browser          app_0     4308  106   52688  16188 ffffffff 400db330 S /system/b2g/plugin-container
+</pre>
+<p>No exemplo, Browser é um processo filho usado como "content process" para a aplicação browser. Assim se você deseja depurar o "content process", nesse exemplo, faça:</p>
+<pre>$ ./run-gdb.sh attach 4308</pre>
+<p>Algumas vezes, é útil ser notificado imediatamente de qualquer criação de processos filhos.</p>
+<p>Isso pode ser ativado iniciando <code>run-gdb.sh</code> com a variável de ambiente<code> MOZ_DEBUG_CHILD_PROCESS</code>:</p>
+<pre>MOZ_DEBUG_CHILD_PROCESS=1 ./run-gdb.sh</pre>
+<p>Feito isso, lançando uma aplicação OOP no Firefox OS será mostrado o PID do "plugin-conteiner" para essa tarefa, e o processo dormirá por 30 segundos, tempo suficiente para você rodar o comando para anexar o depurador como visto abaixo:</p>
+<pre>$ ./run-gdb.sh attach 4308</pre>
+<p>Se você estiver tentando depurar algo que ocorre durante o boot, você tem que lançar uma instância do depurador muito rápido. Uma vez que o depurador foi iniciado, você deve imediatamente pressionar "c" para continuar a executar a nova tarefa.</p>
+<h2 id="Suporte">Suporte</h2>
+<h3 id="Qual_o_nível_de_funcionalidade_esperado">Qual o nível de funcionalidade esperado</h3>
+<p>Os recursos de depuração a seguir ao menos devem funcionar, caso contrário, provavelmente um pequeno ajuste na configuração o fará funcionar:</p>
+<ul>
+ <li>Símbolos para todas as bibliotecas (exceto talvez alguns drivers de alguns telefones Android)</li>
+ <li>Informações de <em>backtraces</em> com depuração completa (exceto para valores de argumentos <em>optimized-away</em>)</li>
+ <li><em>Breakpoints</em>: Você deve poder criar breakpoints num símbolo, ou em arquivo:linha, ou em endereço. Todas as opções devem funcionar.</li>
+ <li><em>Single-stepping </em>('s' e 'n' devem funcionar)</li>
+</ul>
+<p>Os serguintes recursos de depuração não são suportados. Não tente usá-los:</p>
+<ul>
+ <li><em>Watchpoints</em>.</li>
+</ul>
+<h3 id="Resolução_de_problemas">Resolução de problemas</h3>
+<p>Existem algumas coisas para tentar resolver caso o <code>gdb</code> não funcione como descrito acima.</p>
+<h4 id="Certifique-se_que_seu_clone_B2G_está_atualizado">Certifique-se que seu clone B2G está atualizado</h4>
+<p>Tenha sempre em mente que para atualizar seu clone B2G você deve executar esses <strong>dois</strong> comandos:</p>
+<pre>git pull
+./repo sync</pre>
+<p>Ao esquecer do <code>git pull</code> poderá acontecer de você executar um antigo <code>run-gdb.sh</code> e não se beneficiar das últimas melhorias.</p>
+<h4 id="Certifique-se_de_que_você_anexou_o_gdb_ao_processo_correto">Certifique-se de que você anexou o gdb ao processo correto</h4>
+<p>Anexando-se a um processo errado (por exemplo, processo B2G principal versus processo Browser) pode explicar porque o depurador não para nos <em>breakpoints</em>.</p>
+<h4 id="Certifique-se_de_que_os_símbolos_foram_corretamente_lidos">Certifique-se de que os símbolos foram corretamente lidos</h4>
+<ol>
+ <li>No <code>gdb</code>, use <code>info shared</code> para checar se os símbolos foram corretamente lidos:
+  <pre>(gdb) info shared
+From        To          Syms Read   Shared Object Library
+0xb0001000  0xb0006928  Yes         out/target/product/otoro/symbols/system/bin/linker
+0x40051100  0x4007ed74  Yes         /hack/b2g/B2G/out/target/product/otoro/symbols/system/lib/libc.so
+0x401ab934  0x401aba2c  Yes         /hack/b2g/B2G/out/target/product/otoro/symbols/system/lib/libstdc++.so
+...</pre>
+ </li>
+ <li>A coluna <code>Syms Read</code> deve estar com <code>Yes</code> sempre. Talvez em alguns telefones Android você pode ver <code>Yes (*)</code> para algumas bibliotecas de sistema ou drivers, isso estará OK. Você somente não poderá ver um <code>No.</code></li>
+ <li>Se você vir um <code>No</code>, será seu primeiro problema e você deve resolvê-lo antes de procurar qualquer outra coisa.</li>
+ <li>Procure por alguma outra mensagem de erro na saída do terminal logo após executar o comando <code>run-gdb.sh</code>.</li>
+ <li>Verifique também no terminal se a saída do terminal do comando GDB está ok. Em particular, o último argumento da linha de comando deve ser o caminho para o executável <code>b2g</code>. A seguir um exemplo:
+  <pre>prebuilt/linux-x86/toolchain/arm-linux-androideabi-4.4.x/bin/arm-linux-androideabi-gdb -x /tmp/b2g.gdbinit.bjacob /hack/b2g/B2G/objdir-gecko/dist/bin/b2g</pre>
+ </li>
+ <li>Verifique o valor dessas variáveis GDB: <code>solib-search-path</code> e <code>solib-absolute-prefix:</code>
+  <pre>(gdb) show solib-search-path
+The search path for loading non-absolute shared library symbol files is /hack/b2g/B2G/objdir-gecko/dist/bin:out/target/product/otoro/symbols/system/lib:out/target/product/otoro/symbols/system/lib/hw:out/target/product/otoro/symbols/system/lib/egl:out/target/product/otoro/symbols/system/bin:out/target/product/otoro/system/lib:out/target/product/otoro/system/lib/egl:out/target/product/otoro/system/lib/hw:out/target/product/otoro/system/vendor/lib:out/target/product/otoro/system/vendor/lib/hw:out/target/product/otoro/system/vendor/lib/egl.
+(gdb) show solib-absolute-prefix
+The current system root is "out/target/product/otoro/symbols".</pre>
+ </li>
+</ol>
+<div class="note">
+ <p><strong>Nota</strong>: Se você precisar de mais ajuda, tente o canal #b2g no IRC. Se você acredita ter encontrado um bug, reporte-o <a href="https://github.com/mozilla-b2g/B2G/issues" title="https://github.com/mozilla-b2g/B2G/issues">aqui</a>.</p>
+</div>
+<p> </p>
diff --git a/files/pt-br/archive/b2g_os/debugging/depurando_erros_falta_de_memoria/index.html b/files/pt-br/archive/b2g_os/debugging/depurando_erros_falta_de_memoria/index.html
new file mode 100644
index 0000000000..cb56fef4d0
--- /dev/null
+++ b/files/pt-br/archive/b2g_os/debugging/depurando_erros_falta_de_memoria/index.html
@@ -0,0 +1,66 @@
+---
+title: Depurando erros de falta de memória no Firefox OS
+slug: Archive/B2G_OS/Debugging/Depurando_erros_falta_de_memoria
+tags:
+  - B2G
+  - Erros
+  - Falta de Memória
+  - Firefox OS
+translation_of: Archive/B2G_OS/Debugging/Debugging_OOMs
+---
+<div class="summary">
+ <p>Quando um dispositivo Firefox OS fica sem memória, os sistemas low-memory killer e low-memory notifications são executados para encerrar alguns processos e manter o sistema operacional funcionando. Quando o kernel encerra alguns processos que estavam rodando em segundo plano o comportamento assemelha-se a uma finalização inesperada do aplicativo que estava sendo executado. Esse artigo explica como compreender e depurar erros devido a falhas decorrentes de falta de memória.</p>
+</div>
+<div class="note">
+ <p><strong>Nota</strong>: Se você não sabe ainda como situações com baixa memória são gerenciadas no Firefox OS, sugerimos você ler o artigo <a href="https://developer.mozilla.org/pt-BR/Firefox_OS/Platform/Out_of_memory_management_on_Firefox_OS">Gerenciamento de falha de memória no Firefox OS</a> antes de continuar a ler esse documento.</p>
+</div>
+<h2 id="Depurando_uma_falha_decorrente_de_Falta_de_Memória_(OOM_-_Out_Of_Memory_crash)">Depurando uma falha decorrente de Falta de Memória (OOM - Out Of Memory crash)</h2>
+<p>Suponha que você tenha uma falha que possa ser reproduzida e suspeita que seja a causadora de falta de memória. Os passos a seguir farão você entender mais sobre o que está dando errado.</p>
+<h3 id="Passo_1_Confirme_se_realmente_a_falha_é_devido_à_falta_de_memória">Passo 1: Confirme se realmente a falha é devido à falta de memória</h3>
+<p>Primeiro, devemos garantir que a falha é devido ao fato do telefone estar sem memória disponível. Para fazer isso execute <code>adb shell dmesg</code>.  Se o aplicativo for enecerrado devido a falta de memória, você verá a seguinte resposta:</p>
+<pre class="brush: bash">&lt;4&gt;[06-18 07:40:25.291] [2897: Notes+]send sigkill to 2897 (Notes+), adj 2, size 30625</pre>
+<p>Essa linha indica que o aplicativo Notes+ (ID do processo 2897) foi encerrado e possuia <code>oom_adj 2</code>. O tamanho reportado aqui é em páginas, com 4kb cada. Dessa forma, nesse caso, o aplicativo Notes+ estava usando 30625 * 4kb = 120mb de memória.</p>
+<h4 id="Digressão_se_não_for_falta_de_memória_(OOM)">Digressão: se não for falta de memória (OOM)</h4>
+<p>Se a saída do comando <code>dmesg</code> não for a apresentada, provavelmente a falha não é devido à falta de memória.  your crash is likely not an OOM. O próximo passo na depuração da falha é utilizar o <code>gdb</code> ao processo de falha e conseguir um rastreamento, que pode ser feito dessa forma:</p>
+<pre class="brush: bash">$ cd path/to/B2G/checkout
+$ adb shell b2g-ps
+# Note pid of the app that you're going to crash
+$ ./run-gdb.sh attach &lt;pid&gt;
+(gdb) continue
+# crash the app
+(gdb) bt</pre>
+<p>Quando for reportar o bug, anexe o resultado obtido, bem como o resultado do comando <code>adb logcat</code>. Se a falha for devido a falta de memória, o rastreamento provavelmente não será interessante, poir a falha de falta de memória é disparada por um sinal enviado pelo kernel e não por uma falha de código que o processo executa.</p>
+<h3 id="Passo_2_Coletar_relatórios_de_memória">Passo 2: Coletar relatórios de memória</h3>
+<p>Depois de você ter se certificado que a falha é devido à falta de memória, o próximo passo é coletar relatório de memória do seu telefone antes da falha. Esse relatório nos ajudará a entender como a memória está sendo usada. Esta etapa é um pouco complicada, porque uma vez que aplicativo falhar, não há nenhuma maneira de coletar um relatório de memória desse processo. Também não há uma forma de disparar um relatório de memória quando o kernel tenta encerrar um processo — quando isso acontece é tarde demais.</p>
+<p>Para extrair um relatório de memória do seu telefone, primeiramente atualize sua árvore de compilação a fim de obter a última versão da ferramenta que extrai o relatório. Observe que  <code>repo sync</code> não será suficiente; você deve executar <code>git fetch &amp;&amp; git merge</code> ou <code>git pull</code>:</p>
+<pre class="brush: bash">$ cd path/to/B2G/checkout
+$ git fetch origin
+$ git merge --ff-only origin</pre>
+<p>Agora execute a ferramenta para extrair o relatório:</p>
+<pre class="brush: bash">$ tools/get_about_memory.py</pre>
+<p>Uma vez que você conseguiu o relatório, você pode compactar o diretório (chamado <code>about-memory-N</code>) e anexá-lo a um bug. Mas novamente, isso somente será útil se você executar esse comando enquanto o aplicativo que você está monitorando estiver sendo executado e usando muita memória. Você tem algumas opções aqui:</p>
+<h4 id="Passo_2_opção_1_Consiga_um_dispositivo_diferente">Passo 2, opção 1: Consiga um dispositivo diferente</h4>
+<p>Geralmente a forma mais fácil é conseguir um dispositivo com mais memória. Você já sabe desde o passo 1 quanta memória o processo estava usando quando falhou, assim você pode simplesmente esperar até o processo utilizar perto desse valor e então pegar um relatório de memória. O aplicativo <code>b2g-info</code> mostrará quanta memória cada um dos diferentes processos B2G estavam usando. Você pode executar esse processo em um loop fazendo o seguinte:</p>
+<pre class="brush: bash">$ adb shell 'while true; do b2g-info; sleep 1; done'</pre>
+<p>Se <code>b2g-info</code> não está disponível no seu dispositivo, você pode usar <code>b2g-procrank</code>.</p>
+<h4 id="Passo_2_opção_2_Dedo_mais_rápido">Passo 2, opção 2: Dedo mais rápido</h4>
+<p>Se você não possui um dispositivo com mais memória RAM, você pode tentar executar <code>get_about_memory.py</code> no momento exatamente anterior ao aplicativo falhar. Você pode rodar <code>b2g-info</code> em um loop (como mostrado no item anterior) para descobrir quando executar <code>get_about_memory.py</code>. Executar um relatório de memória congela todos os processos por um pequeno momento, assim não é difícil extrair um relatório de memória antes do processo de falta de memória entrar em ação.</p>
+<h4 id="Passo_2_opção_3_Use_um_pequeno_caso_de_teste">Passo 2, opção 3: Use um pequeno caso de teste</h4>
+<p>Geralmente falhas de falta de memória ocorrem quando é feito algo como "carregar um arquivo de no mínimo X bytes no aplicativo".</p>
+<p>Se o aplicativo falha muito rapidadmente com um caso de teste do tamanho X, você pode tentar executar um teste similar com o tamanho X/2 e capturar um relatório de memória após a execução do teste. O relatório pode nos dar valiosas dicas que definitivamente nos chamarão a atenção.</p>
+<h4 id="Passo_2_opção_4_Execute_B2G_no_seu_desktop">Passo 2, opção 4: Execute B2G no seu desktop</h4>
+<p>Se o que é ruim se tornar pior, você pode rodar o B2G no seu desktop, o que provavelmente possui muito mais memória que seu telefone FxOS. Isso é complicado porque B2G rodando num desktopo tem um comportamento diferente que quando roda num dispositivo.</p>
+<p>Particularmente, B2G num desktop possui o multiprocessamento desabilitado por padrão. Ele realmente não funciona 100% em qualquer lugar, mas funciona de forma mais precisa no Linux e no Mac. (Verifique <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=923961">Bug 923961</a>, <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=914584">Bug 914584</a>, <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=891882">Bug 891882</a>). Você pode testar em seu desktop com o multiprocessamento desabilitado, mas em minha experiência muitos dos problemas relacionados ao uso de memória são causados por códigos de comunicação interprocessos, de modo que não vai necessariamente provocar o erro que você está vendo.</p>
+<p>Também não é conveniente extrari relatórios de memória dos processos B2G no desktop. No Linux, você pode enviar o sinal 34 para o processo principal B2G que ele vai escrever relatórios no diretório <code>/tmp</code> com o seguinte nome: <code>memory-report-*.gz</code>.</p>
+<p>Uma vantagem de utilizar o B2G desktop é que você pode usar suas ferramentas de depuração favoritas, como o aplicativo Instruments Activities do Mac OSX. Nós já tivemos muito sucesso no passado. Para coletar relatórios de memória usando esse utilitário do OSX, vá em "New -&gt; Mac OS X -&gt; Allocations". Inicie o b2g-desktop e você verá alguns processos "plugin-container" no utilitário Activity Monitor. Você necessitará de duas instâncias do Instruments: um para registrar as alocações no processo principal b2g e outro para registrar as alocações no aplicativo que você deseja analisar. Com os utiltários monitorando os processos execute o seu caso de teste.</p>
+<p>Para analisar quanta memório seu aplicativo está utilizando, analise as árvores de chamadas. Marque "Invert Call Tree", o ordene por bytes usados. Isso irá mostrar qual parte do seu aplicativo usa mais memória. Abaixo uma cópia de tela de uma análise simples de uso de memória de uma aplicativo:</p>
+<p> </p>
+<p><img alt="Screen shot of instruments." src="https://mdn.mozillademos.org/files/6439/instrumentsScreenShot.png" style="width: 800px; height: 492px;"><br>
+ Para mais informações de como configurar uma compilação do B2G desktop, leia nossa página <a href="/pt-BR/docs/Mozilla/Firefox_OS/Platform/Gaia/Hacking">Modificando o Gaia</a>.</p>
+<h3 id="Passo_3_Analise_o_relatório_de_memória">Passo 3: Analise o relatório de memória</h3>
+<p>Quando você executa <code>get_about_memory.py</code>, será apresentado o relatório de memório no Firefox. Esse arquivo contém informações do uso de memório de todos os processos do sistema. A leitura desse relatório pode ser um tanto pesada num primeiro momento, mas não será tão ruim quando você pegar o jeito da coisa. Note que você pode passar o mouse sobre qualquer nó folha para obter uma descrição do que esse nó descreve. O que você estará procurando é algo "estranhamente grande" no processo que ocasionou a falha. Você pode ter uma ideia do que é "estranhamente grande" capturando um relatório de memória do seu aplicativo quando ele não está usando muita memória.</p>
+<p>A leitura de um relatório de memória requer alguma prática, assim fique a vontade para pedir ajuda. Os especialistas no assunto costumam ficar no canal #memshrink do IRC.</p>
+<h3 id="Passo_4_Recompile_com_DMD_se_necessário">Passo 4: Recompile com DMD, se necessário</h3>
+<p>Um item comum presente nos relatórios de memória extraídos antes de uma falha é<code> heap-unclassified</code>.  <code>heap-unclassified</code> mostra a memória alocada pelo processo que não é apresentada por nenhum outro relatório de memória. Se você tem um valor alto no <code>heap-unclassified</code>, o relatório não pode dizer dizer mais nada sobre a quem a memória pertence. Nossa ferramenta para ir mais fundo no <code>heap-unclassified</code> é chamada DMD. Ela funciona no B2G, mas você deve <a href="/pt-BR/docs/Mozilla/Firefox_OS/Building_and_installing_Firefox_OS">compilar seu próprio B2G</a> para que funcione pois DMD exige símbolos locais que são mantidos na máquina que roda a compilacão.</p>
+<p>Para saber mais informações sobre o DMD e como interpretar sua saída, leia a <a href="https://wiki.mozilla.org/Performance/MemShrink/DMD">página do DMD na Wiki Mozilla</a>.<br>
+  </p>
diff --git a/files/pt-br/archive/b2g_os/debugging/firefox_os_crash_reporting/index.html b/files/pt-br/archive/b2g_os/debugging/firefox_os_crash_reporting/index.html
new file mode 100644
index 0000000000..3d74894f76
--- /dev/null
+++ b/files/pt-br/archive/b2g_os/debugging/firefox_os_crash_reporting/index.html
@@ -0,0 +1,123 @@
+---
+title: Relatórios de Travamento no Firefox OS
+slug: Archive/B2G_OS/Debugging/Firefox_OS_crash_reporting
+tags:
+  - Debugador
+  - Depurador
+  - Firefox OS
+  - QA
+  - Testes
+  - crash
+translation_of: Archive/B2G_OS/Debugging/Firefox_OS_crash_reporting
+---
+<div class="summary">
+<p>Esta página fornece detalhes sobre como lidar com relatórios de travamento no Firefox OS, incluindo a recuperação de relatórios, e forçando travamentos.</p>
+</div>
+
+<div class="note">
+<p>Nota: A maioria dos contribuintes Firefox desktop estão acostumados a usar about: crashes para recuperar relatórios de travamento (leia <a href="https://developer.mozilla.org/pt-BR/docs/Crash_reporting">Relatórios de Travamento</a> para mais detalhes), mas isso não é suportado no Firefox OS.</p>
+</div>
+
+<h2 id="Antes_de_tentar_qualquer_outra_coisa">Antes de tentar qualquer outra coisa</h2>
+
+<p>As instruções a seguir pressupõem que você já tenha seguido estas três etapas:</p>
+
+<ol>
+ <li>Tenha certeza de que o <a href="/pt-BR/Firefox_OS/Debugging/Developer_settings#Debugging_via_USB">depurador remoto</a> esteja habilitado em seu dispositivo, e o ADB esteja instalado. Isso permitirá que o seu computador comunique com seu dispositivo.  </li>
+ <li>Conecte seu dispositivo ao seu computador via USB. </li>
+ <li>Instale o <a href="https://ftp.mozilla.org/pub/mozilla.org/labs/fxos-simulator/">ADB Helper Add-on</a> no desktop Firefox para lidar com qualquer encaminhamento de porta necessário.  </li>
+</ol>
+
+<h3 id="Instalando_BusyBox" style="line-height: 24px; font-size: 1.71428571428571rem;">Instalando BusyBox</h3>
+
+<p>Também é recomendado que você instale o BusyBox, que adiciona uma série de comandos úteis para ADB que ajudam a testar e depurar o Firefox OS.</p>
+
+<p>Para instalá-lo, certifique-se que o seu dispositivo esteja ligado e, em seguida:</p>
+
+<ol>
+ <li>Faça download do<a href="https://wiki.mozilla.org/images/3/32/Busybox-b2g.tar.gz"> BusyBox</a>.</li>
+ <li>Descompacte o tarball em um local seguro.</li>
+ <li>cd no diretório restante busybox-b2g.</li>
+ <li>Execute <code>./install.sh</code> para instalar.</li>
+</ol>
+
+<p>Todas as funcionalidades do busybox pegam symlinks em <code>/system/bin</code>, de forma que você possa rodar comandos como ping diretamente. Aqui estão alguns exemplos de comandos:</p>
+
+<pre class="brush: bash">adb shell ping 8.8.8.8   =&gt; ping command
+
+adb shell ifconfig wlan0 =&gt; check tx/rx bytes
+
+adb shell cat /proc/net/route    =&gt; check the default route
+
+adb shell iptables -t nat -nvL   =&gt; check if the packets are sent from application to IP layer, check Chain OUTPUT (policy ACCEPT 2 packets, 168 bytes)</pre>
+
+<h2 id="Obtendo_relatórios_de_travamento_de_um_dispositivo_Firefox_OS">Obtendo relatórios de travamento de um dispositivo Firefox OS</h2>
+
+<p>Nós criamos o Firefox OS app para que seja possível recuperar relatórios de travamento — <a href="http://jds2501.github.io/webapi-permissions-tests/about-crashes.zip">About Crashes</a> — que funcionam na versão 1.2+.<br>
+ <br>
+ Para instalar em seu dispositivo, siga os seguintes passos:</p>
+
+<ol>
+ <li>About Crashes é um app certificado, então você precisa habilitar o depurador de aplicativos certificados (veja instruções para <a href="/pt-BR/Firefox_OS/Using_the_App_Manager#Debugging_Certified_Apps_2">App Manager</a> e <a href="/pt-BR/docs/Tools/WebIDE#Debugging_certified_apps">WebIDE</a>).</li>
+ <li>Faça download do arquivo zip About Crashes app do link acima e extraia localmente.</li>
+ <li>No Firefox desktop, abra o  <a href="/pt-BR/Firefox_OS/Using_the_App_Manager">App Manager</a> e o <a href="/pt-BR/docs/Tools/WebIDE">WebIDE</a> (dependendo da versão do Firefox que você esteja usando) em Ferramentas &gt; Web Developer.</li>
+ <li>Em cada ferramenta, adicione o About Crashes app como um app compactado (App Manager: clique no sinal de mais ao lado da opção <em>Adicionar App Compactado</em>, WebIDE Compactado: Abra o menu dropdown do lado esquerdo e selecione <em>Adicionar App Compactado</em> ...).</li>
+ <li>Conecte o seu dispositivo ao App Manager/WebIDE (App Manager: encontre listado na parte inferior da interface do usuário, WebIDE: Procure por <em>Select Runtime</em>).</li>
+ <li>Instale e abra o aplicativo em seu dispositivo (App Manager: Pressione o botão <em>Update</em>, WebIDE: pressione o botão "Play" (<em>Instale and execute</em>).</li>
+ <li>No dispositivo, pressione o botão <em>Update</em> dentro de About Crashes para visualisar as falhas mais recentes.</li>
+</ol>
+
+<h2 id="Obtendo_crash_IDs_a_partir_de_uma_linha_de_comando">Obtendo crash IDs a partir de uma linha de comando </h2>
+
+<p>Você pode obter uma lista de IDs de falhas através de uma linha de comando, digitando o seguinte comando em seu terminal:</p>
+
+<pre class="brush: bash">adb shell ls -l /data/b2g/mozilla/Crash\ Reports/submitted/</pre>
+
+<p>Caso você possua uma longa lista de crashes e deseja que elas sejam ordenadas por data, use o seguinte comando:</p>
+
+<pre class="brush: bash">adb shell busybox ls -ltr /data/b2g/mozilla/Crash\ Reports/submitted/</pre>
+
+<h2 id="Obtendoverificando_o_relatório_de_travamento">Obtendo/verificando o relatório de travamento</h2>
+
+<p>Para verificar o relatório de travamento:</p>
+
+<ol>
+ <li>Copie o nome do arquivo sem a extensão.</li>
+ <li>Acesse <a href="http://crash-stats.mozilla.org">Mozilla Crash Reports</a>.</li>
+ <li>Cole o nome do arquivo sem a extensão na parte superior do  campo de busca.  </li>
+</ol>
+
+<p>Isso deverá exibir o crash report que você enviou.</p>
+
+<h2 id="Como_forçar_uma_falha">Como forçar uma falha</h2>
+
+<p>Para acionar uma falha no sistema Firefox OS, digite o seguinte comando em seu terminal para encontrar a ID do processo root:</p>
+
+<pre class="brush: bash">adb shell ps | grep b2g</pre>
+
+<p>Você terá que encontrar a linha que tem raiz no início, e / system / B2G / B2G no final. O resultado deve parecer com isto:</p>
+
+<pre class="brush: bash">root 109 1 191120 66024 ffffffff 400fa330 S /system/b2g/b2g</pre>
+
+<p>O número no início do código é a id que você precisará para terminar o processo. Execute o seguinte comando, com a id dentro espaço [ ]:</p>
+
+<pre class="brush: bash">adb shell kill -11 [ENTER ID HERE]</pre>
+
+<p>Ao matar o processo pela, uma falha aparecerá em seu dispositivo. </p>
+
+<h3 id="Como_executar_o_script_GDB_para_b2g">Como executar o script GDB para b2g</h3>
+
+<ol>
+ <li>Inicie a galeria app no telefone, e em seguida execute o seguinte comando em seu terminal: </li>
+ <li>
+  <pre class="brush: bash">adb shell b2g-ps</pre>
+ </li>
+ <li>Anote o pid do app galeria, e em seguida, execute o seguinte comando:</li>
+ <li>
+  <pre class="brush: bash">./run-gdb.sh attach &lt;pid&gt;</pre>
+ </li>
+ <li>Provoque o crash.</li>
+ <li>Execute o comando abaixo:
+  <pre class="brush: bash">(gdb) bt</pre>
+ </li>
+</ol>
diff --git a/files/pt-br/archive/b2g_os/debugging/index.html b/files/pt-br/archive/b2g_os/debugging/index.html
new file mode 100644
index 0000000000..3d57cd5dd7
--- /dev/null
+++ b/files/pt-br/archive/b2g_os/debugging/index.html
@@ -0,0 +1,72 @@
+---
+title: Depuração no Firefox OS
+slug: Archive/B2G_OS/Debugging
+translation_of: Archive/B2G_OS/Debugging
+---
+<div class="summary">
+ <p><span class="seoSummary">Existe dois tipos de depuração que você pode utilizar no Firefox OS: depuração de aplicativos e depuração de outros apectos do sistema. Essa seção do site provê artigos cobrindo as diferentes ferramentas disponíveis para depurar o seu código Firefox OS.</span></p>
+</div>
+<h2 id="Depurando_aplicativos">Depurando aplicativos</h2>
+<p>Quando depurar aplicativos web, a melhor ferramenta a sua disposição é o <a href="/pt-BR/Firefox_OS/Using_the_App_Manager">App Manager</a>, que possibilita você executar seus aplicativos diretamente em um dispositivo real ou em um simulador, atualiza qualquer alteração instantaneamente e depura diretamente no dispositivo usando as <a href="https://developer.mozilla.org/pt-BR/docs/Tools" title="en-US/docs/Tools">ferramentas de desenvolvimento da Mozilla</a>. Essa pode ser a sua primeira escolha especiamente para depurações de aplicativos e do Gaia.</p>
+<dl>
+ <dt>
+  <a href="/pt-BR/Firefox_OS/Using_the_App_Manager">Usando o App Manager</a></dt>
+ <dd>
+  O App Manager é uma nova ferramenta disponível do Firefox Desktop que fornece diversas funcionalidades que o ajudarão a testar, instalar e depurar os aplicativos HTML5 nos dispositivos Firefox OS e no Simulador do Firefox OS diretamente do seu navegador</dd>
+ <dt>
+  <a href="/pt-BR/docs/Mozilla/Firefox_OS/Debugging/Debugging_OOMs">Depurando erros de falta de memória no Firefox OS</a></dt>
+ <dd>
+  Esse artigo descreve como a arquitetura multiprocesso do B2G é afetada quando ocorre um erro de falta de memória e como entender e depurar nessas situações.</dd>
+</dl>
+<h2 id="Depurando_o_GaiaB2G">Depurando o Gaia/B2G</h2>
+<p>Se você quiser depurar o código da suíte de aplicativos Gaia ou o próprio B2G as seguintes ferramentas são úteis para você.</p>
+<dl>
+ <dt>
+  <a href="/pt-BR/Firefox_OS/Using_the_B2G_desktop_client" title="/en-US/docs/Mozilla/Firefox_OS/Debugging/Debugging_using_the_desktop_B2G_client">Depurando usando o cliente B2G Desktop</a></dt>
+ <dd>
+  Você pode usar a aplicação B2G Desktop (e suas ferramentas associadas) para depurar diversos aspectos do B2G e do Gaia.</dd>
+ <dt>
+  <a href="https://developer.mozilla.org/pt-BR/Firefox_OS/Developing_Firefox_OS/Guia_rapido_desenvolvimento_Gaia">Guia rápido para desenvolvimento Gaia</a></dt>
+ <dd>
+  Esse guia fornece um guia para desenvolver e depurar aplicativos Gaia, incluindo as instruções de como rodar o Gaia a partir do Firefox Desktop e depurar o Gaia com o App Manager.</dd>
+ <dt>
+  <a href="/pt-BR/docs/Mozilla/Firefox_OS/Debugging/Debugging_B2G_using_gdb" title="/en-US/docs/Mozilla/Firefox_OS/Debugging/Debugging_B2G_using_gdb">Depurando o B2G usando gdb</a></dt>
+ <dd>
+  O depurador popular gdb pode ser utilizado para depurar o Firefox OS e os apliciativos web executados em um dispositivo ou no emulador. Esse guia mostra como fazer isso.</dd>
+ <dt>
+  <a href="/pt-BR/docs/Mozilla/Firefox_OS/Debugging/Debugging_B2G_using_valgrind" title="/en-US/docs/Mozilla/Firefox_OS/Debugging/Debugging_B2G_using_gdb">Depurando o B2G usando Valgrind</a></dt>
+ <dd>
+  Valgrind dá aos desenvolvedores acesso a informações sobre alocação de memória, threads e outras informações importantes sobre performance. Esse guia mostra como executar o Valgrind no B2G Desktop ou no dispositivo.</dd>
+ <dt>
+  <a href="/pt-BR/docs/Mozilla/Debugging/HTTP_logging#Firefox_OS_phones" title="/en-US/docs/Mozilla/Debugging/HTTP_logging#Firefox_OS_phones">Conseguindo logs do NSPR no B2G</a></dt>
+ <dd>
+  Você pode usar os logs do NSPR logs para registrar o HTTP e outras operações da rede.</dd>
+ <dt>
+  <a href="/pt-BR/docs/Mozilla/Debugging/Debugging_OpenGL" title="/en-US/docs/Mozilla/Debugging/Debugging_OpenGL">Depurando OpenGL</a></dt>
+ <dd>
+  Como depurar código OpenGL no Firefox OS.</dd>
+</dl>
+<h2 id="Configuração_geral_e_informações"><strong>Configuração geral e informações</strong></h2>
+<p>Os artigos a seguir fornecem informações ou aspectos específicos de configurações para desenvolvimento no Firefox OS. É possível que você não precise disso, especialmente se você estiver depurando apenas aplicativos usando o App Manager. Mas estão disponíveis caso você precise.</p>
+<dl>
+ <dt>
+  <a href="/pt-BR/docs/Mozilla/Firefox_OS/Debugging/Developer_settings" title="/en-US/docs/Mozilla/Firefox_OS/Debugging/Developer_settings">Configurações do desenvolvedor do Firefox OS</a></dt>
+ <dd>
+  Existe um número de configurações disponíveis para os desenvolvedores do Firefox OS. Esse guia explica quais são e como utilizá-las.</dd>
+ <dt>
+  <a href="/pt-BR/Firefox_OS/Debugging/Installing_ADB">Instalando e usando o ADB</a></dt>
+ <dd>
+  Em muitos aspectos do desenvolvimento do Firefox OS você vai precisar instalar o <code>adb</code> (Android Debug Bridge). Esse artigo explica como fazer isso e apresenta os comandos mais comuns.</dd>
+ <dt>
+  <a href="/pt-BR/docs/Mozilla/Firefox_OS/Debugging/On-device_console_logging" title="/en-US/docs/Mozilla/Firefox_OS/Debugging/On-device_console_logging">Log no console do dispositivo</a></dt>
+ <dd>
+  Como fazer um log no console de um dispositivo Firefox OS e como acessar esse registro para examiná-lo no seu computador.</dd>
+ <dt>
+  <a href="/pt-BR/docs/Mozilla/Firefox_OS/Debugging/Connecting_a_Firefox_OS_device_to_the_desktop" title="/en-US/docs/Mozilla/Firefox_OS/Debugging/Debugging_Firefox_OS_apps_in_desktop_Firefox">Conectando um dispositivo Firefox OS no seu computador</a></dt>
+ <dd>
+  Esse pequeno guia explica como configurar seu dispositivo Firefox OS e seu computador para conetctá-los através da porta USB.</dd>
+ <dt>
+  <a href="/pt-BR/docs/Mozilla/Firefox_OS/Debugging/Setting_up" title="/en-US/docs/Mozilla/Firefox_OS/Debugging/Setting_up">Configurando para depurar o código do Firefox OS</a></dt>
+ <dd>
+  Antes de você usar a maioria das ferramentas integradas ao Firefox OS para depurar o código, você precisa um pequeno trabalho de configuração. Esse artigo explica como fazer isso.</dd>
+</dl>
diff --git a/files/pt-br/archive/b2g_os/debugging/instalando_adb/index.html b/files/pt-br/archive/b2g_os/debugging/instalando_adb/index.html
new file mode 100644
index 0000000000..b620146f02
--- /dev/null
+++ b/files/pt-br/archive/b2g_os/debugging/instalando_adb/index.html
@@ -0,0 +1,99 @@
+---
+title: Instalando e Usando o ADB
+slug: Archive/B2G_OS/Debugging/Instalando_ADB
+translation_of: Archive/B2G_OS/Debugging/Installing_ADB
+---
+<div class="summary">
+<p><span class="seoSummary">Em muitos aspectos do desenvolvimento do Firefox OS será necessário a utilização do aplicativo ADB (Android Debug Bridge). Esse artigo explica como fazer a sua instalação e apresenta algun dos seus comandos mais úteis.</span></p>
+</div>
+
+<h2 id="Instalando_o_ADB">Instalando o ADB</h2>
+
+<p>Você pode baixar e instalar o <code>adb</code> como parte do pacote do Android SDK package, para Mac, Linux ou Windows - visite a página <a href="http://developer.android.com/sdk/index.html">Get the Android SDK</a>.</p>
+
+<p>Distribuições mais recentes do Linux já possuem o <code>adb</code> em seus repositórios. Para Ubuntu 12.10 e posteriores execute o seguinte comando:</p>
+
+<pre>sudo apt-get install android-tools-adb</pre>
+
+<p>Ou para Fedora 18/19:</p>
+
+<pre>sudo yum install android-tools</pre>
+
+<p>Ou no OSX usando <a href="http://brew.sh/">Homebrew</a>:</p>
+
+<pre class="language-html">brew install android-platform-tools</pre>
+
+<p>Se sua distribuição não possui pacotes disponíveis para <code>adb</code> (por exemplo, Ubuntu 12.04 ou Fedora 17), você precisará instalar o <a class="external" href="http://developer.android.com/sdk/index.html" title="http://developer.android.com/sdk/index.html">Android SDK starter package</a> para sua plataforma (Selecione a opção <em>ADT Bundle</em>, e não <em>SDK Tools Only</em>). Então execute o gerenciador de pacote <code>$SDK_HOME/tools/android</code>, e use o GUI para instalar "Android SDK Platform-tools".</p>
+
+<p>Verifique onde o <code>adb</code> foi instalado (normalmente em <code>usr/bin</code>, possivelmente dentro de <code>adt/platform-tools</code>, depdendo de como você o instalou). Certifique-se de adicionar esse diretório em seu <code>PATH</code>. Isso pode ser feito adicionando a linha</p>
+
+<pre>PATH=$SDK_HOME:$PATH</pre>
+
+<p>ao seu <code>~/.bashrc</code> ou equivalente, onde <code>$SDK_HOME</code> é o caminho de onde foi instalado o Android SDK.</p>
+
+<h2 id="Resolvendo_problemas">Resolvendo problemas</h2>
+
+<p>Se você está usando uma instalação 64-bit, e receber um erro "File not found" quando executar 'adb' mesmo ele estando presente, você precisa instalar as bibliotecas de compatibilidade para 32-bit. Para fazer isso execute:</p>
+
+<pre>sudo apt-get install ia32-libs</pre>
+
+<p>Para novas versões do ubuntu:</p>
+
+<pre>sudo apt-get install lib32z1 lib32ncurses5 <code>gcc-multilib</code></pre>
+
+<h2 id="Comandos_comuns_do_ADB">Comandos comuns do ADB</h2>
+
+<p>As próximas seções explicam alguns dos mais comuns e úteis comandos do <code>adb</code>.</p>
+
+<h2 id="Reiniciando_o_processo_b2g">Reiniciando o processo b2g</h2>
+
+<p>b2g é equivalente à aplicação <a href="/pt-BR/docs/XULRunner" title="/en-US/docs/XULRunner">XULRunner</a> que é executada no telefone no topo do kernel Android-based. Em algumas vezes você precisa reiniciá-la. Essa é a melhor maneira de reiniciar o ambiente de aplicações sem a necessidade de reiniciar todo o dispositivo. Você pode fazer isso executando o seguinte comando quando seu dispositivo estiver conectado ao seu computador (ou enquanto estiver executando o depurador):</p>
+
+<pre>adb shell killall b2g</pre>
+
+<h2 id="Habilitando_o_encaminhamento_de_porta_para_depuração">Habilitando o encaminhamento de porta para depuração</h2>
+
+<p>Para habilltar isso (por exemplo se você estiver executando o App Manager para depurar aplicativos em um dispositivo Firefox OS), entre o seguinte comando no seu terminal:</p>
+
+<pre class="language-html">adb forward tcp:6000 localfilesystem:/data/local/debugger-socket</pre>
+
+<p>Você necessitará fazer isso toda vez que o telefone for reiniciado ou for desconectado e reconectado ao computador. Você pode trocar o número do socket se necessário.</p>
+
+<h2 id="Encaminhando_portas_para_uma_máquina_local">Encaminhando portas para uma máquina local</h2>
+
+<p>Para isso, você precisará baixar os binários <a href="http://people.mozilla.org/~jmuizelaar/forward/">netcat and ssh</a>, e executar os seguintes comandos:</p>
+
+<pre class="brush: bash"># this is an awful hack but does in fact work...
+host$ adb forward tcp:7979 tcp:6969
+
+# make some named pipes so that we can make a bidirectional netcat
+phone$ mknod readback p
+host$ mknod readback p
+
+# this sets up a one time use connection to back to the host
+# listen on ports 6969 and 5959 and forward all the information between them
+phone$ ./netcat -l -p 6969 &lt; readback | ./netcat -l -p 5959 &gt; readback
+# connect to port 7979 (port 6969 on the device) and the local ssh server and forward all information between them
+host$ ./netcat localhost 7979 &lt; readback | ./netcat localhost 22 &gt; readback
+
+# now when we connect to port 5959 on the phone it will be like connecting to ssh server on the host
+
+# use the netcat reversal to set up an ssh connection back to the host and forward port 9999 on the device to 'localhost:8000' (this could be anything like 'google.com:80')
+phone$ ./ssh localhost -p 5959 -L 9999:localhost:8000</pre>
+
+<p>No exemplo acima é direcionada a porta 9999 do dispositivo para a porta 8000 do hospedeiro.</p>
+
+<p>Alternativamente você pode usar um servidor ssh (<a href="http://people.mozilla.org/~jmuizelaar/forward/dropbear">dropbear</a> e <a href="http://people.mozilla.org/~jmuizelaar/forward/host_key">host_key</a>) diretamente no dispositivo, usando os seguintes comandos:</p>
+
+<pre class="brush: bash">phone$ DROPBEAR_PASSWORD=root ./dropbear -p 9000 -F -v -a -r host_key ./dropbear
+host$ adb forward tcp:8888 tcp:9000
+# public key authentication has been hard coded to succeed (make sure you have a public key for ssh to use)
+host$ ssh -vvv root@localhost -p 8888 -R 9999:people.mozilla.org:80
+</pre>
+
+<p>Outros recursos:</p>
+
+<ul>
+ <li><a href="http://k.japko.eu/android-dropbear.html">Instruções para compilar dropbear</a></li>
+ <li><a href="http://people.mozilla.org/~jmuizelaar/forward/dropbear-b2g.patch">dropbear patch</a> que desabilita a falha no esquecimento de configurar variáveis de ambiente e o "hard code" no sucesso da autenticação.</li>
+</ul>
diff --git a/files/pt-br/archive/b2g_os/debugging/intercepting_traffic_using_a_proxy/index.html b/files/pt-br/archive/b2g_os/debugging/intercepting_traffic_using_a_proxy/index.html
new file mode 100644
index 0000000000..c273634148
--- /dev/null
+++ b/files/pt-br/archive/b2g_os/debugging/intercepting_traffic_using_a_proxy/index.html
@@ -0,0 +1,177 @@
+---
+title: Interceptando tráfego de Firefox OS usando um proxy
+slug: Archive/B2G_OS/Debugging/Intercepting_traffic_using_a_proxy
+tags:
+  - Debugando
+  - Depuração
+  - Segurança
+  - Testes
+translation_of: Archive/B2G_OS/Debugging/Intercepting_traffic_using_a_proxy
+---
+<p>{{PreviousNext("Mozilla/Firefox_OS/Debugging/Debugging_and_security_testing", "Mozilla/Firefox_OS/Apps/Testing_in_a_privileged_context")}}</p>
+
+<div class="summary">
+<p>Nesta parte do artigo de depuração e testes de segurança olhamos para interceptar tráfego de Firefox OS usando uma ferramenta de proxy, incluindo listas brancas certificado SSL do proxy para Firefox OS não se importa com alguém interceptar e re-criptografar a comunicação HTTPS. Se você usar o B2G Área de Trabalho, na primeira parte do tutorial sobre como instalá-lo e anexar o shell de depuração Marionette JavaScript é explicado em <a href="/pt-BR/docs/Mozilla/Firefox_OS/Security/Debugging_and_security_testing" style="text-decoration: underline; font-weight: bold; background-color: rgb(244, 247, 248);" title="/en-US/docs/Mozilla/Firefox_OS/Security/Debugging_and_security_testing">Debugging e segurança de testes com o Firefox OS</a>.</p>
+</div>
+
+<p>Trabalhando com aplicativos que não são nada mais do que HTML e JavaScript, você vai descobrir que uma grande parte do trabalho realmente interessante envolve o uso de APIs que transferem dados através da Web. Isso significa que muitas vezes é útil olhar para as solicitações HTTP que esses aplicativos executam. Ferramentas de proxy como <a href="http://portswigger.net/burp/">Burp</a> e <a href="https://www.owasp.org/index.php/OWASP_Zed_Attack_Proxy_Project" style="text-decoration: underline;">ZAP</a> tem características úteis para o monitoramento desse tráfego. Elas fornecem os manifestos que contenham informações sobre como os clientes devem configurar, incluindo os certificados de raiz para instalar para a terminação TLS etc.</p>
+
+<p>Combinado com o recurso do 'processo principal de debug Firefox OS' do <a href="/pt-BR/Firefox_OS/Using_the_App_Manager">app manager</a>, eles permitem que você instale a cert raiz do seu proxy para o seu dispositivo executando <a href="https://github.com/mozfreddyb/b2g-misc/blob/master/PnH-FxOS.js" style="text-decoration: underline;">algum código</a> a partir de um rascunho.</p>
+
+<h2 id="Depurando_o_processo_principal_do_Firefox_OS">Depurando o processo principal do Firefox OS</h2>
+
+<p>Então como você depura o processo principal no Firefox? Se você estiver usando o Firefox Simulator ou um dispositivo real, é possível depurar aplicativos certificados através da App Manager, <a href="https://developer.mozilla.org/pt-BR/Firefox_OS/Using_the_App_Manager#Debugging_Certified_Apps" style="text-decoration: underline;">definindo algumas prefs em seu perfil</a>. Siga estes passos em primeiro lugar, em seguida, defina o devtools.chrome.enabled pref para true no about:config, antes de reiniciar o browser.</p>
+
+<p>Em seguida, conecte o seu dispositivo / simulador usando o Gerenciador de App, em seguida, na tela do dispositivo, você verá um botão "PROCESSO PRINCIPAL DE DEBUG"; clique nele e você poderá depurar JSMS e executar JavaScript privilegiado no rascunho.</p>
+
+<div class="note">
+<p>Nota: Cuidado com o que você executa contra o processo principal: você pode acidentalmente destruir o seu dispositivo!</p>
+</div>
+
+<h2 id="Introduzindo_ZAP">Introduzindo ZAP</h2>
+
+<p>Primeiro, vamos continuar o processo usando ZAP. ZAP é um proxy interceptor que intercepta e criptografa novamente o tráfego HTTPS para facilitar a depuração. Clique no botão azul grande na <a href="https://www.owasp.org/index.php/ZAP" title="https://www.owasp.org/index.php/ZAP">ZAP homepage</a> para baixá-lo. Se você optar por usar outro proxy sinta-se a vontade para fazê-lo, nossa abordagem deve funcionar com ambos.</p>
+
+<h3 id="Certificado_ZAP">Certificado ZAP</h3>
+
+<p>Agora, em qualquer proxy que você usar, deixe-o exportar seu certificado para um arquivo, como <code>owasp_zap_root_ca.cer</code> (vá em <em><code>Ferramentas &gt; Opções &gt; Certificados SSL dinâmicos &gt; Salvar</code></em>). Quando ZAP inicia, ele gera um certificado válido durante um ano. Você também pode gerar um novo a partir da seção Certificados SSL dinâmico.</p>
+
+<h3 id="Proxy_local">Proxy local</h3>
+
+<p>If you're using B2G desktop, you have to make sure that ZAP does not listen on <code style="font-style: normal;">localhost</code>, but instead on your attributed IP address (ethernet or Wi-Fi). This is because B2G Desktop's <code style="font-style: normal;">localhost</code> does not point to your desktop computer, but something within the <code style="font-style: normal;">b2g</code> binary itself. For our example, we will use my IP address: <code style="font-style: normal;">10.264.1.5</code>.</p>
+
+<p>Se você está trabalhando com um dispositivo real, você precisa ter certeza de que o seu telefone e o seu computador estão conectados à mesma rede / VLAN e podem se comunicar entre si (se você tiver uma dúvida, tente fazer o ping do IP de um dispositivo de o outro).</p>
+
+<h2 id="Conectando_seu_dispositivo_ao_proxy">Conectando seu dispositivo ao proxy</h2>
+
+<p>Você pode extrair as prefs do seu dispositivo, mudá-los para adicionar as preferências de proxy relevantes, colocá-los de volta.</p>
+
+<p>You can pull the default prefs from your device, change them to add the relevant proxy prefs, put them back.</p>
+
+<p>Ou, você pode configurar a sua ferramenta para <a href="https://www.computerist.org/blog/2014/07/23/Transparent-HTTPS-proxying-with-ZAP/">proxy HTTP and HTTPS transparente</a> em seguida, configurar iptables no seu dispositivo para apontar para o proxy. Por exemplo, para fazer tráfego de HTTPS passar por sua ferramenta de proxy:</p>
+
+<div class="codehilite">
+<pre><span class="n">adb</span> <span class="n">shell</span> <span class="n">iptables</span> <span class="o">-</span><span class="n">t</span> <span class="n">nat</span> <span class="o">-</span><span class="n">A</span> <span class="n">OUTPUT</span> <span class="o">-</span><span class="n">p</span> <span class="n">tcp</span> <span class="o">--</span><span class="n">dport</span> <span class="mi">443</span> <span class="o">-</span><span class="n">j</span> <span class="n">DNAT</span> <span class="o">--</span><span class="n">to</span><span class="o">-</span><span class="n">destination</span> <span class="mf">192.168.0.14</span><span class="o">:</span><span class="mi">8443</span>
+</pre>
+</div>
+
+<p>E, para redefini-la quando estiver pronto:</p>
+
+<div class="codehilite">
+<pre><span class="n">adb</span> <span class="n">shell</span> <span class="n">iptables</span> <span class="o">-</span><span class="n">t</span> <span class="n">nat</span> <span class="o">-</span><span class="n">F</span>
+</pre>
+</div>
+
+<h3 id="Configurando_um_proxy_LAN">Configurando um proxy LAN</h3>
+
+<p>Se você está perceber que está fazendo muito esse tipo de atividade, há um caminho que é ainda mais conveniente; configurar um teste LAN onde todo o tráfego é aproximado por padrão. Dessa forma, você poderá transformar o proxy e desligar apenas mudando o que wireless LAN que você está conectado.</p>
+
+<p>Nós construímos um usando um raspberry pi e <a href="http://raspberry-at-home.com/hotspot-wifi-access-point/">passos semelhantes a estes</a>. Mudamos as regras do <code>iptables</code> para ficar assim:</p>
+
+<div class="codehilite">
+<pre class="brush: bash">*filter
+:INPUT ACCEPT [49:3128]
+:FORWARD ACCEPT [0:0]
+:OUTPUT ACCEPT [37:3924]
+-A FORWARD -i eth0 -o wlan0 -m state --state RELATED,ESTABLISHED -j ACCEPT
+-A FORWARD -i wlan0 -o eth0 -j ACCEPT
+COMMIT
+*nat
+:PREROUTING ACCEPT [1:72]
+:INPUT ACCEPT [1:72]
+:OUTPUT ACCEPT [1:148]
+-A PREROUTING -i wlan0 -p tcp -m tcp --dport 80 -j DNAT --to-destination &lt;proxy_host&gt;:&lt;http_port&gt;
+-A PREROUTING -i wlan0 -p tcp -m tcp --dport 443 -j DNAT --to-destination &lt;proxy_host&gt;:&lt;https_port&gt;
+:POSTROUTING ACCEPT [0:0]
+-A POSTROUTING -o eth0 -j MASQUERADE
+COMMIT
+</pre>
+</div>
+
+<h2 id="Criando_um_banco_de_dados_certificado">Criando um banco de dados certificado</h2>
+
+<p>O ato de aceitar certificados acontece em configurações, que são armazenadas nos perfis. Aqui está uma pequena cartilha sobre perfis do Firefox:</p>
+
+<ol start="1" style="list-style-type: decimal; margin-left: 40px;">
+ <li>Inicie o gerenciador de perfil do Firefox usando a opção -P na linha de comando, e certifique-se de que o Firefox não esteja usando todas as sessões do Firefox existentes (-no-remote):
+  <ul style="margin-left: 40px;">
+   <li>No Linux, você precisa dar o seguinte comando:
+    <pre class="brush: bash">firefox -P -no-remote</pre>
+   </li>
+   <li>No Mac OS X:
+    <pre class="brush: bash">/Applications/Firefox.app/Contents/MacOS/firefox -P -no-remote</pre>
+   </li>
+  </ul>
+ </li>
+ <li>Agora crie um novo perfil chamado "zapped". Vá para as configurações de certificado - <em>Editar &gt; Preferências &gt; Avançado &gt; Criptografia &gt; Exibir Certificados &gt; Importar</em>. Agora selecione o arquivo <code>owasp_zap_root_ca.cer</code> criado por seu proxy e diga ao Firefox que ele deve confiar neste CA para identificar sites (isto é realmente válido apenas para este perfil).</li>
+ <li>Após utilizar o Firefox para criar um banco de dados certificado para nós, agora podemos usar esse banco de dados para o nosso perfil B2G. O nome do diretório do perfil do Firefox é uma seqüência aleatória que termina com zapped. A localização depende do seu sistema operacional; veja  <a href="/pt-BR/docs/Runtime_Directories" title="/en-US/docs/Runtime_Directories">Diretórios Runtime</a> para obter detalhes sobre onde ele pode ser encontrado.</li>
+ <li><strong>Para B2G desktop</strong>, precisamos apenas do arquivo <code>cert8.db</code>, que é a base de dados certificados do perfil. Copie-o para o seu perfil B2G diretório <code>b2g/gaia/profile/</code>.</li>
+ <li><strong>Em um dispositivo</strong>, copie o cert9.db em seu diretório de perfil do dispositivo:
+  <pre>$ adb shell stop b2g
+$ adb push cert9.db /data/b2g/mozilla/*.default</pre>
+ </li>
+</ol>
+
+<div class="note">
+<p>Nota: Isto irá substituir o arquivo existente.</p>
+</div>
+
+<h2 id="Configurando_B2G">Configurando B2G</h2>
+
+<p>O próximo passo é definir ZAP como o proxy padrão para toda a comunicação de rede. As configurações de proxy, como as definições do certificado, não estão atualmente disponíveis a partir da interface do usuário Firefox OS.</p>
+
+<h3 id="Em_B2G_desktop">Em B2G desktop</h3>
+
+<p>Você precisa anexar essas configurações personalizadas para o arquivo de preferências, <code>b2g/gaia/profile/prefs.js</code>:</p>
+
+<pre><code class="brush: bash">user_pref("network.proxy.backup.ftp", "10.264.1.5");
+user_pref("network.proxy.backup.ftp_port", 8080);
+user_pref("network.proxy.backup.socks", "10.264.1.5");
+user_pref("network.proxy.backup.socks_port", 8080);
+user_pref("network.proxy.backup.ssl", "10.264.1.5");
+user_pref("network.proxy.backup.ssl_port", 8080);
+user_pref("network.proxy.ftp", "10.264.1.5");
+user_pref("network.proxy.ftp_port", 8080);
+user_pref("network.proxy.http", "10.264.1.5");
+user_pref("network.proxy.http_port", 8080);
+user_pref("network.proxy.no_proxies_on", "");
+user_pref("network.proxy.share_proxy_settings", true);
+user_pref("network.proxy.socks", "10.264.1.5");
+user_pref("network.proxy.socks_port", 8080);
+user_pref("network.proxy.ssl", "10.264.1.5");
+user_pref("network.proxy.ssl_port", 8080);
+user_pref("network.proxy.type", 1);</code>
+</pre>
+
+<div class="note">
+<p>Nota: Lembre-se de substituir o meu endereço IP 10.264.1.5 pelo seu, e se o seu proxy não escuta na porta 8080, certifique-se de alterá-lo neste arquivo também.</p>
+</div>
+
+<p>Neste momento, você já deverá estar pronto! Inicie o B2G Desktop novamente, e tente alguma navegação. O tráfego de rede deverá aparecer na ZAP.</p>
+
+<h3 id="Em_um_dispositivo">Em um dispositivo</h3>
+
+<p>Para habilitar essa funcionalidade em um dispositivo, você precisará modificar o arquivo  <code>prefs.js</code> file localizado no seu perfil do seu dispositivo. Conecte o dispositivo ao computador que tenha sido previamente configurado com as ferramentas EDA.</p>
+
+<p>Primeiro, você precisa saber qual é o nome do seu diretório de perfil. Você pode encontrá-lo assim:</p>
+
+<pre>adb shell ls /data/b2g/mozilla</pre>
+
+<p>Entre a saída, você verá um diretório chamado com uma série de letras e números aleatórios que terminam em ".default". Este é o seu diretório de perfil. Use este nome, onde você vê "xxxxxxxx" daqui em diante.</p>
+
+<p>Em seguida, pegue o arquivo <code>prefs.js</code> para que você possa editá-lo:</p>
+
+<pre>adb pull /data/b2g/mozilla/xxxxxxx.default/prefs.js</pre>
+
+<p>Abra o arquivo resultante em seu editor de texto favorito; no final do arquivo, adicione as configurações personalizadas indicadas na seção acima e salve as alterações. Agora tudo que você precisa fazer é empurrar o arquivo alterado de volta para o dispositivo e reiniciar o processo de B2G para pegar as alterações, como segue (o processo B2G já deve ser interrompido se você seguiu as instruções anteriores para empurrar cert9.db):</p>
+
+<pre>adb push pref.js /data/b2g/mozilla/xxxxxxxx.default
+adb shell start b2g</pre>
+
+<p>{{PreviousNext("Mozilla/Firefox_OS/Debugging/Debugging_and_security_testing", "Mozilla/Firefox_OS/Apps/Testing_in_a_privileged_context")}}</p>
+
+<h3 id="Charles_Proxy">Charles Proxy</h3>
+
+<p>Usuários que desejam usar Charles Proxy deverão ver este post: <a href="https://muffinresearch.co.uk/proxying-connections-from-ffos/">https://muffinresearch.co.uk/proxying-connections-from-ffos/</a></p>
+
+<p> </p>
diff --git a/files/pt-br/archive/b2g_os/debugging/log_console_no_dispositivo/index.html b/files/pt-br/archive/b2g_os/debugging/log_console_no_dispositivo/index.html
new file mode 100644
index 0000000000..a0ccfe5a2f
--- /dev/null
+++ b/files/pt-br/archive/b2g_os/debugging/log_console_no_dispositivo/index.html
@@ -0,0 +1,62 @@
+---
+title: Log do console no dispositivo
+slug: Archive/B2G_OS/Debugging/Log_console_no_dispositivo
+translation_of: Archive/B2G_OS/Debugging/On-device_console_logging
+---
+<div class="summary">
+ <p><span class="seoSummary">Para que você possa fazer o log do console e vê-lo usando <a href="/pt-BR/docs/Mozilla/Firefox_OS/Debugging/Using_the_Remote_Web_Console" title="/en-US/docs/Mozilla/Firefox_OS/Debugging/Using_the_Remote_Web_Console">remote web console</a>, você pode armazenar a saída do console no seu próprio dispositivo, e então recuperar os logs a partir do seu computador usando o utilitário <a href="http://developer.android.com/tools/help/logcat.html" title="http://developer.android.com/tools/help/logcat.html"><code>logcat</code></a> através de uma conexão USB. Esse artigo mostra como habilitar esse recurso, executar o log e recuperá-lo.</span></p>
+</div>
+<h2 id="Habilitando_a_geração_dos_logs">Habilitando a geração dos logs</h2>
+<p>Nas imagens de produção do Firefox OS, a geração de log (por exemplo {{domxref("console.log()")}}) é desabilitada por padrão, então habilte essa opção nas configurações do seu dispositivo em <a href="/pt-BR/Firefox_OS/Debugging/Developer_settings">Configurações do desenvolvedor</a> opção <em>Console Ativado</em>.</p>
+<h2 id="Log">Log</h2>
+<p>Uma vez o registro de logs ativado, ele funciona da mesma forma que o log no desktop Firefox OS. Simplesmente use os métodos do objeto {{domxref("console")}} para criar um texto de log no console. Por exemplo:</p>
+<pre class="brush: js">console.info("Starting up the foobar hardware!");
+var err = foobar.start();
+if (err) {
+  console.error("--Error %d starting up the foobar hardware!", err);
+}
+</pre>
+<div class="note">
+ <p><strong>Nota</strong>: Veja {{domxref("console")}} para detalhes dos recursos de log disponíveis para vocês.</p>
+</div>
+<h2 id="Usando_logcat">Usando logcat</h2>
+<p>Devido ao fato da saída de log ser armazenada no dispositivo Firefox OS e não existir nenhuma interface de usuário para verificar os logs no dispositivo, Because the log output is stored on the Firefox OS device, and there isn't currently any user interface for viewing these logs on the device, você terá que trazê-los para um computador para que possa analisá-los. Para fazer isso use o comando <code>logcat</code> do <code>adb</code>, que faz parte do pacote Android SDK (veja <a href="/pt-BR/Firefox_OS/Debugging/Installing_ADB">Instalando o ADB</a>).</p>
+<p>Felizmente o uso do <code>logcat</code> é muito simples: uma vez o <code>adb</code> instalado e o dispositivo conectado ao seu computador via USB, você pode usá-lo através do terminal:</p>
+<pre class="brush: bash">adb logcat</pre>
+<p>Esse comando apresenta o log do dispositivo (armazenado em <code>/dev/log/system/</code>) na saída to terminal. Por exemplo:</p>
+<pre class="brush: bash">I/Vold    (  107): Vold 2.1 (the revenge) firing up
+D/Vold    (  107): Volume sdcard state changing -1 (Initializing) -&gt; 0 (No-Media)
+D/Vold    (  107): Volume emmc state changing -1 (Initializing) -&gt; 0 (No-Media)
+D/Vold    (  107): Volume sdcard state changing 0 (No-Media) -&gt; 2 (Pending)
+D/Vold    (  107): Volume sdcard state changing 2 (Pending) -&gt; 1 (Idle-Unmounted)
+W/Vold    (  107): Duplicate state (1)
+W/Vold    (  107): Duplicate state (1)
+W/Vold    (  107): Duplicate state (1)
+W/Vold    (  107): Duplicate state (1)
+W/Vold    (  107): Duplicate state (1)
+W/Vold    (  107): Duplicate state (1)
+W/Vold    (  107): Duplicate state (1)
+W/Vold    (  107): Duplicate state (1)
+W/Vold    (  107): Duplicate state (1)
+W/Vold    (  107): Duplicate state (1)
+W/Vold    (  107): Duplicate state (1)
+W/Vold    (  107): Duplicate state (1)
+W/Vold    (  107): Duplicate state (1)
+D/Vold    (  107): Volume emmc state changing 0 (No-Media) -&gt; 2 (Pending)
+D/Vold    (  107): Volume emmc state changing 2 (Pending) -&gt; 1 (Idle-Unmounted)
+D/VoldCmdListener(  107): volume list
+D/VoldCmdListener(  107): volume mount sdcard
+I/Vold    (  107): /dev/block/vold/179:20 being considered for volume sdcard
+D/Vold    (  107): Volume sdcard state changing 1 (Idle-Unmounted) -&gt; 3 (Checking)
+W/Vold    (  107): Skipping fs checks
+I/Vold    (  107): Device /dev/block/vold/179:20, target /mnt/sdcard mounted @ /mnt/secure/staging
+D/Vold    (  107): Volume sdcard state changing 3 (Checking) -&gt; 4 (Mounted)
+D/VoldCmdListener(  107): volume mount emmc
+I/Vold    (  107): /dev/block/vold/179:33 being considered for volume emmc
+D/Vold    (  107): Volume emmc state changing 1 (Idle-Unmounted) -&gt; 3 (Checking)
+W/Vold    (  107): Skipping fs checks
+I/Vold    (  107): Device /dev/block/vold/179:33, target /mnt/emmc mounted @ /mnt/secure/staging
+D/Vold    (  107): Volume emmc state changing 3 (Checking) -&gt; 4 (Mounted)
+
+etc.
+</pre>
diff --git a/files/pt-br/archive/b2g_os/debugging/taking_screenshots/index.html b/files/pt-br/archive/b2g_os/debugging/taking_screenshots/index.html
new file mode 100644
index 0000000000..e0bc5bcff0
--- /dev/null
+++ b/files/pt-br/archive/b2g_os/debugging/taking_screenshots/index.html
@@ -0,0 +1,61 @@
+---
+title: Tirar screenshots
+slug: Archive/B2G_OS/Debugging/Taking_screenshots
+tags:
+  - Firefox OS
+translation_of: Archive/B2G_OS/Debugging/taking_screenshots
+---
+<p>Tirar screenshots de sua aplicação poderia ser útil para mostrar seu trabalho para um cliente, para mostrar na frente dos seus amigos com o telefone FxOS, para publicar no Marketplace, entre outros.</p>
+<p>Esse artigo explica como tirar screenshots com o seu Firefox OS. Os desenvolvedores Android irão facilmente assimilar as coisas, pois os passos são muito similares.</p>
+<h2 id="Preparando_seu_telefone">Preparando seu telefone</h2>
+<p><span style="line-height: 21px;">No telefone, entre em Configurações (Settings) &gt; Informação do Dispositivo (Device Information) &gt; Mais informações (More Information) &gt; Em Desenvolvedor marque: "Depuração Remota (Remote Debugging)" e "Habilitar console (Console Enabled)"</span></p>
+<p><span style="line-height: 21px;">Plug o seu celular ao computador.</span></p>
+<p>Agora, você tem três escolhas: usar o Terminal, usar o DDMS no Eclipse ou usar uma combinação de botões no telefone.</p>
+<h2 id="Tirando_um_screenshot">Tirando um screenshot</h2>
+<h3 id="Terminal">Terminal</h3>
+<p>Abra a janela do terminal.</p>
+<ol>
+ <li>Para tirar o screenshot, nós iremos chama-lo de "screenshot.png"<br>
+  <code>adb shell screencap -p /sdcard/screenshot.png</code></li>
+ <li>Pegue a imagem no seu computador<br>
+  <code>adb pull /sdcard/screenshot.png</code></li>
+ <li>Remova o screenshot do seu telefone<br>
+  <code>adb shell rm /sdcard/screenshot.png</code></li>
+</ol>
+<p>Alternativamente, você pode usar ffmpeg:</p>
+<ol>
+ <li>Certifique-se de ter instalado o ffmpeg:
+  <ol>
+   <li>No Mac, se você usa MacPorts, você pode usar: <code>sudo port install ffmpeg</code>. Pelo homebrew: <code>brew install ffmpeg</code>.</li>
+   <li>No Linux (Ubuntu/Debian), use <code>sudo apt-get install ffmpeg</code>.</li>
+  </ol>
+ </li>
+ <li><code>cd</code> no diretório <code>B2G/gaia</code>.</li>
+ <li>Use o comando <code>make screenshot</code>.</li>
+ <li>Você terá sua cópia de tela em <code>screenshot.png</code>.</li>
+</ol>
+<h3 id="DDMS">DDMS</h3>
+<p>Abra o Eclipse.</p>
+<ol>
+ <li>Abra o DDMS<br>
+  Window &gt; Open Perspective &gt; Other &gt; DDMS</li>
+ <li>No painel do lado esquerdo, aba "Dispositivos (Devices)", clique no botão "Capturar tela (Screen capture)"</li>
+ <li>Uma nova janela aparecer com algumas opções, clique no botão "Salvar"</li>
+</ol>
+<div class="note">
+ <p><span style="line-height: 21px;"><strong>Nota: </strong>Quer aprender mais sobre ADB? De uma olhada na </span><a href="http://developer.android.com/tools/help/adb.html" style="line-height: inherit;" title="ADB documentation">documentação</a><span style="line-height: inherit;">.</span></p>
+</div>
+<h3 id="Combinação_de_botões_no_telefone">Combinação de botões no telefone</h3>
+<ol>
+ <li>A partir da versão 2.0 do Firefox OS versions up to 2.0, pressione simultaneamente os botões <em>Home</em> e <em>Power</em>.</li>
+ <li>A partir da versão 2.1 também funcionará pressionando os botões <em>Volume para baixo</em> e <em>Power</em> por alguns segundos.</li>
+</ol>
+<p>Isso vai fazer uma cópia da tela, cujo arquivo será salvo na sua Galeria. Você poderá copiar a imagem do SDCard para o seu computador utilizando o método que você preferir.</p>
+<div class="note">
+ <p><strong>Nota</strong>: A combinação de botões foi alterada porque muitas pessoas acham que é difícil pressionar os botões Home e Power, principalmente se utilizar uma só mão. Outro problema se dá com dispositivos que não possuem o botão Home fisicamente.</p>
+</div>
+<h3 id="App_ManagerSimulador">App Manager/Simulador</h3>
+<ol>
+ <li>No <a href="https://developer.mozilla.org/pt-BR/Firefox_OS/Using_the_App_Manager">App Manager</a>, conecte seu telefone e vá para a tab <strong>Device</strong>, na esquerda.</li>
+ <li>Clique no botão <strong>Screenshot</strong> na parte inferior da página (no mesmo local que você inicia o simulador).</li>
+</ol>