From 074785cea106179cb3305637055ab0a009ca74f2 Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:42:52 -0500 Subject: initial commit --- .../index.html | 38 +++++ .../b2g_os/debugging/configurando/index.html | 39 +++++ .../index.html" | 164 +++++++++++++++++++ .../debugging_b2g_using_valgrind/index.html | 88 ++++++++++ .../debugging/depurando_b2g_usando_gdb/index.html | 84 ++++++++++ .../depurando_erros_falta_de_memoria/index.html | 66 ++++++++ .../firefox_os_crash_reporting/index.html | 123 ++++++++++++++ files/pt-br/archive/b2g_os/debugging/index.html | 72 +++++++++ .../b2g_os/debugging/instalando_adb/index.html | 99 ++++++++++++ .../intercepting_traffic_using_a_proxy/index.html | 177 +++++++++++++++++++++ .../log_console_no_dispositivo/index.html | 62 ++++++++ .../b2g_os/debugging/taking_screenshots/index.html | 61 +++++++ 12 files changed, 1073 insertions(+) create mode 100644 files/pt-br/archive/b2g_os/debugging/conectando_um_dispositivo_com_firefox_os_no_desktop/index.html create mode 100644 files/pt-br/archive/b2g_os/debugging/configurando/index.html create mode 100644 "files/pt-br/archive/b2g_os/debugging/configura\303\247\303\265es_do_desenvolvedor/index.html" create mode 100644 files/pt-br/archive/b2g_os/debugging/debugging_b2g_using_valgrind/index.html create mode 100644 files/pt-br/archive/b2g_os/debugging/depurando_b2g_usando_gdb/index.html create mode 100644 files/pt-br/archive/b2g_os/debugging/depurando_erros_falta_de_memoria/index.html create mode 100644 files/pt-br/archive/b2g_os/debugging/firefox_os_crash_reporting/index.html create mode 100644 files/pt-br/archive/b2g_os/debugging/index.html create mode 100644 files/pt-br/archive/b2g_os/debugging/instalando_adb/index.html create mode 100644 files/pt-br/archive/b2g_os/debugging/intercepting_traffic_using_a_proxy/index.html create mode 100644 files/pt-br/archive/b2g_os/debugging/log_console_no_dispositivo/index.html create mode 100644 files/pt-br/archive/b2g_os/debugging/taking_screenshots/index.html (limited to 'files/pt-br/archive/b2g_os/debugging') 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 +--- +
+

Este guia explica como conectar um dispositivo Firefox OS em seu desktop através do USB.

+
+
+

Nota: 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 Usando o App Manager para mais detalhes. Se sua versão for inferior à 1.2, leia Configurando o Firefox OS para depurar usando as ferramentas de desenvolvimento do Firefox para aprender sobre o uso da depuração remota padrão.

+
+

Configurar o dispositivo

+

No seu Firefox OS (ver a ilustração):

+
    +
  1. Abrir o aplicativo Configurações, em seguida: Informações > Mais Informações > Desenvolvedor.
    2. +
  2. No menu de desenvolvedores, marque a opção: "Depuração Remota".
    3. +
+

Configurar o Desktop

+

Para conectar o dispositivo ao desktop, você precisa do Android Debug Bridge (adb) instalado. Note que o Simulador do Firefox OS adiciona o pacote adb para você.

+

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 "Configurando um Dispositivo para Desenvolvimento (em inglês)" no site do desenvolvedor Android. Nós listamos algumas instruções adicionais abaixo.

+

Instruções Especiais para Mac OS X

+

Se você estiver executando o Mac OS X, você deve ter baixado um pacote com um nome longo adt-bundle-mac-x86_64-20130522. Coloque essa pasta dentro de Applications, de moto que você tenha /Applications/adt-bundle-mac-x86_64-20130522/ que contém dois diretórios: eclipse e sdk. Depois, você pode editar seu ~/.bashrc e adicionar:

+
export PATH="/Applications/adt-bundle-mac-x86_64-20130522/sdk/platform-tools:$PATH"
+

(Ele estará pronto na próxima vez que você iniciar o shell). Agora você pode digitar no CLI do shell:

+
adb devices
+
+

e ele irá retornar uma lista de dispositivos conectados, tais como:

+
List of devices attached
+AA:BB:A5:B5:AA:BB    device
+

Instruções Especiais para Linux

+

Se você estiver executando o Linux, a identificação do fornecedor para usar os dispositivos Geeksphone com Firefox OS é 05c6, assim seu arquivo /etc/udev/rules.d/51-android.rules deverá conter uma entrada similar a:

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

Instruções Especiais para Windows

+

Você pode realizar download dos drivers para Windows através do site da fabricante Geeksphone.

+

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 "Como instalar um driver não assinado no Windows 8 (em inglês)".

+

Uma vez que o Windows XP Home Edition não possui o arquivo tasklist.exe, o simulador pode não detectar o dispositivo. Isso pode ser solucionado baixando esse arquivo do site ComputerHope e colocá-lo na pasta Windows\System32.

+

Verificando sua Configuração

+

Depois de ter seguido as instruções, conecte o dispositivo no computador usando o cabo USB, abra um prompt de comando e digite "adb devices" (garantindo que adb está no seu caminho). Você deverá ver o seu dispositivo Firefox OS listado na saída.

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

O Firefox OS suporta o mesmo protocolo de depuração remota presente no Firefox para Android. Isto significa que você pode usar as ferramentas de desenvolvimento do Firefox para depurar aplicativos do Gaia executado em um dispositivo Firefox OS ou simulador. Para depurar o Firefox OS rodando no seu dispositivo ou no Firefox OS Simulator, você precisa usar o Firefox 18 ou superior e, além disso, existem configurações que precisam ser alteradas, tanto na configuração do Firefox quanto no dispositivo Firefox OS ou simulador.

