O que é logcat e como visualizar logs no Android

Resumindo

Nesse artigo, vamos conhecer mais sobre uma ferramenta super bacana do Android, o Log, além de aprender como utilizá-la para facilitar o desenvolvimento dos seus aplicativos. Vamos ver:

• O que são logs;
• Porque utilizá-los;
• Visualizando os Logs com o LogCat;
• Tipos de Log no Android;
• Quando utilizar cada tipo de Log;
• Dicas e boas práticas;
• Melhorando a visualização de Logs.

Depois de ler esse artigo, você vai entender melhor como funcionam os Logs no Android, quando e como utilizar cada um dos tipos, entender as boas práticas relacionadas e ainda melhorar a visualização de Logs para otimizar o desenvolvimento dos seus aplicativos. Bora lá?

O que são logs?

Certamente, em algum momento dos seus estudos de programação, você já se deparou com o termo log, mas o que ele significa?

Em termos gerais, são chamados de logs, os registros de eventos importantes que acontecem em um sistema ou aplicativo, e eles podem ser utilizados, entre outras coisas, para identificar problemas antecipadamente.

Por que utilizar Logs?

Já vimos o que são logs e para que eles servem, mas, quais são as vantagens de utilizar logs no projeto?

Bom, os logs nos permitem visualizar informações sobre nosso aplicativo que não vemos pelo emulador. Como exemplos de utilização dos logs, podemos citar:

• Coletar dados específicos do funcionamento do aplicativo;
• Verificar em qual etapa do ciclo de vida a Activity está, para incluir mais corretamente funcionalidades;
• Registrar erros ou exceções que podem ser corrigidos antes de chegar à pessoa usuária;
• Auxiliar no processo de depuração do código.

Com isso, podemos corrigir possíveis falhas do aplicativo antes de chegar à pessoa usuária. Já deu para notar que os Logs são importantes para as pessoas que estão desenvolvendo um projeto, certo?

E como podemos utilizar essa ferramenta tão poderosa? É o que veremos a seguir com o Logcat!

Visualizando Logs com o Logcat

Para visualizar os logs que criamos, utilizamos uma janela do Android Studio chamada Logcat, que exibe, em tempo real, mensagens do sistema e as mensagens que adicionamos ao aplicativo por meio da classe Log, além de guardar um histórico das mensagens mais antigas para consulta.

Geralmente, a janela Logcat aparecerá na barra de janelas inferior do Android Studio, mas caso não apareça para você, é possível acessá-la através do menu principal em View > Tool Windows > Logcat.

Na imagem acima, temos um print da janela Logcat do Android, que apresenta algumas mensagens de logs emitidas pelo sistema. As saídas de mensagens de log na janela Logcat seguem sempre o mesmo padrão de escrita:

data hora pacote prioridade/tag: mensagem

Apesar de seguir o padrão acima, você pode alterá-lo, clicando no botão Logcat Header no menu lateral da janela.

Vamos ver um exemplo na prática? Abaixo temos uma mensagem de log que informa o nome de uma lista de alunos que foi clicado pela pessoa usuária naquele momento:

2022-02-17 15:13:58.289 11384-11384/br.com.alura.agenda I/aluno: O aluno da lista clicado foi Fran

Criando e visualizando logs no Android | #AluraMais

https://www.youtube.com/watch?v=412nsNqL8YE&t=0s

Até aqui tudo bem, certo? E vamos mergulhar um pouco mais: você sabia que existem tipos de Log no Android?

Tipos de Log no Android

No Android, há a classe Log, que nos permite gravar os registros de eventos através de métodos. Esses métodos permitem que façamos a criação das mensagens de registro que são geradas e exibidas posteriormente.

Os métodos de registro mais utilizados geralmente são listados em ordem de prioridade decrescente, ou seja, do mais para o menos detalhado:

• Log.e(String, String)
• Log.w(String, String)
• Log.i(String, String)
• Log.d(String, String)
• Log.v(String, String)

Em cada um desses métodos, é preciso passar dois parâmetros: uma tag exclusiva e uma mensagem. A tag é uma String curta que indica o componente do sistema que origina a mensagem e a mensagem é o que você deseja mostrar quando o evento acontecer.

