Activity和Fragment的回退

一.Fragment的回退

1 2 3 4 5 6 7

int  num = getActivity().getSupportFragmentManager().getBackStackEntryCount(); String numString =  "++++++++++++++++++++++++++++++++++Fragment回退栈数量：" +num; TALogger.d( "Fragment" , numString); for  ( int  i =  0 ; i < num; i++) {      BackStackEntry backstatck = getActivity().getSupportFragmentManager().getBackStackEntryAt(i);      TALogger.d( "Fragment" , backstatck.getName()); }

最后一步是调用：

1	getActivity().getSupportFragmentManager().popBackStackImmediate(CreateGroupNameFragment. class .getName(), FragmentManager.POP_BACK_STACK_INCLUSIVE);

即弹出Tag为CreateGroupNameFragment之上的所有（包括自身）的Fragment。

popBackStackImmediate(name,flag);

第二个参数：只能是 0 或者 1（POP_BACK_STACK_INCLUSIVE）；

第一个参数为null时，第二个参数为0时：

会弹出回退栈中最上层的那一个fragment。

因为经测试，回退栈中的fragment个数减少了一个。

第二个参数为1时：

会弹出所有回退栈中的fragment。

因为经测试，回退栈中的fragment个数变为0了。

二.Activity清除栈

   我们知道Android的窗口类提供了历史栈，我们可以通过stack的原理来巧妙的实现，这里我们在A窗口打开B窗口时在Intent中直接加入标 志     Intent.FLAG_ACTIVITY_CLEAR_TOP，这样开启B时将会清除该进程空间的所有Activity。

在A窗口中使用下面的代码调用B窗口

     
     
Intent intent = new Intent(); 
intent.setClass(Android123.this, CWJ.class); 
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);  //注意本行的FLAG设置 
startActivity(intent);

接下来在B窗口中需要退出时直接使用finish方法即可全部退出。

A - B - C

当 B - A - B 跳转的时候，使用Intent的FLAG_ACTIVITY_CLEAR_TOP会让第一个B和第二个A，destory掉

但是当B - A - C跳转的时候不会调用B和A的destory

其实这个问题以前遇到过，今天遇到的时候又忘记了。查看API文档才发现原因，所以这里记录一下避免下次又忘记了

文档上说，如果设置这个属性，是当要启动的Activity已经存在当前Task中，才会在启动的时候销毁其他的Activity。

所以上面当A跳C的时候不满足此条件。

当然如果你想实现这个效果可以使用：

it.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_CLEAR_TASK);(注:API11)

        关掉自己

在activity加入代码：

[java] view plaincopy

1. Override  
2. protected void onNewIntent(Intent intent) {  
3. // TODO Auto-generated method stub  
4. super.onNewIntent(intent);  
5. //退出  
6.  if ((Intent.FLAG_ACTIVITY_CLEAR_TOP & intent.getFlags()) != 0) {  
7.  finish();  
8.  }  
9. }

原理总结：
一般A是程序的入口点，从D起一个A的activity，加入标识Intent.FLAG_ACTIVITY_CLEAR_TOP这个过程中会把栈中B，C，都清理掉。因为A是android:launchMode="singleTop"
不会调用oncreate(),而是响应onNewIntent（）这时候判断Intent.FLAG_ACTIVITY_CLEAR_TOP，然后把A finish（）掉。
栈中A,B,C,D全部被清理。所以整个程序退出了。

三.自定义activity栈管理

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

	不过这样有一个问题，如果你的应用程序有很多个Activity，那么加栈的这个代码就要重复写很多次，为了偷懒，可以选择写一个Activity的子类（比如BaseActivity）,之后的该应用程序里的所有Activity都继承你写的
BaseActivity，在BaseActivity里面的onCreate()或者onStart()里面把当前的的Activity加入该栈中（addActivity），这样会省去很多代码的。（AppManager.getInstance().addActivity(this);）
private LinkedList<Activity> activityList = new LinkedList<>();


public void addActivity(Activity activity) {
    activityList.add(activity);
}

public void removeActivity(Activity activity) {
    mActivities.remove(activity);
}

public void finishAll() {
    for (Activity act : activityList) {
        act.finish();
    }
}
/**
 * 获取当前处于栈顶的activity，无论其是否处于前台
 */
public static Activity getCurrentActivity() {
    List<Activity> copy;
    synchronized (mActivities) {
        copy = new ArrayList<Activity>(mActivities);
    }
    if (copy.size() > 0) {
        return copy.get(copy.size() - 1);
    }
    return null;
}
public synchronized static AppContext getInstance() {
    return mApplication;
}
在baseactivity中实例化
AppContext.getInstance().mActivities.add(this);

      
      

       
       
        
        
import android.app.Activity;
import android.app.ActivityManager;
import android.content.Context;
import java.util.Stack;
/**
 * app管理类 对应用的activity进行控制
 *
 * @author Huangnan
 */
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) {
        }
    }
}