+
+
+

Nota: Se você deseja depurar aplicações em um dispositivo com Firefox OS em versão 1.2 ou superior. Sua melhor opção é usar o App Manager.

+
+

Firefox

+

Você precisa ter certeza de que você tem uma versão do Firefox 18 ou superior, a fim de ter suporte à depuração remota. Se você ainda não tem uma versão recente, baixe a última versão Nightly para obter acesso à todos os recursos mais recentes.

+

Uma vez que você esteja executando uma versão apropriada do Firefox em seu computador, digite about:config na barra de endereços, aceite o termo e pesquise por devtools.debugger.remote-enabled em seguida altere o seu valor para true. 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, Ferramentas > Conectar.

+

Habilitando a depuração

+

Ao usar o Firefox OS Simulator (B2G Desktop), a configuração para depuração é muito fácil. Você não precisa fazer encaminhamento de porta, como você faz quando a depuração é em um dispositivo físico. Basta abrir o aplicativo Configurações, em seguida: Informações > Mais Informações > Desenvolvedor ative Depuração remota.

+
+

Nota: Isso não funciona mais em dispositivos com Firefox OS desde 10 de Janeiro de 2013. Eventualmente, haverá uma maneira de construir a sua própria compilação com ele re-ativado, mas isso ainda não existe. Este documento será atualizado assim que acontecer. Além disso, a preferência para desligar o suporte "out-of-process" foi removido. Por enquanto, você precisa fazer a sua depuração no Firefox OS Simulator.

+
+

Se estiver usando um dispositivo com Firefox OS, abra as Configurações do Desenvolvedor e:

+ +
+

Nota: Se você aplicar as definições de fábrica no dispositivo, você terá que refazer essas alterações de configuração.

+
+

Agora você está pronto para usar o depurador!

+

Habilitando o log do console em um dispositivo Firefox OS

+

Na produção de versões do Firefox OS, o log do console (por exemplo {{domxref("console.log()")}}) é desativado por padrão. Para ativá-lo, vá para Configurações do Desenvolvedor no seu dispositivo e habilite Console Ativado.

+

Nota: Leia o artigo On-device console logging para mais detalhes sobre como usar o console logging on Firefox OS.

+

Veja também

+ diff --git "a/files/pt-br/archive/b2g_os/debugging/configura\303\247\303\265es_do_desenvolvedor/index.html" "b/files/pt-br/archive/b2g_os/debugging/configura\303\247\303\265es_do_desenvolvedor/index.html" new file mode 100644 index 0000000000..de82a2026d --- /dev/null +++ "b/files/pt-br/archive/b2g_os/debugging/configura\303\247\303\265es_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 +--- +
+

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 a depuração de sua aplicação web no Firefox OS mais fácil. Este artigo aborda as opções disponíveis e como fazer uso deles.

+
+

O painel de configurações para as opções de desenvolvedor é intencionalmente "trancando a sete chaves" para evitar que os usuários finais que não têm necessidade de fazer uso dessas opções, inadvertidamente, realizem a ativação de opções que farão o dispositivo funcionar mais lentamente ou adicionar efeitos visuais estranhos as suas telas. O painel é algo como isto (o que se segue é 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):

+

+

O painel de desenvolvedor é acessado da seguinte forma:

+ +

As seções a seguir abordam cada uma das opções presentes no painel do desenvolvedor. Explicando o que elas fazem e descrevendo suas utilidades.

+
+

Nota do tradutor: 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.

+
+

Configurações das ferramentas de desenvolvimento

+

Depurando via USB

+

A opção "Depuração Remota" habilita o suporte para depurar remotamente seu dispositivo Firefox OS. Isso também habilitar os comandos ADB. 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:

+ +

HUD (Head Up Display) do desenvolvedor

+

Disponível nas versões Firefox OS 1.4 e posteriores.

+

+

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:

+ +

Frames per second

+

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. 

+ +

A screenshot of Firefox OS, showing three numbers in the top left hand corner that are measurements of app framerate.

+

Time to load

+

Firefox OS também tem uma ferramenta que ajuda a medir o tempo de inicialização, especificamente o tempo do "first paint". 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 "first paint", 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.

+

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.

+

App memory

+

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.

+

+

Piscar área desenhada

+

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.

+

A screenshot of Firefox OS with a number of transparent overlays, showing the parts of the screen repainted with each new animation frame.

+

Configurações gráficas

+

Habilitar APZ para todo conteúdo (era Async Pan/Zoom)

+

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

+

Tiling (era Layers: Enable tiles)

+

Introduzido no Firefox OS 1.4, esse recurso possibilita o desenho do conteúdo na tela em pedaços pequenos ("tiles") 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.

+

Simple tiling (era Layers: Simple tiles)

+

Inverte entre as duas implementações diferentes do desenho de conteúdo descritos na seção acima.

+

Hardware composer (era Enable hardware compositing)

+

Quando habilitado, faz o dispositivo usar o Hardware Composer para compor elementos visuais (superfícies) na tela.

+

Draw tile borders (era Layers: Draw tile borders)

+

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.

+

Mostrar layers

+

Desenha uma borda brilhande e colorida ao redor das diferentes camadas desenhadas na tela — bom para diagnosticar problemas de layout.

+

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.

+

Dump layers tree

+

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.

+

Cards View: Cópia de tela

+

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.

+

Configurações do gerenciamento de janelas

+

Botão Home por Software

+

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.

+

Gesto para tela de início ativado

+

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.

+

Gesto de canto

+

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.

+

Continuous transition

+

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.

+

App transition

+

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.

+

App suspending

+

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.

+

Configuração de depuração

+

Reg. animaçõe lentas

+

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:

