点滴记录 -- 自定义Activity栈 之 如何出栈

自定义Activity栈

首先自定义一个 ActivityManage

第一种 ActivityManage

 感谢  http://www.360doc.com/content/14/0916/15/16319846_409925799.shtml  

     public class ScreenManager {
    private static Stack<Activity> activityStack;
    private static ScreenManager instance;

    private ScreenManager() {
    }

    public static ScreenManager getScreenManager() {
        if (instance == null) {
            instance = new ScreenManager();
        }
        return instance;
    }

     public static void popActivity() {
        Activity activity = activityStack.lastElement();
        if (activity != null) {
            activity.finish();
            activity = null;
        }
    }

    // 退出栈顶Activity
    public void popActivity(Activity activity) {
        if (activity != null) {
            activity.finish();
            activityStack.remove(activity);
            activity = null;
        }
    }

    // 获得当前栈顶Activity
    public Activity currentActivity() {
        Activity activity = activityStack.lastElement();
        return activity;
    }

    // 将当前Activity推入栈中
    public static void pushActivity(Activity activity) {
        if (activityStack == null) {
            activityStack = new Stack<Activity>();
        }
        activityStack.add(activity);
    }

    // 退出栈中所有Activity
    public void popAllActivityExceptOne(Class cls) {
        while (true) {
            Activity activity = currentActivity();
            if (activity == null) {
                break;
            }
            if (activity.getClass().equals(cls)) {
                break;
            }
            popActivity(activity);
            }
        }
    }

第二种 ActivityManage

感谢好友 开发-北京-噢耶
public class AppManager {

    private static Stack<Activity> activityStack;
    private static AppManager instance;

    private AppManager() {
    }

    /**
     * 单一实例
     */
    public static AppManager getAppManager() {
        if (instance == null) {
            instance = new AppManager();
        }
        return instance;
    }

    /**
     * 添加Activity到堆中
     */
    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实例
     * 
     * @param cls
     * @return
     */
    public Activity getActivity(Class<?> cls) {
        for (Activity activity : activityStack) {
            if (activity.getClass().equals(cls)) {
                return activity;
            }
        }
        return null;
    }

    /**
     * 结束当前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);
//          }
//      }
         Iterator<Activity> itr = activityStack.iterator();  
         while(itr.hasNext()){
             Activity activity = itr.next();
             if(activity.getClass().equals(cls)){
                 itr.remove();
                 activity.finish();
                 activity = null;
             }
         }
    }

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

第三种 ActivityManage

public class FQYActivityManage {

    private static FQYActivityManage manage;
    private static Stack<Activity> activityStack;

    private FQYActivityManage() {

    }

    /**
     * 得到一个 FQYActivityManage 对象
     * 
     * @return
     */
    public static FQYActivityManage getFQYActivityManage() {
        // 保证只有一个 FQYActivityManage对象
        if (manage == null) {
            manage = new FQYActivityManage();
        }
        return manage;
    }

    /**
     * 获得当前栈顶的activity
     * 
     * @return
     */
    public Activity getCurrentStackTopActivity() {
        Activity activity = null;
        if (!activityStack.empty()) {
            activity = activityStack.lastElement();
        }
        return activity;
    }

    /**
     * 将新的activity 压栈
     * 
     * @param activity
     */
    public void pushActivity(Activity activity) {
        if (activityStack == null) {
            activityStack = new Stack<Activity>();
        }
        activityStack.add(activity);

        FQYLogUtils.e("push入栈 " + activity.toString());
    }

    /**
     * 退出栈顶 activity
     */
    public void pullActivity() {

        Activity lastElement = null;

        if (!activityStack.empty()) {
            lastElement = activityStack.lastElement();

            FQYLogUtils.e("pull出栈 " + lastElement.toString());

            lastElement.finish();
            activityStack.remove(lastElement);
        }
    }

    /**
     * 关闭应用程序
     */
    public void pullAllActivity() {
        int size = activityStack.size();
        for (int i = 0; i < size; i++) {
            pullActivity();
            size--;
        }

    }



}

第三种是我自己写的，这里以第三种为例继续下文，先来段题外话，网上好多第一种，但是我对popAllActivityExceptOne 很困惑，注释写的是“退出栈中所有Activity”，但是方法名（popAllActivityExceptOne）和 方法体都是保留一个指定的activity，不明白这样做的目的和用法，求指点

言归正传 ，继续主题。

重写一个Application

主要是为了方便管理activityManage（我是这么理解的，不对请指正）

public class FQYApplication extends Application {

    protected FQYActivityManage activityManage;



    @Override
    public void onCreate() {
        super.onCreate();

        activityManage = FQYActivityManage.getFQYActivityManage();

    }

    public FQYActivityManage getActivityManage() {
        return activityManage;
    }

    public void setActivityManage(FQYActivityManage activityManage) {
        this.activityManage = activityManage;
    }

}

写一个baseActivity 或者 直接使用

看看baseactivity

public class BaseActivity extends FragmentActivity {

    protected Context baseContext;

    protected FQYActivityManage activityManage;

    @Override
    protected void onCreate(Bundle arg0) {
        super.onCreate(arg0);
        baseContext = this;
        // 去除标题栏
        requestWindowFeature(Window.FEATURE_NO_TITLE);

        activityManage = ((FQYApplication) this.getApplication())
                .getActivityManage();
        activityManage.pushActivity(this);

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
    }

    @Override
    public void onBackPressed() {
        super.onBackPressed();
    }

}

Ps： 不要在baseactivity 中执行出栈，想知道为什么？你可以试验一下。

接下来就是如何出栈了

出栈在baseactivity 的子类中执行 ，子类有FQYActivityManage的对象 activityManage（baseactivity 中 protected FQYActivityManage activityManage; ），只须在需要出栈的地方 activityManage.pullActivity(); 就可以了，相信直接使用你也会了吧？