Implementing user-unaware background crash handling in Android

As the saying goes, if you want to have no bugs, don't write a single line of code. When an app reaches the hands of users, the fewer crashes the better. Crash handling in Android is different from that in iOS. iOS crashes usually result in a flash back, while Android will display a clumsy dialog box as shown below.

It’s not surprising that when your users see a crash dialog like this, they think “this class of programmers is terrible”.

In Android, our applications have the concept of foreground and background. In this article, it is defined as follows: the current application has an Activity displayed (that is, the user clearly perceives that they are in the current application), which is agreed to be the foreground, otherwise it is the background.

If a crash occurs in the foreground, the user will be able to clearly perceive it, but if it happens in the background, we can do some simple operations to prevent the user from noticing the crash (i.e., no crash dialog box will pop up).

The principle is actually quite simple.

• Check whether it is background
• If it is a background process, kill the process, otherwise execute the default crash handling

Check whether it is background. Here we use the number of Activities in the process as the judgment standard

• When activity onStart, activityCount increases automatically
• When Activity onStop, activityCount is decremented
• When activityCount is 0, we consider the application to be in the background state

The specific implementation is as follows:

 object ActivityLifecycleCallbackImp: Application.ActivityLifecycleCallbacks {
 var activityCount: Int = 0
   override fun onActivityPaused(activity: Activity?) {
 } 
 
   override fun onActivityResumed(activity: Activity?) {
 } 
 
   override fun onActivityStarted(activity: Activity?) {
 activityCount++
 } 
 
   override fun onActivityDestroyed(activity: Activity?) {
 } 
 
   override fun onActivitySaveInstanceState(activity: Activity?, outState: Bundle?) {
 } 
 
   override fun onActivityStopped(activity: Activity?) {
 activityCount --  
 } 
 
   override fun onActivityCreated(activity: Activity?, savedInstanceState: Bundle?) {
 }
 }

Register in Application:

 class MyApplication : Application() {
 override fun onCreate() {
 super.onCreate()
       registerActivityLifecycleCallbacks(ActivityLifecycleCallbackImp)
 }
 }

All that's left is to set up a custom uncaught exception handler:

 val defaultHandler = Thread.getDefaultUncaughtExceptionHandler()
 Thread.setDefaultUncaughtExceptionHandler { thread, exception ->
   exception.printStackTrace()
   val isBackground = ActivityLifecycleCallbackImp.activityCount == 0
 if (isBackground) {
       Log.d( "MyApplication" , "isBackground just kill the process without annoying users" )
       android.os.Process.killProcess(android.os.Process.myPid())
 } else {
       defaultHandler.uncaughtException(thread, exception)
 }
 }

This function has been basically realized. Compared with the previous rigid dialog box, it is much more friendly to kill the process silently in the background without interfering with the user.