+
I/Gecko   ( 5644): Performance warning: Async animation disabled because frame size (1280, 410) is bigger than the viewport (360, 518) [div with id 'views']
+
+

Saída Wi-Fi para adb

+

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 adb logcat | grep "Error")

+

Bluetooth output in adb

+

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 adb logcat | grep "Error")

+

Console ativado

+

Quando habilitado, essa opção permite usar o Web Console no Firefox para acessa remotamente o console do dispositivo, sem essa opção habilitada, a função {{domxref("console.log()")}} não faz nada.

+

Gaia debug traces

+

Isso habilita diretamente DEBUG traces no Gaia; veja {{ bug("881672") }} para mais detalhes.

+
+

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

+
+

Show accessibility settings

+

Habilitar o menu de configurações de acessibilidade, que poderá ser acessado em Configurações > Accessibilidade. As opções são as seguintes:

+

Leitor de Tela

+

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:

+ +
+

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

+
+

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

+

Speech volume

+

Controle deslizante do volume da voz.

+

Speech rate

+

Controle deslizante da velocidade da voz.

+

Abrir a primeira utilização

+

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.

+

Configurações obsoletas

+

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.

+

Accessibilidade

+

Nas versões anteriores à 1.4, essa opção apresentava as configurações explicadas na seção {{ anch("Show_accessibility_settings") }}.

+

Grid

+

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.

+

+

As linhas mais largas são separadas por 32 pixels, tanto horizontal quanto verticalmente.

+

Show frames per second

+

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

+

Show time to load

+

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

+

Rocketbar enabled

+

Nas versões anteriores à 1.4, essa opção habilita o novo Firefox Rocketbar 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.

+
+

Nota: Nas novas versões do Firefox OS, Rocketbar é habilitado automaticamente e não pode ser desabilitado.

+
+

Contacts debugging output in adb

+

Ao habilitar essa opção informações sobre contatos são adicionadas ao log do adb (logs de erro podem ser acessados digitando adb logcat | grep "Error" no terminal.)

+

Progressive paint (era Layers: Progressive paint)

+

