In-depth Analysis of Android Application Exit Mechanisms: Elegant Implementation Based on onBackPressed

Introduction

In Android application development, properly handling the behavior when users press the back key is crucial for enhancing user experience. Many developers attempt to implement application exit functionality by overriding the onBackPressed() method but often encounter issues where the app does not exit completely or displays blank pages. Based on a typical Q&A scenario, this article delves into the root causes of these problems and provides validated solutions.

Problem Analysis

In the original code, the developer uses an AlertDialog to prompt users for exit confirmation and calls finish() upon confirmation. However, this only closes the current Activity; if other Activities remain in the back stack, users may see blank pages or app icons. This stems from Android's Activity lifecycle and stack management mechanisms—the app does not terminate fully as long as Activities exist in the stack.

A more complex attempt involves using Intent.ACTION_MAIN and Intent.CATEGORY_HOME to launch the home screen, but this may cause the app to exit completely rather than run in the background, which does not meet certain scenario requirements.

Core Solution

The best answer (score 10.0) provides a systematic approach. First, ensure cleanup of the Activity stack: when launching the target Activity, use flags such as Intent.FLAG_ACTIVITY_NEW_TASK and Intent.FLAG_ACTIVITY_CLEAR_TASK. For example:

Intent launchNextActivity = new Intent(B.class, A.class);
launchNextActivity.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
launchNextActivity.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
launchNextActivity.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
startActivity(launchNextActivity);

This ensures the new Activity becomes the sole instance at the top of the stack, preventing background residue.

Second, implement elegant exit logic in onBackPressed():

private Boolean exit = false;
@Override
public void onBackPressed() {
    if (exit) {
        finish();
    } else {
        Toast.makeText(this, "Press Back again to Exit.", Toast.LENGTH_SHORT).show();
        exit = true;
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                exit = false;
            }
        }, 3 * 1000);
    }
}

This code uses a Handler to delay state reset, preventing accidental operations and ensuring safe exit upon rapid double-clicks.

Comparison of Supplementary Solutions

Other answers offer alternative approaches. For instance, using System.exit(0) forces process termination, but this may disrupt Android lifecycle management and is not recommended for regular scenarios. Meanwhile, moveTaskToBack(true) mimics home button behavior by moving the app to the background rather than exiting, suitable for apps requiring state retention.

Implementation Recommendations

Developers should choose solutions based on app needs: for apps requiring complete exit, prioritize stack cleanup with double-click confirmation; for apps needing background operation, consider moveTaskToBack(). Always avoid System.exit() to maintain system stability.

Conclusion

By properly managing the Activity stack and implementing user-friendly interaction logic, common issues in Android application exit can be resolved. The solutions in this article, based on best practices, balance functionality and user experience, providing reliable references for developers.