Como obtenho dados de falha do meu aplicativo Android?

Como posso obter dados de falha (rastreios de pilha pelo menos) do meu aplicativo Android? Pelo menos ao trabalhar no meu próprio dispositivo sendo recuperado por cabo, mas idealmente a partir de qualquer instância do meu aplicativo em execução no ambiente, para que eu possa melhorá-lo e torná-lo mais sólido.

Você pode experimentar a biblioteca do ACRA (Application Crash Report for Android) :

A ACRA é uma biblioteca que permite ao Aplicativo Android publicar automaticamente seus relatórios de falhas em um formulário do GoogleDoc. Ele é direcionado aos desenvolvedores de aplicativos Android para ajudá-los a obter dados de seus aplicativos quando eles travam ou se comportam de maneira incorreta.

É fácil de instalar no seu aplicativo, altamente configurável e não exige que você hospede um script de servidor em qualquer lugar ... os relatórios são enviados para uma planilha do Google Doc!

Para aplicativos de amostra e propósitos de depuração, uso uma solução simples que permite gravar o rastreamento de pilha no cartão sd do dispositivo e / ou enviá-lo para um servidor. Essa solução foi inspirada no Project android-remote-stacktrace (especificamente, nas partes salvar no dispositivo e fazer upload no servidor) e acho que resolve o problema mencionado por Soonil. Não é o ideal, mas funciona e você pode aprimorá-lo se quiser usá-lo em um aplicativo de produção. Se você decidir fazer upload dos rastreamentos de pilha no servidor, poderá usar um script php ( index.php) para visualizá-los. Se você estiver interessado, poderá encontrar todas as fontes abaixo - uma classe java para seu aplicativo e dois scripts php opcionais para o servidor que hospeda os stacktraces carregados.

Em um contexto (por exemplo, a atividade principal), chame

if(!(Thread.getDefaultUncaughtExceptionHandler() instanceof CustomExceptionHandler)) {
    Thread.setDefaultUncaughtExceptionHandler(new CustomExceptionHandler(
            "/sdcard/<desired_local_path>", "http://<desired_url>/upload.php"));
}

CustomExceptionHandler

public class CustomExceptionHandler implements UncaughtExceptionHandler {

    private UncaughtExceptionHandler defaultUEH;

    private String localPath;

    private String url;

    /* 
     * if any of the parameters is null, the respective functionality 
     * will not be used 
     */
    public CustomExceptionHandler(String localPath, String url) {
        this.localPath = localPath;
        this.url = url;
        this.defaultUEH = Thread.getDefaultUncaughtExceptionHandler();
    }

    public void uncaughtException(Thread t, Throwable e) {
        String timestamp = TimestampFormatter.getInstance().getTimestamp();
        final Writer result = new StringWriter();
        final PrintWriter printWriter = new PrintWriter(result);
        e.printStackTrace(printWriter);
        String stacktrace = result.toString();
        printWriter.close();
        String filename = timestamp + ".stacktrace";

        if (localPath != null) {
            writeToFile(stacktrace, filename);
        }
        if (url != null) {
            sendToServer(stacktrace, filename);
        }

        defaultUEH.uncaughtException(t, e);
    }

