¿Cómo obtengo datos de fallas de mi aplicación de Android?

¿Cómo puedo obtener datos de fallas (trazas de pila al menos) de mi aplicación de Android? Al menos cuando trabajo en mi propio dispositivo siendo recuperado por cable, pero idealmente desde cualquier instancia de mi aplicación que se ejecute en la naturaleza para que pueda mejorarla y hacerla más sólida.

Puede probar la biblioteca ACRA (Application Crash Report para Android) :

ACRA es una biblioteca que permite que la aplicación de Android publique automáticamente sus informes de fallas en un formulario de GoogleDoc. Está dirigido a los desarrolladores de aplicaciones de Android para ayudarlos a obtener datos de sus aplicaciones cuando se bloquean o se comportan erróneamente.

Es fácil de instalar en su aplicación, altamente configurable y no requiere que aloje un script de servidor en ningún lugar ... ¡los informes se envían a una hoja de cálculo de Google Doc!

Para aplicaciones de muestra y propósitos de depuración, utilizo una solución simple que me permite escribir el stacktrace en la tarjeta sd del dispositivo y / o subirlo a un servidor. Esta solución se ha inspirado en Project android-remote-stacktrace (específicamente, las partes de guardar en el dispositivo y cargar en el servidor) y creo que resuelve el problema mencionado por Soonil. No es óptimo, pero funciona y puede mejorarlo si desea usarlo en una aplicación de producción. Si decide cargar los stacktraces en el servidor, puede usar un script php ( index.php) para verlos. Si está interesado, puede encontrar todas las fuentes a continuación: una clase java para su aplicación y dos scripts php opcionales para el servidor que aloja los stacktraces cargados.

En un contexto (por ejemplo, la actividad principal), llame

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");
?>

También puedes probar [BugSense] ^{Motivo: redireccionamiento de spam a otra url} . BugSense recopila y analiza todos los informes de fallas y le brinda informes significativos y visuales. Es gratis y es solo una línea de código para integrarse.

Descargo de responsabilidad: soy cofundador

En Android 2.2 ahora es posible obtener automáticamente informes de bloqueo de aplicaciones de Android Market:

La nueva función de informe de errores para las aplicaciones de Android Market permite a los desarrolladores recibir informes de bloqueo y congelación de sus usuarios. Los informes estarán disponibles cuando inicien sesión en su cuenta de editor.

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

Es posible manejar estas excepciones con Thread.setDefaultUncaughtExceptionHandler(), sin embargo, esto parece alterar el método de manejo de excepciones de Android. Intenté usar un controlador de esta naturaleza:

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

Sin embargo, incluso al volver a lanzar las excepciones, no pude obtener el comportamiento deseado, es decir, registrar la excepción al tiempo que permitía que Android cerrara el componente que había sucedido, así que me di por vencido después de un tiempo.

Veo que la pregunta es demasiado antigua y espero que mi respuesta sea útil para otros que tengan el mismo problema ...

Prueba Crashlytics . Le dará una visión profunda de todos los bloqueos en todos los dispositivos que tienen su aplicación y le enviará una notificación por correo electrónico ... Y la mejor parte es que es completamente gratis.

Ok, bueno, miré las muestras proporcionadas por rrainn y Soonil, y encontré una solución que no estropea el manejo de errores.

Modifiqué el CustomExceptionHandler para que almacene el UncaughtExceptionHandler original del Hilo al que asociamos el nuevo. Al final del nuevo "uncaughtException" - Método, simplemente llamo a la función anterior usando el UncaughtExceptionHandler almacenado.

En la clase DefaultExceptionHandler necesitas algo. Me gusta esto:

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();
  }
}

Con esa modificación en el código en http://code.google.com/p/android-remote-stacktrace , tiene una buena base de trabajo para iniciar sesión en el campo en su servidor web o tarjeta SD.

Google Play Developers Console realmente te ofrece los rastros de Stack de esas aplicaciones que se han bloqueado y han enviado los informes, también tiene muy buenos gráficos para ayudarte a ver la información, mira el siguiente ejemplo:

He estado usando Crittercism para mis aplicaciones de Android e iOS; escuché sobre ellas en techcrunch. Muy feliz con ellos hasta ahora!

Hice mi propia versión aquí: http://androidblogger.blogspot.com/2009/12/how-to-improve-your-application-crash.html

Básicamente es lo mismo, pero estoy usando un correo electrónico en lugar de una conexión http para enviar el informe y, lo que es más importante, agregué información a mi informe, como la versión de la aplicación, la versión del sistema operativo, el modelo del teléfono o la memoria disponible. .

use esto para capturar los detalles de la excepción:

String stackTrace = Log.getStackTraceString(exception); 

almacenar esto en la base de datos y mantener el registro.

También puede usar un servicio completo (simple) en lugar de solo una biblioteca. Nuestra compañía acaba de lanzar un servicio solo para eso: http://apphance.com .

