The most elegant way to exit an Android app

[[185951]]

Let's first look at some common exit methods (inelegant ways)

1. Container Type

Create a global container to store all Activities, and loop through all Activities when exiting

 import java.util.ArrayList;
 import java.util.List;
 import android.app.Activity;
 import android.os.Bundle;
 public class BaseActivity extends Activity {
 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 // Add Activity to the stack
 AtyContainer.getInstance().addActivity(this);
 }
 @Override
 protected void onDestroy() {
 super.onDestroy();
 // End the Activity & remove it from the stack
 AtyContainer.getInstance().removeActivity(this);
 }
 }
 class AtyContainer {
 private AtyContainer() {
 }
 private static AtyContainer instance = new AtyContainer();
 private static List activityStack = new ArrayList();
 public   static AtyContainer getInstance() {
 return instance;
 }
 public void addActivity(Activity aty) {
 activityStack.add (aty) ;
 }
 public void removeActivity(Activity aty) {
 activityStack.remove(aty);
 }
 /**
 * End all Activities
 */
 public void finishAllActivity() {
 for ( int i = 0, size = activityStack. size (); i if ( null != activityStack.get(i)) {
 activityStack.get(i).finish();
 }
 }
 activityStack.clear();
 }
 }

This method is relatively simple, but you can see that activityStack holds a strong reference to the Activity, which means that when an Activity exits abnormally, activityStack does not release the reference immediately, which will cause memory problems. Next, let's look at a similar method, but it will be a little more elegant.

2. Broadcast

By registering a broadcast in BaseActivity, a broadcast is sent when exiting, and finish exiting

 public class BaseActivity extends Activity {
 private static final String EXITACTION = "action.exit" ;
 private ExitReceiver exitReceiver = new ExitReceiver();
 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 IntentFilter filter = new IntentFilter();
 filter.addAction(EXITACTION);
 registerReceiver(exitReceiver, filter);
 }
 @Override
 protected void onDestroy() {
 super.onDestroy();
 unregisterReceiver(exitReceiver);
 }
 class ExitReceiver extends BroadcastReceiver {
 @Override
 public void onReceive(Context context, Intent intent) {
 BaseActivity.this.finish();
 }
 }
 }

3. Process

End the application by directly killing the current application process. It is simple, crude, and effective!

 android.os.Process.killProcess(android.os.Process.myPid());
 System.exit(0);
 ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
 manager.killBackgroundProcesses(getPackageName());

All three methods can achieve the same effect, but on the simulator, a message box "Unfortunately, XXX has stopped" will pop up, but the app can indeed be exited. Some real devices will fail directly and can only finish the current Activity (such as the Xiaomi Note in my hand. Several domestic ROM fw layers have too many changes, so use this method with caution)

4. RS Elegant Style

What is RS style? It is Receiver+singleTask. We know that there are four loading modes for Activity, and singleTask is one of them. After using this mode, when starting Activity, it will first query whether there is an instance of Activity in the current stack. If it exists, it will be placed on the top of the stack and all the Activities above it will be removed from the stack. When we open an app, the first thing is a splash page, and then the splash page will be finished. Jump to the home page. Then it will jump to the home page N times, during which an indefinite number of Activities will be generated, some of which will be destroyed, and some will reside in the stack, but the bottom of the stack will always be our HomeActivity. This makes the problem much simpler. We only need two steps to exit the app elegantly.

1. Register an exit broadcast in HomeActivity, which is the same as the second broadcast, but here you only need to register on one page of HomeActivity.

2. Set the startup mode of HomeActivity to singleTask.

When we need to exit, we only need to startActivity(this,HomeActivity,class), and then send an exit broadcast. The above code will first remove all Activities above HomeActivity from the stack, and then receive the broadcast and finish itself. Everything is OK! No pop-up window, no need to consider model Rom adaptation. There will be no memory problem, it is so elegant and simple!

5. SingleTask Redesign

After communicating with some guys, many of them said that registering for broadcasting was a bit troublesome. The guy downstairs proposed a simpler way, and the idea was also very simple.

1. Set the loading mode of MainActivity to singleTask

2. Rewrite the onNewIntent method in MainActivity

3. Add an exit tag to the Intent when you need to exit

Since many friends are eager for source code, we will explain this method directly in the form of code.

The first step is to set the loading mode of MainActivity to singleTask

 android:launchMode= "singleTask"  

The second step is to rewrite the onNewIntent() method

 private static final String TAG_EXIT = "exit" ;
 @Override
 protected void onNewIntent(Intent intent) {
 super.onNewIntent(intent);
 if (intent != null ) {
 boolean isExit = intent.getBooleanExtra(TAG_EXIT, false );
 if (isExit) {
 this.finish();
 }
 }
 }

Step 3 Exit

 Intent intent = new Intent(this,MainActivity.class);
 intent.putExtra(MainActivity.TAG_EXIT, true );
 startActivity(intent);

6. Lazy Style

This method is simpler and only requires the following two steps

1. Set MainActivity as singleTask

2. Place the exit in MainActivity

We can see that many applications double-click the home button twice to exit the application, which is implemented in this way. Here is the source code for how to handle two consecutive clicks to exit private boolean mIsExit;

 @Override
 /**
 * Double-click the return key to exit
 */
 public boolean onKeyDown( int keyCode, KeyEvent event) {
 if (keyCode == KeyEvent.KEYCODE_BACK) {
 if (mIsExit) {
 this.finish();
 } else {
 Toast.makeText(this, "Press again to exit" , Toast.LENGTH_SHORT).show();
 mIsExit = true ;
 new Handler().postDelayed(new Runnable() {
 @Override
 public void run() {
 mIsExit = false ;
 }
 }, 2000);
 }
 return   true ;
 }
 return super.onKeyDown(keyCode, event);
 }