Para definir a mensagem de log que você quer verificar, é preciso chamar a classe Log seguindo o padrão do exemplo abaixo, no qual passamos a prioridade do log, a tag e a mensagem a ser exibida:

Log.i(“teste”, “mensagem de teste”)

Assim, o resultado no Logcat seria esse:

Nesse exemplo, fizemos um Log de informação com a tag teste e a mensagem como mensagem de teste. Como resultado, podemos ver esses dados exibidos no Logcat, conforme o padrão de mensagem que vimos anteriormente.

Prioridades do Log

Quando falamos de prioridades, significa os valores associados à classe Logque utilizamos para criar os logs. As prioridades podem ser:

• E - Error (erro): identifica e exibe problemas que provocaram erros no aplicativo;

• W - Warning (alerta): exibe alertas para problemas que ainda não são erros, mas que podem precisar de atenção;

• I - Info (informação): essa prioridade exibe mensagens de informação, são mensagens esperadas quando está acontecendo um funcionamento regular do aplicativo. Geralmente, esse é o log que mais utilizamos, para verificar se algo está funcionando corretamente;

• D - Debug: aqui conseguimos ver as mensagens de depuração, que são utilizadas durante o desenvolvimento do aplicativo para verificar o fluxo exato que está acontecendo durante o funcionamento do aplicativo;

• V - Verbose: utilizado para conferir mais detalhes sobre o funcionamento de uma parte específica ou detalhar mais alguma informação coletada, por exemplo.

Podemos, ainda, utilizar o método Log.wtf() para registrar um problema que não deveria estar acontecendo no app. O WTF vem de What a Terrible Failure (Que falha terrível, em uma tradução rápida) e geralmente é utilizado quando precisamos ver os registros de algo que teve um resultado muito errado, não esperado e que não deveria estar acontecendo de jeito nenhum.

Esses métodos possuem também a possibilidade de passar um terceiro parâmetro, além da tag e da mensagem, o parâmetro tr do tipo Throwable.

O Throwable é a superclasse de todos os erros e exceções. Utilizando o parâmetro tr nos logs, conseguimos ver, de maneira detalhada, tudo que está acontecendo quando ocorre um Error ou uma Exception e, portanto, podemos saber exatamente o problema que aconteceu e o que pode ser feito para corrigi-lo.

No exemplo abaixo, vamos criar uma Exception e ver o que acontece quando utilizamos o parâmetro tr no log:

try {
       throw Throwable("teste")
} catch (tr: Throwable) {
       Log.e("Listaprodutos", "onCreate: erro", tr)
}

No Logcat, temos a seguinte saída:

Nesse caso, a grande diferença é que se não passássemos o parâmetro tr, teríamos a saída somente com a mensagem da primeira linha, que apenas informa ter ocorrido um erro. Já utilizando o parâmetro tr, recebemos mensagens mais específicas sobre qual erro ou exceção ocorreu, onde e mais informações que vão nos ajudar no tratamento.

Agora que entendemos sobre os tipos e prioridades de logs, incluindo o parâmetro tr, você também precisa conhecer algumas boas práticas do Logcat.

6 dicas e boas práticas no uso de Logs

Existem algumas dicas e boas práticas, ao utilizar logs no Android, que facilitam nosso trabalho e mantêm uma uniformidade no processo de escrita do código. Vamos ver seis delas por aqui:

1. Utilizar filtros e pesquisas no Logcat;
2. Usar a prioridade certa para o que precisamos verificar;
3. Utilizar Log.v() e Log.d() somente em desenvolvimento;
4. Declarar uma constante TAG ;
5. Utilizar tags mais específicas;
6. Identificar onde o log foi gerado.

Vamos lá?

1) Utilizar filtros e pesquisas no Logcat

Quando executamos o aplicativo, são geradas várias mensagens de log do sistema que muitas vezes não nos interessam naquele momento e podem dificultar a localização dos logs que realmente precisamos ver.

Para melhorar essa visualização, podemos utilizar os recursos de filtros e pesquisa do Logcat, e assim, visualizar somente o que é de nosso interesse, facilitando o fluxo de trabalho.

