Android之退出多个Activty-CFANZ编程社区

一、使用链表把要退出的Activity实例保存起来，在要退出时，遍例这个链表，调用每个Activity的finish方法。

1、在应用程序的每个Activity里面的onCreate()或者onStart()里面把当前的的Activity加入该栈中（addActivity），在你需要退出activity的时候，调用下面对应的方法去销毁栈。

2、不过这样有一个问题，如果你的应用程序有很多个Activity，那么加栈的这个代码就要重复写很多次，为了偷懒，可以选择写一个Activity的子类（比如BaseActivity）,之后的该应用程序里的所有Activity都继承你写的

3、BaseActivity，在BaseActivity里面的onCreate()或者onStart()里面把当前的的Activity加入该栈中（addActivity），这样会省去很多代码的。（AppManager.getInstance().addActivity(this);）

import android.app.Activity;
import android.app.ActivityManager;
import android.content.Context;
import java.util.Stack;

    /**
     * app管理类 对应用的activity进行控制
     *
     * @author w
     */

    public class AppManager {

        private static AppManager manager;
        private Stack<Activity> activityStack;
        private AppManager() {
        }
        //单例
        public static AppManager getInstance() {

            if (manager == null) {
                synchronized (AppManager.class) {
                    if (manager == null) {
                        manager = new AppManager();
                    }
                }
            }
            return manager;
        }

        /**
         * 添加Activity到堆栈
         */
// Stack <Activity> activityStack;
        public void addActivity(Activity activity) {
            if (activityStack == null) {
                activityStack = new Stack<Activity>();
            }
            activityStack.add(activity);
        }

        /**
         * 获取当前Activity（堆栈中最后一个压入的）
         */
        public Activity currentActivity() {
            Activity activity = activityStack.lastElement();
            return activity;
        }

        /**
         * 结束当前Activity（堆栈中最后一个压入的）
         */
        public void finishActivity() {
            Activity activity = activityStack.lastElement();
            finishActivity(activity);
        }

        /**
         * 结束指定的Activity
         */
        public void finishActivity(Activity activity) {
            if (activity != null) {
                activityStack.remove(activity);
                activity.finish();
                activity = null;
            }
        }

        /**
         * 结束指定类名的Activity
         */
        public void finishActivity(Class<?> cls) {
            for (Activity activity : activityStack) {
                if (activity.getClass().equals(cls)) {
                    finishActivity(activity);
                }
            }
        }

        /**
         * 结束所有Activity
         */
        public void finishAllActivity() {
            for (int i = 0; i < activityStack.size(); i++) {
                if (null != activityStack.get(i)) {
                    activityStack.get(i).finish();
                }
            }
            activityStack.clear();
        }

        /**
         * 退出应用程序
         */
        public void AppExit(Context context) {
            try {
                finishAllActivity();
                ActivityManager activityMgr = (ActivityManager) context
                        .getSystemService(Context.ACTIVITY_SERVICE);
                activityMgr.killBackgroundProcesses(context.getPackageName());
                System.exit(0);
            } catch (Exception e) {
            }
        }
    }

二、可以使用广播，每个Activity中收到这个广播，自己把自己finish掉。

public abstract class EnterActivity extends BaseActivity {


    // 写一个广播的内部类，当收到动作时，结束activity
    private BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            unregisterReceiver(this); // 这句话必须要写要不会报错，不写虽然能关闭，会报一堆错
            ((Activity) context).finish();
        }
    };

    @Override
    public void onResume() {
        super.onResume();
        // 在当前的activity中注册广播
        IntentFilter filter = new IntentFilter();
        filter.addAction(Attribute.PAGENAME);
        registerReceiver(this.broadcastReceiver, filter); // 注册
    }

    /**
     * 关闭
     */
    public void close() {
        Intent intent = new Intent();
        intent.setAction(Attribute.PAGENAME); // 说明动作
        sendBroadcast(intent);// 该函数用于发送广播
        finish();
    }
}

最后的activity继承BaseActivity

三、可以在要退出Activity的onStart方法中加入以下code:

MyApplication mApp = (MyApplication)getApplication();
mApp.setExit(true);
finish();

四、假如Activity的启动顺序是：A->B->C->D,我们想在D中把所有的Acitivity都清理掉，那么做法是：

1、 A的Manifest.xml配置成android:launchMode="singleTop" ，D窗口打开A窗口的Intent加入标识Intent.FLAG_ACTIVITY_CLEAR_TOP，这样会把栈中B， C，D都清除掉，同时因为A是的启动模式是singleTop，不会调用onCreate，而是调用onNewIntent,这时判断intent的值，如果为Intent.FLAG_ACTIVITY_CLEAR_TOP，则把A finish掉，这样A，B，C，D都finish掉了。

2、如果Activity的启动顺序是：A->B->C->D，可以把A的起动模式设成singleTask，从D起动A,会把栈中位于A之上的Activity都kill掉，然后在A的onNewIntent中把A finish掉。

3、最好是加入标识，通过判断来执行，这样安全一点，也就是在D开启A的时候，加intent.setFlags(xxx);xxx为自定义int型常量，

Intent intent = new Intent(D.this, A.class);
intent.setFlags(9009);
startActivity(intent);

4、在A中的onNewIntent()里面判断，是要销毁整个应用程序的指令时才把自己finish掉。

@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    if(intent.getFlags()==9009){      
    finish();  
 }
}

-END