    private void writeToFile(String stacktrace, String filename) {
        try {
            BufferedWriter bos = new BufferedWriter(new FileWriter(
                    localPath + "/" + filename));
            bos.write(stacktrace);
            bos.flush();
            bos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void sendToServer(String stacktrace, String filename) {
        DefaultHttpClient httpClient = new DefaultHttpClient();
        HttpPost httpPost = new HttpPost(url);
        List<NameValuePair> nvps = new ArrayList<NameValuePair>();
        nvps.add(new BasicNameValuePair("filename", filename));
        nvps.add(new BasicNameValuePair("stacktrace", stacktrace));
        try {
            httpPost.setEntity(
                    new UrlEncodedFormEntity(nvps, HTTP.UTF_8));
            httpClient.execute(httpPost);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

upload.php

<?php
    $filename = isset($_POST['filename']) ? $_POST['filename'] : "";
    $message = isset($_POST['stacktrace']) ? $_POST['stacktrace'] : "";
    if (!ereg('^[-a-zA-Z0-9_. ]+$', $filename) || $message == ""){
        die("This script is used to log debug data. Please send the "
                . "logging message and a filename as POST variables.");
    }
    file_put_contents($filename, $message . "\n", FILE_APPEND);
?>

index.php

<?php
    $myDirectory = opendir(".");
    while($entryName = readdir($myDirectory)) {
        $dirArray[] = $entryName;
    }
    closedir($myDirectory);
    $indexCount = count($dirArray);
    sort($dirArray);
    print("<TABLE border=1 cellpadding=5 cellspacing=0 \n");
    print("<TR><TH>Filename</TH><TH>Filetype</th><th>Filesize</TH></TR>\n");
    for($index=0; $index < $indexCount; $index++) {
        if ((substr("$dirArray[$index]", 0, 1) != ".") 
                && (strrpos("$dirArray[$index]", ".stacktrace") != false)){ 
            print("<TR><TD>");
            print("<a href=\"$dirArray[$index]\">$dirArray[$index]</a>");
            print("</TD><TD>");
            print(filetype($dirArray[$index]));
            print("</TD><TD>");
            print(filesize($dirArray[$index]));
            print("</TD></TR>\n");
        }
    }
    print("</TABLE>\n");
?>

Você também pode experimentar o [BugSense] ^{Motivo: redirecionamento de spam para outro URL} . O BugSense coleta e analisa todos os relatórios de falhas e fornece relatórios visuais e significativos. É gratuito e possui apenas 1 linha de código para integrar.

Disclaimer: Eu sou um co-fundador

No Android 2.2, agora é possível obter automaticamente os Relatórios de falhas a partir dos aplicativos do Android Market:

O novo recurso de relatório de erros dos aplicativos Android Market permite que os desenvolvedores recebam relatórios de travamentos e congelamentos de seus usuários. Os relatórios estarão disponíveis quando eles fizerem login na conta do editor.

http://developer.android.com/sdk/android-2.2-highlights.html

É possível lidar com essas exceções Thread.setDefaultUncaughtExceptionHandler(), mas isso parece mexer com o método do Android de lidar com exceções. Eu tentei usar um manipulador dessa natureza:

private class ExceptionHandler implements Thread.UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread thread, Throwable ex){
        Log.e(Constants.TAG, "uncaught_exception_handler: uncaught exception in thread " + thread.getName(), ex);

        //hack to rethrow unchecked exceptions
        if(ex instanceof RuntimeException)
            throw (RuntimeException)ex;
        if(ex instanceof Error)
            throw (Error)ex;

        //this should really never happen
        Log.e(Constants.TAG, "uncaught_exception handler: unable to rethrow checked exception");
    }
}

No entanto, mesmo com o relançamento das exceções, não consegui obter o comportamento desejado, ou seja, registrei a exceção e, ao mesmo tempo, permiti que o Android desligasse o componente que havia acontecido, por isso desisti depois de um tempo.

Vejo que a pergunta é muito antiga e espero que minha resposta seja útil para outras pessoas com o mesmo problema ...

Experimente o Crashlytics . Ele fornecerá informações detalhadas sobre todas as falhas em todos os dispositivos que possuem seu aplicativo e enviará uma notificação por e-mail. E a melhor parte é totalmente gratuito para uso.

Ok, olhei as amostras fornecidas pela rrainn e Soonil e encontrei uma solução que não atrapalha o tratamento de erros.

Modifiquei o CustomExceptionHandler para que ele armazene o UncaughtExceptionHandler original do Thread que associamos ao novo. No final do novo "uncaughtException" - Método, chamo a função antiga usando o UncaughtExceptionHandler armazenado.

Na classe DefaultExceptionHandler, você precisa de sth. como isso:

public class DefaultExceptionHandler implements UncaughtExceptionHandler{
  private UncaughtExceptionHandler mDefaultExceptionHandler;

  //constructor
  public DefaultExceptionHandler(UncaughtExceptionHandler pDefaultExceptionHandler)
  {
       mDefaultExceptionHandler= pDefaultExceptionHandler;
  }
  public void uncaughtException(Thread t, Throwable e) {       
        //do some action like writing to file or upload somewhere         

        //call original handler  
        mStandardEH.uncaughtException(t, e);        

        // cleanup, don't know if really required
        t.getThreadGroup().destroy();
  }
}

Com essa modificação no código em http://code.google.com/p/android-remote-stacktrace, você tem uma boa base de trabalho para fazer logon no campo no servidor da web ou no cartão SD.

O Google Play Developers Console, na verdade, fornece os rastreamentos de pilha dos aplicativos que falharam e enviaram os relatórios; também possui gráficos muito bons para ajudá-lo a ver as informações, veja o exemplo abaixo:

Eu uso o Crittercism para meus aplicativos Android e iOS - ouvi falar deles no TechCrunch. Muito feliz com eles até agora!

Criei minha própria versão aqui: http://androidblogger.blogspot.com/2009/12/how-to-improve-your-application-crash.html

É basicamente a mesma coisa, mas estou usando um email em vez de uma conexão http para enviar o relatório e, mais importante, adicionei algumas informações como versão do aplicativo, versão do SO, modelo do telefone ou memória disponível no meu relatório. .

use isso para capturar os detalhes da exceção:

String stackTrace = Log.getStackTraceString(exception); 

armazene isso no banco de dados e mantenha o log.

Você também pode usar um serviço (simples) completo para ele, em vez de apenas uma biblioteca. Nossa empresa acaba de lançar um serviço exatamente para isso: http://apphance.com .

Possui uma biblioteca .jar simples (para Android) que você adiciona e integra em 5 minutos e, em seguida, a biblioteca reúne não apenas informações de falha, mas também logs do aplicativo em execução, além de permitir que os testadores relatem problemas diretamente do dispositivo - incluindo o contexto inteiro (rotação do dispositivo, esteja ele conectado a um wifi ou não e mais). Você pode ver os logs usando um painel da Web muito agradável e útil, onde pode acompanhar sessões com seu aplicativo, falhas, logs, estatísticas e muito mais. O serviço está em fase de teste beta fechado agora, mas você pode solicitar acesso e nós o fornecemos muito rapidamente.

Isenção de responsabilidade: Sou CTO da Polidea e co-criador do serviço.

Graças aos recursos presentes, Stackoverflowajudando-me a encontrar esta resposta.

Você pode encontrar seus relatórios de falhas remotamente Android diretamente em seu e-mail . Lembre-se de que você deve colocar seu email na classe CustomExceptionHandler .

public static String sendErrorLogsTo = "[email protected]" ;

Etapas necessárias:

1º) no onCreate de sua atividade, use esta seção do seu código.

    if(!(Thread.getDefaultUncaughtExceptionHandler() instanceof CustomExceptionHandler)) {
        Thread.setDefaultUncaughtExceptionHandler(new CustomExceptionHandler(this));
    }   

2) use esta versão substituída da classe CustomExceptionHandler de (rrainn), de acordo com meu phpscript.

package com.vxmobilecomm.activity;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.Thread.UncaughtExceptionHandler;
import java.util.ArrayList;
import java.util.List;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.BufferedHttpEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;

import android.app.Activity;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.os.AsyncTask;
import android.util.Log;

public class CustomExceptionHandler implements UncaughtExceptionHandler {