Você pode filtrar a prioridade, buscar algum termo na barra de buscas e criar ou selecionar um filtro personalizado.

2) Usar a prioridade certa para o que precisamos verificar

Uma boa prática muito importante é utilizar o nível de prioridade correto para o que queremos verificar.

Por exemplo, se queremos verificar alguma informação referente a certa parte do código, vamos utilizar o Log.i(). Já se quisermos verificar algum erro no nosso aplicativo, devemos utilizar o Log.e().

Utilizar esse padrão vai ajudar a manter o código organizado e a visualizar as mensagens de registro de maneira correta.

3) Utilizar Log.v() e Log.d() somente em desenvolvimento

Os métodos de log detalhado (Log.v()) e de log de depuração (Log.d()) devem ser utilizados para verificações de funcionamento somente durante a etapa de desenvolvimento do aplicativo.

Por serem logs que exibem mensagens mais complexas e que só são úteis durante a etapa de desenvolvimento, o ideal é desativá-los quando o aplicativo for para a fase de publicação, para reduzir a quantidade de informações enviadas.

4) Declarar uma constante TAG

Uma boa prática muito utilizada é declarar uma constante TAG para utilizar no primeiro parâmetro dos métodos Log. Isso, além de facilitar a utilização de mais de um log, ainda deixa especificado e padronizado o valor do parâmetro.

No exemplo abaixo, podemos ver um log de informação em uma Activity utilizando a tag como constante:

private const val TAG = "ListaProdutosActivity"
...
Log.i(TAG, "onCreate: ")

5) Utilizar tags mais específicas

Utilizar uma tag mais específica vai ajudar a filtrar melhor as informações no Logcat e a saber mais rapidamente onde aquele log foi gerado.

Uma boa prática é identificar a classe atual na TAG. Podemos verificar isso no exemplo anterior, em que declaramos uma constante referenciando a Activity atual.

Utilizando esse padrão, podemos filtrar os logs relacionados a essa Activity com o valor que foi declarado na constante através da caixa de pesquisa no menu superior do Logcat e temos como resultado somente as mensagens que possuem aquela tag exibidas:

6) Identificar onde o log foi gerado

Quando pensamos em um código grande, receber uma mensagem de log pouco específica pode dificultar bastante a localização de onde está aquela ocorrência. Por isso, podemos especificar, na mensagem, por qual método o log foi chamado:

private const val TAG = "ListaProdutosActivity"
...
Log.i(TAG, "onCreate: ")

Essas informações vão gerar a seguinte saída no Logcat:

2022-02-18 12:28:12.745 12154-12154/br.com.alura.orgs I/ListaProdutosActivity: onCreate:

Nessa mensagem exibida, conseguimos saber que foi gerado um log de informação na classe ListaProdutosActivity no método onCreate(), assim, fica bem mais fácil de localizar e fazer correções caso necessárias.

Uma boa dica para facilitar a utilização dos logs é usar os templates de log que o Android Studio fornece, pois eles geram a mensagem automaticamente com o local onde o log está inserido. Basta escrever no Android Studio logi e apertar a tecla Enter para usar o template e gerar um log de informação. Se quiser outro tipo de log, é só mudar a letra da prioridade, como por exemplo, logw para warning.

Melhorando a visualização de Logs

Filtrando por nível de prioridade

No Logcat, podemos filtrar as mensagens por nível de prioridade e, assim, exibir somente as mensagens que nos interessam. O filtro é feito através da terceira lista suspensa no menu superior do Logcat, conforme identificado na janela abaixo:

Como opções de filtros, temos:

• Verbose: exibe todas as mensagens;
• Debug: exibe as mensagens de depuração e todas as mensagens dos níveis inferiores;
• Info: exibe as mensagens de informação e todas as mensagens dos níveis inferiores;
• Warn: exibe as mensagens de alerta de problemas que ainda não são erros e todas as mensagens dos níveis inferiores;
• Error: exibe as mensagens de problemas que causaram erros e todas as mensagens dos níveis inferiores;
• Assert: exibe as mensagens de problemas que não eram esperados de acontecer.