Tiene una biblioteca .jar simple (para Android) que agrega e integra en 5 minutos y luego la biblioteca recopila no solo información sobre fallas, sino también registros de la aplicación en ejecución, así como permite a sus evaluadores informar problemas directamente desde el dispositivo, incluido el contexto completo (rotación del dispositivo, ya sea que esté conectado a un wifi o no y más). Puede mirar los registros utilizando un panel web muy agradable y útil, donde puede realizar un seguimiento de las sesiones con su aplicación, bloqueos, registros, estadísticas y más. El servicio está en fase de prueba beta cerrada ahora, pero puede solicitar acceso y se lo daremos muy rápidamente.

Descargo de responsabilidad: soy CTO de Polidea y cocreador del servicio.

Agradezco los recursos presentes en Stackoverflowayudarme a encontrar esta respuesta.

Puede encontrar sus informes de fallas de Android de forma remota directamente en su correo electrónico . recuerda que debes poner tu correo electrónico dentro de la clase CustomExceptionHandler .

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

Pasos requeridos:

Primero) en onCreate of your activity use esta sección de su código.

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

2º) use esta versión anulada de la clase CustomExceptionHandler de (rrainn), de acuerdo con mi 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();

    }
}

Hoy en día, los informes de Firebase Crash son muy populares y fáciles de usar. Consulte el siguiente enlace para obtener más información: Informes de bloqueo de Firebase

Espero que te ayude.

Esto es muy bruto, pero es posible ejecutar logcat en cualquier lugar, por lo que se debe agregar un truco rápido y sucio a cualquier bloque de captura getRuntime().exec("logcat >> /sdcard/logcat.log");

Existe una herramienta llamada fabric, esta es una herramienta analítica de fallas, que le permitirá obtener informes de fallas, cuando la aplicación se implemente en vivo y durante el desarrollo. Agregar esta herramienta a su aplicación también fue simple. Cuando su aplicación falla, el informe del bloqueo se puede ver desde su tablero de fabric.io. Este informe se capturó automáticamente. No le pedirá permiso al usuario. Si desea enviar el informe de error / bloqueo. Y esto es completamente gratis ... https://get.fabric.io/

Google Firebase es la última forma de Google (2016) de proporcionarle datos de fallas / errores en su teléfono. Inclúyalo en su archivo build.gradle:

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

Los bloqueos fatales se registran automáticamente sin requerir la intervención del usuario y también puede registrar bloqueos no fatales u otros eventos como este:

try
{

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

Existe esta biblioteca de Android llamada Sherlock . Le proporciona el informe completo del bloqueo junto con la información del dispositivo y la aplicación. Cada vez que ocurre un bloqueo, muestra una notificación en la barra de notificaciones y al hacer clic en la notificación, abre los detalles del bloqueo. También puede compartir detalles del bloqueo con otras personas por correo electrónico u otras opciones para compartir.

Instalación

android {
    dataBinding {
      enabled = true
    }
}

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

Manifestación

Si bien muchas de las respuestas en esta página son útiles, es fácil que se desactualicen. El sitio web de AppBrain agrega estadísticas que le permiten encontrar la solución de informes de fallas más popular que es actual:

Bibliotecas de informes de fallos de Android

Puede ver que al momento de publicar esta imagen, Crashlytics se usa en el 5.24% de las aplicaciones y el 12.38% de las instalaciones.

Utilizamos nuestro sistema interno dentro de la empresa y nos sirve muy bien. Es una biblioteca de Android que envía informes de fallas al servidor y al servidor que recibe informes y realiza algunos análisis. El servidor agrupa las excepciones por nombre de excepción, stacktrace, mensaje. Ayuda a identificar los problemas más críticos que deben corregirse. Nuestro servicio está en versión beta pública ahora para que todos puedan probarlo. Puede crear una cuenta en http://watchcat.co o simplemente puede ver cómo funciona usando el acceso de demostración http://watchcat.co/reports/index.php?demo .

Si quiere respuestas de inmediato, puede usar logcat

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

Si hay demasiada basura en su registro en este momento, intente borrarlo primero.

$adb shell logcat -c

Luego intente ejecutar su aplicación y luego logcat nuevamente.

Encontré una gran aplicación web más para rastrear los informes de errores.

https://mint.splunk.com/

Pequeño número de pasos para configurar.

1. Inicie sesión o regístrese y configure usando el enlace de arriba. Una vez que haya terminado de crear una aplicación, le proporcionarán una línea para configurar como se muestra a continuación.

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

2. Agregue lo siguiente en la aplicación build.gradl.

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

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

3. Agregue el código que copiamos arriba y agréguelo a cada actividad.

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

Eso es. Inicie sesión y vaya al panel de la aplicación, obtendrá todos los informes de errores.

Espero que ayude a alguien.

Para un servicio alternativo de informe de fallas / seguimiento de excepciones, consulte fallas Raygun.io : tiene una buena lógica para manejar los bloqueos de Android, incluida una experiencia de usuario decente al conectarlo a su aplicación (dos líneas de código en su Actividad principal y algunas líneas de XML pegadas en AndroidManifest).

Cuando su aplicación se bloquea, automáticamente capturará el seguimiento de la pila, los datos del entorno del hardware / software, la información de seguimiento del usuario, cualquier información personalizada que especifique, etc. La publicará en la API de forma asincrónica para que no se bloquee el hilo de la interfaz de usuario y la almacene en caché al disco si no hay red disponible.

Descargo de responsabilidad: construí el proveedor de Android :)