    private UncaughtExceptionHandler defaultUEH;
    public static String sendErrorLogsTo = "[email protected]" ;

    Activity activity;

    public CustomExceptionHandler(Activity activity) {
        this.defaultUEH = Thread.getDefaultUncaughtExceptionHandler();
        this.activity = activity;
    }

    public void uncaughtException(Thread t, Throwable e) {

        final Writer result = new StringWriter();
        final PrintWriter printWriter = new PrintWriter(result);
        e.printStackTrace(printWriter);
        String stacktrace = result.toString();
        printWriter.close();
        String filename = "error" + System.nanoTime() + ".stacktrace";

        Log.e("Hi", "url != null");
        sendToServer(stacktrace, filename);

        StackTraceElement[] arr = e.getStackTrace();
        String report = e.toString() + "\n\n";
        report += "--------- Stack trace ---------\n\n";
        for (int i = 0; i < arr.length; i++) {
            report += "    " + arr[i].toString() + "\n";
        }
        report += "-------------------------------\n\n";

        report += "--------- Cause ---------\n\n";
        Throwable cause = e.getCause();
        if (cause != null) {
            report += cause.toString() + "\n\n";
            arr = cause.getStackTrace();
            for (int i = 0; i < arr.length; i++) {
                report += "    " + arr[i].toString() + "\n";
            }
        }
        report += "-------------------------------\n\n";

        defaultUEH.uncaughtException(t, e);
    }