Filtrando por informações personalizadas

Podemos, também, utilizar um filtro personalizado para selecionar algumas mensagens de registro específicas, utilizando a última lista suspensa do menu superior do Logcat, conforme imagem abaixo:

Abrindo a lista suspensa, veremos as seguintes opções:

• Show only selected application: exibe somente as mensagens geradas pelo código do aplicativo;
• Firebase: exibe somente as mensagens geradas pelo Firebase;
• No Filters: exibe todas as mensagens do aplicativo sem aplicar filtros;
• Edit Filter Configuration: permite criar ou editar um filtro personalizado.

Se você optar por criar um filtro personalizado, pode utilizar os seguintes parâmetros para configurar esse filtro:

• Filter Name: nome do filtro que você quer configurar;
• Log Tag: permite filtrar por uma tag criada;
• Log Message: permite filtrar por uma mensagem criada;
• Package Name: permite filtrar pelo nome do pacote;
• PID: permite filtrar pelo ID de processo;
• Log Level: permite adicionar um nível de registro para especificar mais o filtro;
• Regex: habilita o filtro por uma expressão regular quando marcado.

Agora que você já sabe como filtrar essas mensagens para deixar tudo do jeitinho que você quer visualizar, vou mostrar mais uma maneira de facilitar a identificação dessas mensagens: alterar o esquema de cores do Logcat.

Alterando o esquema de cores das mensagens por prioridade

Quem nunca se confundiu ao ver o tanto de mensagem que aparece no Logcat e se perdeu ao procurar algo ali no meio?

Ao ver uma lista gigante de logs, a gente sente confusão, como a personagem Nazaré, não é mesmo?

Por padrão, o Logcat vem com uma cor única para todas as mensagens e somente as mensagens de erro destacadas, mas podemos alterar o esquema de cores. Como fazer isso?

No menu superior do Android Studio, clique em File > Settings > Editor > Color Scheme > Android Logcat.

Na tela Android Logcat, você pode alterar as cores de cada um dos níveis de registro, clicando sobre eles e alterando, na área à direita, as configurações que você preferir.

Color Scheme > Android Logcat e, logo abaixo, há a palavra “Scheme” (“Esquema”, em português) e uma caixa de seleção em que se lê “Darcula”. Abaixo da caixa “Scheme”, ainda no centro da tela, há uma lista com seis opções: um, Assert; dois, Debug; três, Error; quatro, Info; cinco, Verbose; seis, Warning. Na parte direita da tela, há opções para alterar a cor da fonte e inserir outros efeitos. Na parte central e direita inferior do Android Studio, há uma caixa com uma prévia das configurações de cor aplicadas, mostrando logs de erro na cor vermelha. Na parte superior esquerda, há um campo de buscas. À esquerda central e inferior, há uma lista de opções para selecionar.">

Olha só como ficou o meu Logcat:

Bacana demais né? Se gostou desse esquema de cores que usei e quiser utilizar o mesmo, pode fazer o download aqui.

Para adicionar esse arquivo ao seu Logcat, acesse a tela de configurações que fomos anteriormente, na engrenagem ao lado do nome do esquema de cores (Show Scheme Actions), escolha a opção Import Scheme, e selecione o arquivo que você baixou. Pronto! Só aplicar e aproveitar essa nova visualização.

Conclusão

Nesse artigo, conhecemos o que são logs e o Logcat, por que utilizá-los nos nossos aplicativos, quais os tipos de logs e quando utilizar cada um deles.

Vimos também como visualizá-los através da janela Logcat e conhecemos algumas boas práticas na utilização dessa ferramenta incrível.

E por fim, ainda aprendemos a fazer filtros que vão nos ajudar a visualizar com mais facilidade as mensagens de logs.

E aí, gostou de conhecer mais sobre os Logs no Android? Que tal aproveitar pra mergulhar ainda mais no universo do Android e dar uma conferida no nosso curso inicial de Android com Kotlin?

E se você gostou desse conteúdo, compartilhe com as amigas e amigos que podem gostar também e marca a gente lá nas redes sociais. Até a próxima! =D