Essa opção foi introduzida para ajudar a depuração do módulo Async Panning/Zoom module (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") }}).

+

Displayport Heuristics

+ +

Essas opções foram introduzidas para ajudar a depuração do Async Panning/Zoom module (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") }}).

+

Keyboard layouts

+

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:

+

+

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.

+
+

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

+
+

 

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

S

+
+

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

+
+

Requisitos

+

Antes de executar o Valgrind no Firefox OS, é recomendado que os desenvolvedores familiarizem-se com o artigo Depurando Mozilla com ValgrindDSDDSDDSG. 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.

+

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 Especificações de Telefones para maiores detalhes dos aparelhos disponíveis.

+

Executando Valgrind em telefones com FxOS

+

Compilando

+

Para compilar o Firefox OS com o valgrind habilitado, inclua no arquivo.userconfig.

+
export B2G_VALGRIND=1
+

Compilar com debug (B2G_DEBUG) também é recomendado. Compilação sem otimizações (B2G_NOOPT) 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.

+

Executando

+
+

Nota: 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 adb disponível e executar o script run-valgrind.sh para iniciar o valgrind no telefone.

+
+

Para executar o Firefox OS sob o valgrind, use o script run-valgrind.sh a partir do diretório B2G. Esse script faz o seguinte:

+
    +
  1. Remonta o sistema de arquivos do telefone com r/w.
    2. +
  2. Copia a biblioteca atual libxul.so 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 libxul execute esse comando:
    + 
    run-valgrind.sh nocopy
    +
    3. +
  3. Reinicia o telefone.
    4. +
  4. Encerra os processos b2g que foram iniciados.
    5. +
  5. Executa o seu próprio processo b2g sob o valgrind.
    6. +
+

Toda a saída do valgrind é escrita em stdout do terminal que executou o script run-valgrind.sh. Essa saída pode ser lida no terminal ou direcionada para um arquivo.

+
+

Nota: Uma vez que o script run-valgrind.sh é 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.

+
+

Executando Valgrind no Firefox OS Desktop

+

Executar o valgrind no Firefox OS Desktop funciona da mesma forma que excutar o Firefox (navegador). Consulte o artigo Depurando o  Mozilla com ValgrindDDS para mais informações. Todos os flags de compilação relevantes necessários a ser incluídos no mozconfig, e todos os problemas específicos das plataformas descritos na página devem ser aplicados.

+

Observe que ao executar Valgrind no desktop em modo OOP/process-per-tab requer adicionar as seguintes opções para certificar-se que os processos-filho também estão sendo monitorados:

+
--trace-children=yes
+

Mantendo e atualizando o Firefox OS Valgrind

+

Durante as liberações de correções, Valgrind para Firefox OS é mantido em um repositório forked para mantê-lo o mais atualizado possível enquanto as excentricidades do Firefox OS são adequadas às mais novas versões.

+

Atualizando Repositórios Valgrind

+
+

AVISO: 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 git.mozilla.org, que por sua vez irão para os desenvolvedores que usam o HEAD dos repositórios de manifesto.

+
+

Os repositórios principais do Firefox OS valgrind e VEX são

+ +

O master branch é uma versão antiga do trunk SVN de cada um desses repos, enquanto que o branch Firefox OS contém correções específicas do Firefox OS baseadas no topo do trunk.

+
+

Nota: SEMPRE ATUALIZE AMBOS OS REPOS NO MESMO MOMENTO. 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.

+
+

Esses estão replicados no domínio git.mozilla.org para se usado nos manifestos  B2G:

+ +
    +
  1. 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: + 
    git svn init -s [subversion repo url]
+
    +
    2. +
  2. 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.
    3. +
  3. Para enviar futuras atualizações, utilize o seguinte grupo de comandos: + 
    git checkout master
+git svn fetch
+git svn rebase
+git push [github-remote-name] master
+git checkout fxos
+git rebase master
+
    +
    4. +
  4. Existe a chance de existir conflitos entre as correções durante o rebase do branch do Firefox OS. Se não conseguir resolver os conflitos, envie um email para o autor para que ele resolva os conflitos encontrados.
    5. +
  5. Depois do rebase, execute uma compilação completa do Firefox OS com a opção B2G_VALGRIND para certificar-se que ainda funciona. Os consertos mais comuns são listados na seção a seguir.
    6. +
  6. Uma vez feito o rebase E TESTADA a compilação contra a árvore Firefox OS, você deve forçar um push para o branch Firefox OS devido à alteração do head. + 
    git push -f [github-remote-name] fxos
    +
    7. +
+

Scripts de compilação, instalação e execução

+

Existem diversos scripts que fazem parte do branch Valgrind Firefox OS ou do repo B2Gque podem necessitar serem alterados após um fetch do repo.

+

external/valgrind/android.mk

+

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 -j1 para verificar quais os alvos falham na compilação e se foi esquecido algum arquivo ou há alguma referência a um arquivo inexistente.

+

external/valgrind/valgrind.mk

+

Contém uma lista de pacotes que necessitam ser compilados e adicionados à imagem do FxOS, referenciada por gonk-misc/b2g.mk. 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.

+

run-valgrind.sh

+

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.

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

gdb é 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 b2g-ps, 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.

+
+

Começando a depurar no modo single-process

+
+

Nota: Antes de executar o depurador você pode configurar o arquivo .userconfig para customizar algumas coisas. Veja o artigo Customização com o arquivo .userconfig para maiores detalhes.

+
+

Para reiniciar Firefox OS e executá-lo sob o controle do gdb, simplesmente use o scritp run-gdb.sh:

+
./run-gdb.sh
+
+
+

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

+
+

Se o Firefox OS já estiver rodando e você quiser conectar o gdb sem reiniciá-lo, você pode fazer algo como isso:

+
./run-gdb.sh attach
+
+

Depurando tarefas fora do processo

+

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 b2g-ps para descobrir o PID do processo que você precisa depurar:

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

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:

+
$ ./run-gdb.sh attach 4308
+

Algumas vezes, é útil ser notificado imediatamente de qualquer criação de processos filhos.

+

Isso pode ser ativado iniciando run-gdb.sh com a variável de ambiente MOZ_DEBUG_CHILD_PROCESS:

+
MOZ_DEBUG_CHILD_PROCESS=1 ./run-gdb.sh
+

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:

+
$ ./run-gdb.sh attach 4308
+

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.

+

Suporte

+

Qual o nível de funcionalidade esperado

+

Os recursos de depuração a seguir ao menos devem funcionar, caso contrário, provavelmente um pequeno ajuste na configuração o fará funcionar:

+ +

Os serguintes recursos de depuração não são suportados. Não tente usá-los:

+ +

Resolução de problemas

+

Existem algumas coisas para tentar resolver caso o gdb não funcione como descrito acima.

+

Certifique-se que seu clone B2G está atualizado

+

Tenha sempre em mente que para atualizar seu clone B2G você deve executar esses dois comandos:

+
git pull
+./repo sync
+

Ao esquecer do git pull poderá acontecer de você executar um antigo run-gdb.sh e não se beneficiar das últimas melhorias.

+

Certifique-se de que você anexou o gdb ao processo correto

+

Anexando-se a um processo errado (por exemplo, processo B2G principal versus processo Browser) pode explicar porque o depurador não para nos breakpoints.

+

Certifique-se de que os símbolos foram corretamente lidos

+
    +
  1. No gdb, use info shared para checar se os símbolos foram corretamente lidos: + 
    (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
+...
    +
    2. +
  2. A coluna Syms Read deve estar com Yes sempre. Talvez em alguns telefones Android você pode ver Yes (*) para algumas bibliotecas de sistema ou drivers, isso estará OK. Você somente não poderá ver um No.
    3. +
  3. Se você vir um No, será seu primeiro problema e você deve resolvê-lo antes de procurar qualquer outra coisa.
    4. +
  4. Procure por alguma outra mensagem de erro na saída do terminal logo após executar o comando run-gdb.sh.
    5. +
  5. 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 b2g. A seguir um exemplo: + 
    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
    +
    6. +
  6. Verifique o valor dessas variáveis GDB: solib-search-path e solib-absolute-prefix: + 
    (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".
    +
    7. +
+
+

Nota: Se você precisar de mais ajuda, tente o canal #b2g no IRC. Se você acredita ter encontrado um bug, reporte-o aqui.

+
+

 

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

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.

+
+
+

Nota: Se você não sabe ainda como situações com baixa memória são gerenciadas no Firefox OS, sugerimos você ler o artigo Gerenciamento de falha de memória no Firefox OS antes de continuar a ler esse documento.

+
+

Depurando uma falha decorrente de Falta de Memória (OOM - Out Of Memory crash)

+

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.

+

Passo 1: Confirme se realmente a falha é devido à falta de memória

+

Primeiro, devemos garantir que a falha é devido ao fato do telefone estar sem memória disponível. Para fazer isso execute adb shell dmesg.  Se o aplicativo for enecerrado devido a falta de memória, você verá a seguinte resposta:

+
<4>[06-18 07:40:25.291] [2897: Notes+]send sigkill to 2897 (Notes+), adj 2, size 30625
+

Essa linha indica que o aplicativo Notes+ (ID do processo 2897) foi encerrado e possuia oom_adj 2. 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.

+

Digressão: se não for falta de memória (OOM)

+

Se a saída do comando dmesg 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 gdb ao processo de falha e conseguir um rastreamento, que pode ser feito dessa forma:

+
$ cd path/to/B2G/checkout
+$ adb shell b2g-ps
+# Note pid of the app that you're going to crash
+$ ./run-gdb.sh attach <pid>
+(gdb) continue
+# crash the app
+(gdb) bt
+

Quando for reportar o bug, anexe o resultado obtido, bem como o resultado do comando adb logcat. 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.

+

Passo 2: Coletar relatórios de memória

+

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.

+

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  repo sync não será suficiente; você deve executar git fetch && git merge ou git pull:

+
$ cd path/to/B2G/checkout
+$ git fetch origin
+$ git merge --ff-only origin
+

Agora execute a ferramenta para extrair o relatório:

+
$ tools/get_about_memory.py
+

Uma vez que você conseguiu o relatório, você pode compactar o diretório (chamado about-memory-N) 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:

+

Passo 2, opção 1: Consiga um dispositivo diferente

+

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 b2g-info mostrará quanta memória cada um dos diferentes processos B2G estavam usando. Você pode executar esse processo em um loop fazendo o seguinte:

+
$ adb shell 'while true; do b2g-info; sleep 1; done'
+

Se b2g-info não está disponível no seu dispositivo, você pode usar b2g-procrank.

+

Passo 2, opção 2: Dedo mais rápido

+

Se você não possui um dispositivo com mais memória RAM, você pode tentar executar get_about_memory.py no momento exatamente anterior ao aplicativo falhar. Você pode rodar b2g-info em um loop (como mostrado no item anterior) para descobrir quando executar get_about_memory.py. 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.

+

Passo 2, opção 3: Use um pequeno caso de teste

+

Geralmente falhas de falta de memória ocorrem quando é feito algo como "carregar um arquivo de no mínimo X bytes no aplicativo".

+

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.

+

Passo 2, opção 4: Execute B2G no seu desktop

+

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.

+

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 Bug 923961, Bug 914584, Bug 891882). 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.

+

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 /tmp com o seguinte nome: memory-report-*.gz.

+

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 -> Mac OS X -> 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.

+

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:

+

 

+

Screen shot of instruments.
+ Para mais informações de como configurar uma compilação do B2G desktop, leia nossa página Modificando o Gaia.

+

Passo 3: Analise o relatório de memória

+

Quando você executa get_about_memory.py, 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.

+

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.

+

Passo 4: Recompile com DMD, se necessário

+

Um item comum presente nos relatórios de memória extraídos antes de uma falha é heap-unclassified.  heap-unclassified 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 heap-unclassified, o relatório não pode dizer dizer mais nada sobre a quem a memória pertence. Nossa ferramenta para ir mais fundo no heap-unclassified é chamada DMD. Ela funciona no B2G, mas você deve compilar seu próprio B2G para que funcione pois DMD exige símbolos locais que são mantidos na máquina que roda a compilacão.

+

Para saber mais informações sobre o DMD e como interpretar sua saída, leia a página do DMD na Wiki Mozilla.
+  

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

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.

+
+ +
+

Nota: A maioria dos contribuintes Firefox desktop estão acostumados a usar about: crashes para recuperar relatórios de travamento (leia Relatórios de Travamento para mais detalhes), mas isso não é suportado no Firefox OS.

+
+ +

Antes de tentar qualquer outra coisa

+ +

As instruções a seguir pressupõem que você já tenha seguido estas três etapas:

+ +
    +
  1. Tenha certeza de que o depurador remoto esteja habilitado em seu dispositivo, e o ADB esteja instalado. Isso permitirá que o seu computador comunique com seu dispositivo.  
    2. +
  2. Conecte seu dispositivo ao seu computador via USB. 
    3. +
  3. Instale o ADB Helper Add-on no desktop Firefox para lidar com qualquer encaminhamento de porta necessário.  
    4. +
+ +

Instalando BusyBox

+ +

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.

+ +

Para instalá-lo, certifique-se que o seu dispositivo esteja ligado e, em seguida:

+ +
    +
  1. Faça download do BusyBox.
    2. +
  2. Descompacte o tarball em um local seguro.
    3. +
  3. cd no diretório restante busybox-b2g.
    4. +
  4. Execute ./install.sh para instalar.
    5. +
+ +

Todas as funcionalidades do busybox pegam symlinks em /system/bin, de forma que você possa rodar comandos como ping diretamente. Aqui estão alguns exemplos de comandos:

+ +
adb shell ping 8.8.8.8   => ping command
+
+adb shell ifconfig wlan0 => check tx/rx bytes
+
+adb shell cat /proc/net/route    => check the default route
+
+adb shell iptables -t nat -nvL   => check if the packets are sent from application to IP layer, check Chain OUTPUT (policy ACCEPT 2 packets, 168 bytes)
+ +

Obtendo relatórios de travamento de um dispositivo Firefox OS

+ +

Nós criamos o Firefox OS app para que seja possível recuperar relatórios de travamento — About Crashes — que funcionam na versão 1.2+.
+
+ Para instalar em seu dispositivo, siga os seguintes passos:

+ +
    +
  1. About Crashes é um app certificado, então você precisa habilitar o depurador de aplicativos certificados (veja instruções para App Manager e WebIDE).
    2. +
  2. Faça download do arquivo zip About Crashes app do link acima e extraia localmente.
    3. +
  3. No Firefox desktop, abra o  App Manager e o WebIDE (dependendo da versão do Firefox que você esteja usando) em Ferramentas > Web Developer.
    4. +
  4. Em cada ferramenta, adicione o About Crashes app como um app compactado (App Manager: clique no sinal de mais ao lado da opção Adicionar App Compactado, WebIDE Compactado: Abra o menu dropdown do lado esquerdo e selecione Adicionar App Compactado ...).
    5. +
  5. Conecte o seu dispositivo ao App Manager/WebIDE (App Manager: encontre listado na parte inferior da interface do usuário, WebIDE: Procure por Select Runtime).
    6. +
  6. Instale e abra o aplicativo em seu dispositivo (App Manager: Pressione o botão Update, WebIDE: pressione o botão "Play" (Instale and execute).
    7. +
  7. No dispositivo, pressione o botão Update dentro de About Crashes para visualisar as falhas mais recentes.
    8. +
+ +

Obtendo crash IDs a partir de uma linha de comando 

+ +

Você pode obter uma lista de IDs de falhas através de uma linha de comando, digitando o seguinte comando em seu terminal:

+ +
adb shell ls -l /data/b2g/mozilla/Crash\ Reports/submitted/
+ +

Caso você possua uma longa lista de crashes e deseja que elas sejam ordenadas por data, use o seguinte comando:

+ +
adb shell busybox ls -ltr /data/b2g/mozilla/Crash\ Reports/submitted/
+ +

Obtendo/verificando o relatório de travamento

+ +

Para verificar o relatório de travamento:

+ +
    +
  1. Copie o nome do arquivo sem a extensão.
    2. +
  2. Acesse Mozilla Crash Reports.
    3. +
  3. Cole o nome do arquivo sem a extensão na parte superior do  campo de busca.  
    4. +
+ +

Isso deverá exibir o crash report que você enviou.

+ +

Como forçar uma falha

+ +

Para acionar uma falha no sistema Firefox OS, digite o seguinte comando em seu terminal para encontrar a ID do processo root:

+ +
adb shell ps | grep b2g
+ +

Você terá que encontrar a linha que tem raiz no início, e / system / B2G / B2G no final. O resultado deve parecer com isto:

+ +
root 109 1 191120 66024 ffffffff 400fa330 S /system/b2g/b2g
+ +

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 [ ]:

+ +
adb shell kill -11 [ENTER ID HERE]
+ +

Ao matar o processo pela, uma falha aparecerá em seu dispositivo. 

+ +

Como executar o script GDB para b2g

+ +
    +
  1. Inicie a galeria app no telefone, e em seguida execute o seguinte comando em seu terminal: 
    2. +
  2. + 
    adb shell b2g-ps
    +
    3. +
  3. Anote o pid do app galeria, e em seguida, execute o seguinte comando:
    4. +
  4. + 
    ./run-gdb.sh attach <pid>
    +
    5. +
  5. Provoque o crash.
    6. +
  6. Execute o comando abaixo: + 
    (gdb) bt
    +
    7. +
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 +--- +
+

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.

+
+

Depurando aplicativos

+

Quando depurar aplicativos web, a melhor ferramenta a sua disposição é o App Manager, 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 ferramentas de desenvolvimento da Mozilla. Essa pode ser a sua primeira escolha especiamente para depurações de aplicativos e do Gaia.

+
+
+ Usando o App Manager
+
+ 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
+
+ Depurando erros de falta de memória no Firefox OS
+
+ 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.
+
+

Depurando o Gaia/B2G

+

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

+
+
+ Depurando usando o cliente B2G Desktop
+
+ Você pode usar a aplicação B2G Desktop (e suas ferramentas associadas) para depurar diversos aspectos do B2G e do Gaia.
+
+ Guia rápido para desenvolvimento Gaia
+
+ 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.
+
+ Depurando o B2G usando gdb
+
+ 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.
+
+ Depurando o B2G usando Valgrind
+
+ 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.
+
+ Conseguindo logs do NSPR no B2G
+
+ Você pode usar os logs do NSPR logs para registrar o HTTP e outras operações da rede.
+
+ Depurando OpenGL
+
+ Como depurar código OpenGL no Firefox OS.
+
+

Configuração geral e informações

+

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.

+
+
+ Configurações do desenvolvedor do Firefox OS
+
+ 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.
+
+ Instalando e usando o ADB
+
+ Em muitos aspectos do desenvolvimento do Firefox OS você vai precisar instalar o adb (Android Debug Bridge). Esse artigo explica como fazer isso e apresenta os comandos mais comuns.
+
+ Log no console do dispositivo
+
+ Como fazer um log no console de um dispositivo Firefox OS e como acessar esse registro para examiná-lo no seu computador.
+
+ Conectando um dispositivo Firefox OS no seu computador
+
+ Esse pequeno guia explica como configurar seu dispositivo Firefox OS e seu computador para conetctá-los através da porta USB.
+
+ Configurando para depurar o código do Firefox OS
+
+ 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.
+
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 +--- +
+

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.

+
+ +

Instalando o ADB

+ +

Você pode baixar e instalar o adb como parte do pacote do Android SDK package, para Mac, Linux ou Windows - visite a página Get the Android SDK.

+ +

Distribuições mais recentes do Linux já possuem o adb em seus repositórios. Para Ubuntu 12.10 e posteriores execute o seguinte comando:

+ +
sudo apt-get install android-tools-adb
+ +

Ou para Fedora 18/19:

+ +
sudo yum install android-tools
+ +

Ou no OSX usando Homebrew:

+ +
brew install android-platform-tools
+ +

Se sua distribuição não possui pacotes disponíveis para adb (por exemplo, Ubuntu 12.04 ou Fedora 17), você precisará instalar o Android SDK starter package para sua plataforma (Selecione a opção ADT Bundle, e não SDK Tools Only). Então execute o gerenciador de pacote $SDK_HOME/tools/android, e use o GUI para instalar "Android SDK Platform-tools".

+ +

Verifique onde o adb foi instalado (normalmente em usr/bin, possivelmente dentro de adt/platform-tools, depdendo de como você o instalou). Certifique-se de adicionar esse diretório em seu PATH. Isso pode ser feito adicionando a linha

+ +
PATH=$SDK_HOME:$PATH
+ +

ao seu ~/.bashrc ou equivalente, onde $SDK_HOME é o caminho de onde foi instalado o Android SDK.

+ +

Resolvendo problemas

+ +

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:

+ +
sudo apt-get install ia32-libs
+ +

Para novas versões do ubuntu:

+ +
sudo apt-get install lib32z1 lib32ncurses5 gcc-multilib
+ +

Comandos comuns do ADB

+ +

As próximas seções explicam alguns dos mais comuns e úteis comandos do adb.

+ +

Reiniciando o processo b2g

+ +

b2g é equivalente à aplicação XULRunner 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):

+ +
adb shell killall b2g
+ +

Habilitando o encaminhamento de porta para depuração

+ +

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:

+ +
adb forward tcp:6000 localfilesystem:/data/local/debugger-socket
+ +

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.

+ +

Encaminhando portas para uma máquina local

+ +

Para isso, você precisará baixar os binários netcat and ssh, e executar os seguintes comandos:

+ +
# 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 < readback | ./netcat -l -p 5959 > 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 < readback | ./netcat localhost 22 > 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
+ +

No exemplo acima é direcionada a porta 9999 do dispositivo para a porta 8000 do hospedeiro.

+ +

Alternativamente você pode usar um servidor ssh (dropbear e host_key) diretamente no dispositivo, usando os seguintes comandos:

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

Outros recursos:

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

{{PreviousNext("Mozilla/Firefox_OS/Debugging/Debugging_and_security_testing", "Mozilla/Firefox_OS/Apps/Testing_in_a_privileged_context")}}

+ +
+

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 Debugging e segurança de testes com o Firefox OS.

+
+ +

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 Burp e ZAP 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.

+ +

Combinado com o recurso do 'processo principal de debug Firefox OS' do app manager, eles permitem que você instale a cert raiz do seu proxy para o seu dispositivo executando algum código a partir de um rascunho.

+ +

Depurando o processo principal do Firefox OS

+ +

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, definindo algumas prefs em seu perfil. Siga estes passos em primeiro lugar, em seguida, defina o devtools.chrome.enabled pref para true no about:config, antes de reiniciar o browser.

+ +

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.

+ +
+

Nota: Cuidado com o que você executa contra o processo principal: você pode acidentalmente destruir o seu dispositivo!

+
+ +

Introduzindo ZAP

+ +

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 ZAP homepage para baixá-lo. Se você optar por usar outro proxy sinta-se a vontade para fazê-lo, nossa abordagem deve funcionar com ambos.

+ +

Certificado ZAP

+ +

Agora, em qualquer proxy que você usar, deixe-o exportar seu certificado para um arquivo, como owasp_zap_root_ca.cer (vá em Ferramentas > Opções > Certificados SSL dinâmicos > Salvar). 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.

+ +

Proxy local

+ +

If you're using B2G desktop, you have to make sure that ZAP does not listen on localhost, but instead on your attributed IP address (ethernet or Wi-Fi). This is because B2G Desktop's localhost does not point to your desktop computer, but something within the b2g binary itself. For our example, we will use my IP address: 10.264.1.5.

+ +

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

+ +

Conectando seu dispositivo ao proxy

+ +

Você pode extrair as prefs do seu dispositivo, mudá-los para adicionar as preferências de proxy relevantes, colocá-los de volta.

+ +

You can pull the default prefs from your device, change them to add the relevant proxy prefs, put them back.

+ +

Ou, você pode configurar a sua ferramenta para proxy HTTP and HTTPS transparente 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:

+ +
+
adb shell iptables -t nat -A OUTPUT -p tcp --dport 443 -j DNAT --to-destination 192.168.0.14:8443
+
+
+ +

E, para redefini-la quando estiver pronto:

+ +
+
adb shell iptables -t nat -F
+
+
+ +

Configurando um proxy LAN

+ +

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.

+ +

Nós construímos um usando um raspberry pi e passos semelhantes a estes. Mudamos as regras do iptables para ficar assim:

+ +
+
*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 <proxy_host>:<http_port>
+-A PREROUTING -i wlan0 -p tcp -m tcp --dport 443 -j DNAT --to-destination <proxy_host>:<https_port>
+:POSTROUTING ACCEPT [0:0]
+-A POSTROUTING -o eth0 -j MASQUERADE
+COMMIT
+
+
+ +

Criando um banco de dados certificado

+ +

O ato de aceitar certificados acontece em configurações, que são armazenadas nos perfis. Aqui está uma pequena cartilha sobre perfis do Firefox:

+ +
    +
  1. 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): +
      +
    • No Linux, você precisa dar o seguinte comando: + 
      firefox -P -no-remote
      +
      • +
    • No Mac OS X: + 
      /Applications/Firefox.app/Contents/MacOS/firefox -P -no-remote
      +
      • +
    +
    2. +
  2. Agora crie um novo perfil chamado "zapped". Vá para as configurações de certificado - Editar > Preferências > Avançado > Criptografia > Exibir Certificados > Importar. Agora selecione o arquivo owasp_zap_root_ca.cer 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).
    3. +
  3. 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  Diretórios Runtime para obter detalhes sobre onde ele pode ser encontrado.
    4. +
  4. Para B2G desktop, precisamos apenas do arquivo cert8.db, que é a base de dados certificados do perfil. Copie-o para o seu perfil B2G diretório b2g/gaia/profile/.
    5. +
  5. Em um dispositivo, copie o cert9.db em seu diretório de perfil do dispositivo: + 
    $ adb shell stop b2g
+$ adb push cert9.db /data/b2g/mozilla/*.default
    +
    6. +
+ +
+

Nota: Isto irá substituir o arquivo existente.

+
+ +

Configurando B2G

+ +

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.

+ +

Em B2G desktop

+ +

Você precisa anexar essas configurações personalizadas para o arquivo de preferências, b2g/gaia/profile/prefs.js:

+ +
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);
+
+ +
+

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.

+
+ +

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.

+ +

Em um dispositivo

+ +

Para habilitar essa funcionalidade em um dispositivo, você precisará modificar o arquivo  prefs.js file localizado no seu perfil do seu dispositivo. Conecte o dispositivo ao computador que tenha sido previamente configurado com as ferramentas EDA.

+ +

Primeiro, você precisa saber qual é o nome do seu diretório de perfil. Você pode encontrá-lo assim:

+ +
adb shell ls /data/b2g/mozilla
+ +

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.

+ +

Em seguida, pegue o arquivo prefs.js para que você possa editá-lo:

+ +
adb pull /data/b2g/mozilla/xxxxxxx.default/prefs.js
+ +

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

+ +
adb push pref.js /data/b2g/mozilla/xxxxxxxx.default
+adb shell start b2g
+ +

{{PreviousNext("Mozilla/Firefox_OS/Debugging/Debugging_and_security_testing", "Mozilla/Firefox_OS/Apps/Testing_in_a_privileged_context")}}

+ +

Charles Proxy

+ +

Usuários que desejam usar Charles Proxy deverão ver este post: https://muffinresearch.co.uk/proxying-connections-from-ffos/

+ +

 

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

Para que você possa fazer o log do console e vê-lo usando remote web console, 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 logcat através de uma conexão USB. Esse artigo mostra como habilitar esse recurso, executar o log e recuperá-lo.

+
+

Habilitando a geração dos logs

+

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 Configurações do desenvolvedor opção Console Ativado.

+

Log

+

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:

+
console.info("Starting up the foobar hardware!");
+var err = foobar.start();
+if (err) {
+  console.error("--Error %d starting up the foobar hardware!", err);
+}
+
+
+

Nota: Veja {{domxref("console")}} para detalhes dos recursos de log disponíveis para vocês.

+
+

Usando logcat

+

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 logcat do adb, que faz parte do pacote Android SDK (veja Instalando o ADB).

+

Felizmente o uso do logcat é muito simples: uma vez o adb instalado e o dispositivo conectado ao seu computador via USB, você pode usá-lo através do terminal:

+
adb logcat
+

Esse comando apresenta o log do dispositivo (armazenado em /dev/log/system/) na saída to terminal. Por exemplo:

+
I/Vold    (  107): Vold 2.1 (the revenge) firing up
+D/Vold    (  107): Volume sdcard state changing -1 (Initializing) -> 0 (No-Media)
+D/Vold    (  107): Volume emmc state changing -1 (Initializing) -> 0 (No-Media)
+D/Vold    (  107): Volume sdcard state changing 0 (No-Media) -> 2 (Pending)
+D/Vold    (  107): Volume sdcard state changing 2 (Pending) -> 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) -> 2 (Pending)
+D/Vold    (  107): Volume emmc state changing 2 (Pending) -> 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) -> 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) -> 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) -> 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) -> 4 (Mounted)
+
+etc.
+
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 +--- +

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.

+

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.

+

Preparando seu telefone

+

No telefone, entre em Configurações (Settings) > Informação do Dispositivo (Device Information) > Mais informações (More Information) > Em Desenvolvedor marque: "Depuração Remota (Remote Debugging)" e "Habilitar console (Console Enabled)"

+

Plug o seu celular ao computador.

+

Agora, você tem três escolhas: usar o Terminal, usar o DDMS no Eclipse ou usar uma combinação de botões no telefone.

+

Tirando um screenshot

+

Terminal

+

Abra a janela do terminal.

+
    +
  1. Para tirar o screenshot, nós iremos chama-lo de "screenshot.png"
    + adb shell screencap -p /sdcard/screenshot.png
    2. +
  2. Pegue a imagem no seu computador
    + adb pull /sdcard/screenshot.png
    3. +
  3. Remova o screenshot do seu telefone
    + adb shell rm /sdcard/screenshot.png
    4. +
+

Alternativamente, você pode usar ffmpeg:

+
    +
  1. Certifique-se de ter instalado o ffmpeg: +
      +
    1. No Mac, se você usa MacPorts, você pode usar: sudo port install ffmpeg. Pelo homebrew: brew install ffmpeg.
      2. +
    2. No Linux (Ubuntu/Debian), use sudo apt-get install ffmpeg.
      3. +
    +
    2. +
  2. cd no diretório B2G/gaia.
    3. +
  3. Use o comando make screenshot.
    4. +
  4. Você terá sua cópia de tela em screenshot.png.
    5. +
+

DDMS

+

Abra o Eclipse.

+
    +
  1. Abra o DDMS
    + Window > Open Perspective > Other > DDMS
    2. +
  2. No painel do lado esquerdo, aba "Dispositivos (Devices)", clique no botão "Capturar tela (Screen capture)"
    3. +
  3. Uma nova janela aparecer com algumas opções, clique no botão "Salvar"
    4. +
+
+

Nota: Quer aprender mais sobre ADB? De uma olhada na documentação.

+
+

Combinação de botões no telefone

+
    +
  1. A partir da versão 2.0 do Firefox OS versions up to 2.0, pressione simultaneamente os botões Home e Power.
    2. +
  2. A partir da versão 2.1 também funcionará pressionando os botões Volume para baixo e Power por alguns segundos.
    3. +
+

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.

+
+

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

+
+

App Manager/Simulador

+
    +
  1. No App Manager, conecte seu telefone e vá para a tab Device, na esquerda.
    2. +
  2. Clique no botão Screenshot na parte inferior da página (no mesmo local que você inicia o simulador).
    3. +
-- cgit v1.2.3-54-g00ecf