    private void sendToServer(String stacktrace, String filename) {
        AsyncTaskClass async = new AsyncTaskClass(stacktrace, filename,
                getAppLable(activity));
        async.execute("");
    }

    public String getAppLable(Context pContext) {
        PackageManager lPackageManager = pContext.getPackageManager();
        ApplicationInfo lApplicationInfo = null;
        try {
            lApplicationInfo = lPackageManager.getApplicationInfo(
                    pContext.getApplicationInfo().packageName, 0);
        } catch (final NameNotFoundException e) {
        }
        return (String) (lApplicationInfo != null ? lPackageManager
                .getApplicationLabel(lApplicationInfo) : "Unknown");
    }

    public class AsyncTaskClass extends AsyncTask<String, String, InputStream> {
        InputStream is = null;
        String stacktrace;
        final String filename;
        String applicationName;

        AsyncTaskClass(final String stacktrace, final String filename,
                String applicationName) {
            this.applicationName = applicationName;
            this.stacktrace = stacktrace;
            this.filename = filename;
        }

        @Override
        protected InputStream doInBackground(String... params) 
        { 
            HttpClient httpclient = new DefaultHttpClient();
            HttpPost httppost = new HttpPost(
                    "http://suo-yang.com/books/sendErrorLog/sendErrorLogs.php?");

            Log.i("Error", stacktrace);

            try {
                List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(
                        6);

                nameValuePairs.add(new BasicNameValuePair("data", stacktrace));
                nameValuePairs.add(new BasicNameValuePair("to",sendErrorLogsTo));
                nameValuePairs.add(new BasicNameValuePair("subject",applicationName));

                httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));

                HttpResponse response = httpclient.execute(httppost);

                HttpEntity entity1 = response.getEntity();

                BufferedHttpEntity bufHttpEntity = new BufferedHttpEntity(
                        entity1);

                is = bufHttpEntity.getContent();

            } catch (ClientProtocolException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }

            return is;
        }