Recién comencé a usar ACRA https://github.com/ACRA/acra usando Google Forms como back-end y es muy fácil de configurar y usar, es el valor predeterminado.

PERO el envío de informes a los formularios de Google quedará en desuso (luego se eliminará): https://plus.google.com/118444843928759726538/posts/GTTgsrEQdN6 https://github.com/ACRA/acra/wiki/Notice-on-Google -Formulario-Hoja de cálculo-uso

De todos modos, es posible definir su propio remitente https://github.com/ACRA/acra/wiki/AdvancedUsage#wiki-Implementing_your_own_sender , puede intentar enviar un correo electrónico al remitente, por ejemplo.

Con un mínimo esfuerzo es posible enviar informes a bugsense: http://www.bugsense.com/docs/android#acra

Nota : la cuenta gratuita de bugsense está limitada a 500 informes / mes

Tarde a la fiesta, apoyo y creo que ACRA es la mejor opción entre todas. Es fácil de configurar y configurar. He creado una guía detallada con entradas de todas partes para buscar el informe de falla usando ACRA y enviarlo por correo a mi dirección de correo electrónico usando MandrillAp.

Enlace a la publicación: https://androidician.wordpress.com/2015/03/29/sending-crash-reports-with-acra-over-email-using-mandrill/

Enlace al proyecto de muestra en github: https://github.com/ayushhgoyal/AcraSample

Soy uno de los fundadores de Bugsnag, que diseñamos exactamente para este propósito. Bugsnag captura automáticamente las excepciones no controladas en las aplicaciones de Android y las envía a nuestro panel de control, donde puede priorizar las soluciones y sumergirse en la información de diagnóstico.

Estas son algunas cosas importantes a tener en cuenta al seleccionar o crear un sistema de informe de fallos, junto con algunos fragmentos de código:

• Detecta excepciones no manejadas automáticamente ( código de ejemplo )
• Recopila datos de diagnóstico como el uso de memoria, información del dispositivo, etc. ( código de ejemplo )
• Agrupa efectivamente los choques por causa raíz
• Le permite realizar un seguimiento de las acciones que realizó el usuario antes de cada bloqueo para ayudar a reproducir ( código de ejemplo )

Si desea ver algunas de las mejores prácticas sobre el manejo / informe de fallas en Android, puede consultar el código fuente completo de la biblioteca de informes de fallas de Bugsnag que es de código abierto, ¡no dude en separar esto y usarlo en sus propias aplicaciones!

Si otras personas descargan su aplicación y se bloquea en dispositivos remotos, es posible que desee buscar en una biblioteca de informes de errores de Android (mencionada en esta publicación SO ). Si solo está en su propio dispositivo local, puede usar LogCat. Incluso si el dispositivo no estaba conectado a una máquina host cuando se produjo el bloqueo, al conectar el dispositivo y al emitir un comando adb logcat se descargará todo el historial de logcat (al menos en la medida en que está almacenado en el búfer, que suele ser una gran cantidad de datos de registro) , simplemente no es infinito). ¿Alguna de esas opciones responde a su pregunta? Si no, ¿puedes intentar aclarar un poco más lo que estás buscando?

Flurry analytics le brinda información sobre fallas, modelo de hardware, versión de Android y estadísticas de uso de aplicaciones en vivo. En el nuevo SDK, parecen proporcionar información de bloqueo más detallada http://www.flurry.com/flurry-crash-analytics.html .

Google cambió la cantidad de informes de fallos que realmente recibes. Anteriormente solo recibías informes de errores informados manualmente.

Desde la última conferencia de desarrolladores y la presentación de Android Vitals , también recibe informes de fallas de los usuarios que han permitido compartir datos de diagnóstico.

Verá todos los bloqueos recopilados de los dispositivos Android cuyos usuarios han optado por compartir automáticamente los datos de uso y diagnóstico. Los datos están disponibles para los dos meses anteriores.

Ver fallas y errores de aplicación que no responde (ANR)

Puedes hacer esto directamente en Android Studio. Simplemente conecte su teléfono, ejecute la aplicación, deje que se bloquee y podrá ver el seguimiento de la pila directamente en Android Studio.