What is ANR?How it Can be Prevented in Android? ANR-WatchDog?

ANR or Application Not Responding is an android error that happens when the UI thread becomes unresponsive to the user. When the application becomes unresponsive, the user is presented with an ANR dialog that gives them the option to force quit the application.

What triggers ANR?

1. If your application does not respond to user input or BroadcastReceiver within five seconds.
2. Your BroadcastReceiver has not finished executing within a considerable amount of time, and the application has no ongoing foreground task.

A foreground task is a task noticeable by the user. An example of an ongoing foreground task is a music application playing audio. These tasks display a notification to the user.

A BroadcastReceiver is a component that listens to system-wide broadcasts such as a broadcast announcing that the screen was turned off.

Common culprits

Generally, ANRs are triggered because your application is doing the following:

1. Performing slow operations with I/O on the main thread.
2. Doing long calculations on the main thread.
3. Performing a synchronous binder call in the main thread and the other process is taking time to respond.
4. Waiting in the main thread for another thread that is performing a long operation.
5. Stuck in a deadlock situation. Deadlocks can happen in the main thread when it is waiting on resources that another process has not released, so it cannot acquire the resources it needs. These other processes may be in another thread, your process, or in a binder call.

Diagnosis techniques

ANR-WatchDog

Why it exists

There is currently no way for an android application to catch and report ANR errors.
If your application is not in the play store (either because you are still developing it or because you are distributing it differently), the only way to investigate an ANR is to pull the file /data/anr/traces.txt.
Additionally, we found that using the Play Store was not as effective as being able to choose our own bug tracking service.

There is an issue entry in the android bug tracker describing this lack, feel free to star it ;)

What it does

It sets up a “watchdog” timer that will detect when the UI thread stops responding. When it does, it raises an error with all threads stack traces (main first).

Can it work with crash reporters?

Yes! I’m glad you asked: That’s the reason why it was developed in the first place!
As this throws an error, a crash handler can intercept it and handle it the way it needs.

Known working crash reporters include:

• ACRA
• Crashlytics (Only with setReportMainThreadOnly())
• HockeyApp
• Bugsnag

And there is no reason why it should not work with [insert your favourite crash reporting system here].

How it works

The watchdog is a simple thread that does the following in a loop:

1. Schedules a runnable to be run on the UI thread as soon as possible.
2. Wait for 5 seconds. (5 seconds is the default, but it can be configured).
3. See if the runnable has been run. If it has, go back to 1.
4. If the runnable has not been run, which means that the UI thread has been blocked for at least 5 seconds, it raises an error with all running threads stack traces.

Usage

Install

With Gradle / Android Studio

1. In the app/build.gradle file, add:

• implementation 'com.github.anrwatchdog:anrwatchdog:1.4.0'

1. In your application class, in onCreate, add:

• new ANRWatchDog().start();

Reading the ANRError exception report

The ANRError stack trace is a bit particular, it has the stack traces of all the threads running in your application. So, in the report, each caused by section is not the cause of the precedent exception, but the stack trace of a different thread.

Here is a dead lock example:

FATAL EXCEPTION: |ANR-WatchDog|
    Process: anrwatchdog.github.com.testapp, PID: 26737
    com.github.anrwatchdog.ANRError: Application Not Responding
    Caused by: com.github.anrwatchdog.ANRError$_$_Thread: main (state = WAITING)
        at testapp.MainActivity$1.run(MainActivity.java:46)
        at android.os.Handler.handleCallback(Handler.java:739)
        at android.os.Handler.dispatchMessage(Handler.java:95)
        at android.os.Looper.loop(Looper.java:135)
        at android.app.ActivityThread.main(ActivityThread.java:5221)
    Caused by: com.github.anrwatchdog.ANRError$_$_Thread: APP: Locker (state = TIMED_WAITING)
        at java.lang.Thread.sleep(Native Method)
        at java.lang.Thread.sleep(Thread.java:1031)
        at java.lang.Thread.sleep(Thread.java:985)
        at testapp.MainActivity.SleepAMinute(MainActivity.java:18)
        at testapp.MainActivity.access$100(MainActivity.java:12)
        at testapp.MainActivity$LockerThread.run(MainActivity.java:36)

From this report, we can see that the stack traces of two threads. The first (the “main” thread) is stuck at MainActivity.java:46 while the second thread (named "App: Locker") is locked in a Sleep at MainActivity.java:18.
From there, if we looked at those two lines, we would surely understand the cause of the dead lock!

Note that some crash reporting library (such as Crashlytics) report all thread stack traces at the time of an uncaught exception. In that case, having all threads in the same exception can be cumbersome. In such cases, simply use setReportMainThreadOnly().

Configuration

Timeout (minimum hanging time for an ANR)

To set a different timeout (5000 millis is the default):

if (BuildConfig.DEBUG == false) {
  new ANRWatchDog(10000 /*timeout*/).start();
}

Debugger

By default, the watchdog will ignore ANRs if the debugger is attached or if the app is waiting for the debugger to attach. This is because it detects execution pauses and breakpoints as ANRs. To disable this and throw an ANRError even if the debugger is connected, you can add setIgnoreDebugger(true):

new ANRWatchDog().setIgnoreDebugger(true).start();

On ANR callback

If you would prefer not to crash the application when an ANR is detected, you can enable a callback instead:

new ANRWatchDog().setANRListener(new ANRWatchDog.ANRListener() {
    @Override
    public void onAppNotResponding(ANRError error) {
        // Handle the error. For example, log it to HockeyApp:
        ExceptionHandler.saveException(error, new CrashManager());
    }
}).start();

This is very important when delivering your app in production. When in the hand of the final user, it’s probably better not to crash after 5 seconds, but simply report the ANR to whatever reporting system you use. Maybe, after some more seconds, the app will “de-freeze”.

Filtering reports

If you would like to have only your own threads to be reported in the ANRError, and not all threads (including system threads such as the FinalizerDaemon thread), you can set a prefix: only the threads whose name starts with this prefix will be reported.

new ANRWatchDog().setReportThreadNamePrefix("APP:").start();

Then, when you start a thread, don’t forget to set its name to something that starts with this prefix (if you want it to be reported):

public class MyAmazingThread extends Thread {
    @Override
    public void run() {
        setName("APP: Amazing!");
        /* ... do amazing things ... */
    }
}

If you want to have only the main thread stack trace and not all the other threads, you can:

new ANRWatchDog().setReportMainThreadOnly().start();

ANR Interceptor

Sometimes, you want to know that the application has froze for a certain duration, but not report the ANR error just yet. You can define an interceptor that will be called before reporting an error. The role of the interceptor is to define whether or not, given the given freeze duration, an ANR error should be raised or postponed.

new ANRWatchDog(2000).setANRInterceptor(new ANRWatchDog.ANRInterceptor() {
    @Override
    public long intercept(long duration) {
        long ret = 5000 - duration;
        if (ret > 0) {
            Log.w(TAG, "Intercepted ANR that is too short (" + duration + " ms), postponing for " + ret + " ms.");
        }
        return ret;
    }
})

In this example, the ANRWatchDog starts with a timeout of 2000 ms, but the interceptor will postpone the error until at least 5000 ms of freeze has been reached.

Watchdog thread

ANRWatchDog is a thread, so you can interrupt it at any time.

If you are programming with Android’s multi process capability (like starting an activity in a new process), remember that you will need an ANRWatchDog thread per process.