        @Override
        protected void onPostExecute(InputStream result) {
            super.onPostExecute(result);

            Log.e("Stream Data", getStringFromInputStream(is));
        }
    }

    // convert InputStream to String
    private static String getStringFromInputStream(InputStream is) {

        BufferedReader br = null;
        StringBuilder sb = new StringBuilder();

        String line;
        try {

            br = new BufferedReader(new InputStreamReader(is));
            while ((line = br.readLine()) != null) {
                sb.append(line);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return sb.toString();

    }
}

Atualmente, os relatórios do Firebase Crash são muito populares e fáceis de usar. Consulte o link a seguir para obter mais informações: Firebase Crash Reporting

Espero que ajude você.

Isso é muito bruto, mas é possível executar o logcat em qualquer lugar, portanto, um hack rápido e sujo é adicionado a qualquer bloco de captura getRuntime().exec("logcat >> /sdcard/logcat.log");

Existe uma ferramenta chamada fabric, que é uma ferramenta de análise de falhas, que permite obter relatórios de falhas quando o aplicativo é implementado ao vivo e durante o desenvolvimento. A adição desta ferramenta ao seu aplicativo também foi simples. Quando o seu aplicativo falha, o relatório da falha pode ser visualizado no painel fabric.io. o relatório foi capturado automaticamente. não solicitará permissão ao usuário. Se ele / ela deseja enviar o relatório de erro / falha. E isso é totalmente gratuito ... https://get.fabric.io/

O Google Firebase é a maneira mais recente (2016) do Google de fornecer dados de falha / erro no seu telefone. Inclua-o no arquivo build.gradle:

compile 'com.google.firebase:firebase-crash:9.0.0'

Falhas fatais são registradas automaticamente sem a necessidade de entrada do usuário e você também pode registrar falhas não fatais ou outros eventos como:

try
{

}
catch(Exception ex)
{
    FirebaseCrash.report(new Exception(ex.toString()));
}

Existe esta biblioteca Android chamada Sherlock . Ele fornece o relatório completo de falha, além de informações sobre o dispositivo e o aplicativo. Sempre que ocorre uma falha, ele exibe uma notificação na barra de notificação e, ao clicar nela, abre os detalhes da falha. Você também pode compartilhar detalhes da falha com outras pessoas por e-mail ou outras opções de compartilhamento.

Instalação

android {
    dataBinding {
      enabled = true
    }
}

compile('com.github.ajitsing:sherlock:1.0.0@aar') {
    transitive = true
}

Demo

Embora muitas das respostas desta página sejam úteis, é fácil para elas ficarem desatualizadas. O site do AppBrain agrega estatísticas que permitem encontrar a solução de relatório de falhas mais popular atualmente:

Bibliotecas de relatórios de falhas do Android

Você pode ver que, no momento da publicação desta imagem, o Crashlytics é usado em 5,24% dos aplicativos e 12,38% das instalações.

Utilizamos nosso sistema interno dentro da empresa e isso nos serve muito bem. É uma biblioteca Android que envia relatórios de falhas para o servidor e servidor que recebe relatórios e faz algumas análises. O servidor agrupa exceções por nome da exceção, rastreamento de pilha, mensagem. Ajuda a identificar os problemas mais críticos que precisam ser corrigidos. Nosso serviço está em versão beta pública agora, para que todos possam experimentá-lo. Você pode criar uma conta em http://watchcat.co ou pode simplesmente ver como funciona usando o acesso demo http://watchcat.co/reports/index.php?demo .

Se você deseja respostas imediatamente, pode usar o logcat

$adb shell logcat -f /sdcard/logoutput.txt *:E

Se houver muito lixo no seu log agora, tente limpá-lo primeiro.

$adb shell logcat -c

Em seguida, tente executar o aplicativo e faça o logcat novamente.

Encontrei mais um ótimo aplicativo da web para rastrear os relatórios de erros.

https://mint.splunk.com/

Pequeno número de etapas para configurar.

1. Entre ou inscreva-se e configure usando o link acima. Depois de criar um aplicativo, eles fornecerão uma linha para configurar como abaixo.

Mint.initAndStartSession(YourActivity.this, "api_key");

2. Adicione o seguinte no build.gradl do aplicativo.

android {
...
    repositories {
        maven { url "https://mint.splunk.com/gradle/"}
    }
...
}

dependencies {
...
    compile "com.splunk.mint:mint:4.4.0"
...
}

3. Adicione o código que copiamos acima e adicione-o a todas as atividades.

   Mint.initAndStartSession (YourActivity.this, "api_key");

É isso aí. Ao fazer o login e acessar o painel do aplicativo, você receberá todos os relatórios de erros.

Espero que ajude alguém.

Para um serviço alternativo de relatório de falhas / rastreamento de exceções, confira Raygun.io - ele tem várias lógicas legais para lidar com falhas do Android, incluindo uma experiência decente do usuário ao conectá-las ao seu aplicativo (duas linhas de código na sua Atividade principal e algumas linhas de XML coladas no AndroidManifest).

Quando o aplicativo falha, ele pega automaticamente o rastreamento da pilha, os dados do ambiente para o hardware / software, as informações de rastreamento do usuário, quaisquer dados personalizados que você especificar etc. Ele o envia para a API de forma assíncrona, sem bloqueio do encadeamento da interface do usuário, e o armazena em cache. para o disco se não houver rede disponível.

Isenção de responsabilidade: criei o provedor Android :)

