What is ANR in Android?

ANR stands for Application Not Responding. It occurs when the app’s main thread is blocked for too long, specifically for more than 5 seconds. The Android operating system expects the main thread (also called the UI thread) to be responsive to user actions like tapping buttons, scrolling, or entering data. If the UI thread is held up by intensive operations, the system will trigger an ANR and prompt the user with the dreaded “App is not responding” dialog, offering the user an option to either wait or force close the app.

Common Causes of ANR:

1. Heavy Operations on the Main Thread: This includes tasks like performing network requests, database queries, file I/O, or complex computations.

2. Deadlocks or Synchronization Issues: Blocking the main thread while waiting for locks or resources can result in deadlock.

3. BroadcastReceiver Execution: If a BroadcastReceiver takes too long to complete, it can also cause an ANR.

4. ContentProvider Queries: A slow query on a ContentProvider can block the main thread.

5. Long-running services bound to the main thread*

Best Practices to Avoid ANR:

To prevent ANR, developers need to ensure that the main thread remains free to handle user input and UI updates. Here are some effective strategies:

1. Offload Heavy Tasks to Background Threads

The golden rule is never block the main thread. Use background threads to handle time-consuming tasks.

- Use AsyncTask, Executors, or HandlerThread: While AsyncTask is deprecated, you can use `Executors`or `HandlerThread` for simple background tasks.

- WorkManager or Coroutines: For more complex operations, consider using WorkManager for deferrable tasks or Kotlin coroutines for structured concurrency.

Example using Kotlin coroutines:

kotlin

GlobalScope.launch(Dispatchers.IO) {

    // Perform heavy task here, like database query

}        

2. Optimize Database and File I/O Operations

- Avoid performing large database queries or file I/O operations on the main thread. Use background threads and ensure queries are optimized.

- Room ORM automatically provides support for executing database queries off the main thread, making it easier to prevent ANR issues.

3. Network Operations on Background Threads

All network calls should happen asynchronously, using libraries like Retrofit, Volley, or Kotlin Coroutines with Dispatchers.IO. Make sure you're handling timeouts correctly, and always provide a fallback or retry mechanism.

Example with Retrofit and coroutines:

kotlin

suspend fun fetchData() {

    withContext(Dispatchers.IO) {

        // Retrofit call here

    }

}        

4. Limit BroadcastReceiver Execution Time

If your app uses a BroadcastReceiver, ensure it completes its job quickly. If the task takes longer, consider delegating the work to a JobIntentService or WorkManager.

5. Use StrictMode to Catch Violations Early

StrictMode is a tool in Android that helps detect accidental I/O operations on the main thread. You can enable it during development to catch potential ANR-causing code.

Example:

kotlin

StrictMode.setThreadPolicy(

    StrictMode.ThreadPolicy.Builder()

        .detectAll()

        .penaltyLog()

        .build()

)        

6. Avoid Long-running Operations in onCreate() or onResume()

Initialization tasks that take time should not block the app’s startup or UI rendering. Consider using background threads for initialization tasks or defer initialization until it's absolutely needed.

7. Keep UI Rendering Light

Make sure your UI doesn’t take too long to render. Avoid heavy operations like image decoding on the main thread. Use libraries like Glide or Picasso for efficient image loading and caching.

Conclusion

Avoiding ANR is all about keeping the main thread responsive and offloading long-running or blocking tasks to background threads. By following these best practices—such as utilizing background threads for heavy operations, optimizing database and network operations, and using tools like StrictMode—you can significantly reduce the chances of encountering ANR errors.

By delivering smooth, responsive apps, you not only improve the user experience but also boost your app’s chances of success in a highly competitive market.

Call to Action

If you found this article helpful or have any additional tips to avoid ANR, feel free to share your thoughts in the comments!