1. Container (classical)

(1) Create an ActivityCollector.java that is used as a public class for collecting and destroying activities.

1. public class ActivityCollector {    
2.     
3.     public static List<Activity> activities = new ArrayList<Activity>();    
4.     
5.     public static void addActivity(Activity activity) {    
6.         activities.add(activity);    
7.     }    
8.     
9.     public static void removeActivity(Activity activity) {    
10.         activities.remove(activity);    
11.     }    
12.     
13.     public static void finishAll() {    
14.         for (Activity activity : activities) {    
15.             if (!activity.isFinishing()) {    
16.                 activity.finish();    
17.             }    
18.         }    
19.     }    
20.     
21. }    

(2). Create a BaseActivity. Java Base class, inherited by all activities in the project.

1. public class BaseActivity extends Activity {    
2.     
3.     @Override    
4.     protected void onCreate(Bundle savedInstanceState) {    
5.         // TODO Auto-generated method stub    
6.         super.onCreate(savedInstanceState);    
7.         ActivityCollector.addActivity(this);    
8.     }    
9.     
10.     @Override    
11.     protected void onDestroy() {    
12.         // TODO Auto-generated method stub    
13.         super.onDestroy();    
14.         ActivityCollector.removeActivity(this);    
15.     }    

(3).How do I need to destroy all at once somewhere activity,Just call ActivityCollector.java In finishAll()Method.
     For example, in app Any interface call in loginout Method,It needs to be used once kill Multiple activity:

1. ActivityCollector.finishAll();   

This method is simple, but you can see that activityStack holds strong references to this Activity, that is, when an Activity exits abnormally, activityStack does not even release references, which can cause memory problems. Next, let's look at a similar method, but it's a little elegant

finish quits by registering a broadcast in BaseActivity and sending a broadcast when quitting

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();
        }

    }

What is RS?That is Receiver+singleTask.We know that there are four loading modes for an activity, and singleTask is one of them. After using this mode, when startActivity is used, it first queries the current stack for instances of the activity, if it exists, moves it to the top of the stack and removes all activities above it.We open an app, start with a splash page, and then finish off the splash page.Jump to the home page.Then there will be N jumps on the home page, during which there will be a variable number of activities, some destroyed, some resident on the stack, but the bottom of the stack will always be our Home Activity.This makes the problem much simpler.We can gracefully implement an app exit in just two steps.
1. Register an exit broadcast in HomeActivity, just like 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 just need to start the Activity (this, HomeActivity, class) and send another exit broadcast.The code above first removes all the activities above the HomeActivity from the stack and receives the broadcast finish itself.All OK There are no bouncing boxes, no need to consider the model Rom adapter.No memory problems, it's so elegant and simple!