Apenas começou a usar o ACRA https://github.com/ACRA/acra usando o Google Forms como back-end e é muito fácil de configurar e usar, é o padrão.

MAS O envio de relatórios para o Google Forms será preterido (depois removido): https://plus.google.com/118444843928759726538/posts/GTTgsrEQdN6 https://github.com/ACRA/acra/wiki/Notice-on-Google -Form-Spreadsheet-use

De qualquer forma, é possível definir seu próprio remetente https://github.com/ACRA/acra/wiki/AdvancedUsage#wiki-Implementing_your_own_sender Você pode tentar enviar um e-mail ao remetente, por exemplo.

Com o mínimo esforço, é possível enviar relatórios para o bugsense: http://www.bugsense.com/docs/android#acra

NB A conta gratuita do bugsense é limitada a 500 relatórios / mês

Tarde para a festa, apoio e acredito que a ACRA é a melhor opção entre todas. É fácil de instalar e configurar. Criei um guia detalhado com entradas de todo o país para buscar o relatório de falha usando o ACRA e enviar o mesmo para o meu endereço de e-mail usando o MandrillAp.

Link para postagem: https://androidician.wordpress.com/2015/03/29/sending-crash-reports-with-acra-over-email-using-mandrill/

Link para amostra de projeto no github: https://github.com/ayushhgoyal/AcraSample

Eu sou um dos fundadores da Bugsnag que projetamos exatamente para esse fim. O Bugsnag captura automaticamente exceções não tratadas em aplicativos Android e as envia para o nosso painel, onde você pode priorizar correções e mergulhar nas informações de diagnóstico.

Aqui estão algumas coisas importantes a considerar ao selecionar ou criar um sistema de relatório de falhas, junto com alguns trechos de código:

• Detecta exceções não tratadas automaticamente ( código de exemplo )
• Coleta dados de diagnóstico, como uso de memória, informações do dispositivo etc. ( código de exemplo )
• Agrupa efetivamente as falhas por causa raiz
• Permite rastrear ações que o usuário executou antes de cada falha para ajudar a reproduzir ( código de exemplo )

Se você quiser ver algumas práticas recomendadas em relação ao tratamento / relatório de falhas no Android, confira o código-fonte completo da biblioteca de relatórios de falhas do Bugsnag, que é totalmente aberta, sinta-se à vontade para separar isso e usá-lo em seus próprios aplicativos!

Se o aplicativo estiver sendo baixado por outras pessoas e travando em dispositivos remotos, convém consultar uma biblioteca de relatórios de erros do Android (mencionada nesta postagem do SO ). Se for apenas no seu próprio dispositivo local, você pode usar o LogCat. Mesmo que o dispositivo não tenha sido conectado a uma máquina host quando ocorreu a falha, o dispositivo conectado e a emissão de um comando adb logcat farão o download de todo o histórico do logcat (pelo menos na medida em que estiver em buffer, o que geralmente é uma quantidade imensa de dados de log , simplesmente não é infinito). Alguma dessas opções responde à sua pergunta? Caso contrário, você pode tentar esclarecer um pouco mais o que está procurando?

A análise de agitação fornece informações sobre falhas, modelo de hardware, versão do Android e estatísticas de uso de aplicativos ao vivo. No novo SDK, eles parecem fornecer informações mais detalhadas sobre falhas http://www.flurry.com/flurry-crash-analytics.html .

O Google mudou a quantidade de relatórios de falhas que você realmente recebe. Anteriormente, você só recebia relatórios de erros reportados manualmente.

Desde a última conferência do desenvolvedor e a introdução do Android Vitals, você também recebe relatórios de falhas de usuários que ativaram o compartilhamento de dados de diagnóstico.

Você verá todas as falhas coletadas em dispositivos Android cujos usuários optaram por compartilhar automaticamente dados de uso e diagnóstico. Os dados estão disponíveis para os dois meses anteriores.

Ver falhas e erros de aplicação não respondendo (ANR)

Você pode fazer isso diretamente no Android Studio. Basta conectar seu telefone, executar o aplicativo, deixá-lo travar e você pode visualizar o rastreamento de pilha diretamente no Android Studio.