Activity生命週期的管理方式

  在我們的開發過程中，有時候要操作Activity的全域性生命週期，故我們需要儲存Activity的生命週期，以及進行管理。如何進行存放Activity的生命週期呢？
工具類下載地址：http://download.csdn.net/download/gl_mine_csdn/9937815

在Application中進行管理Activity

•   在此之前，我們需要知道Application下的一個介面和一個方法，通過這兩個進行管理Activity的生命週期。

 public interface ActivityLifecycleCallbacks {
        void
 
 onActivityCreated(Activity activity, Bundle savedInstanceState);
        void onActivityStarted(Activity activity);
        void onActivityResumed(Activity activity);
        void onActivityPaused(Activity activity);
        void onActivityStopped(Activity activity);
        void onActivitySaveInstanceState(Activity activity, Bundle outState);
        void
 
 onActivityDestroyed(Activity activity);
    }

 public void registerActivityLifecycleCallbacks(ActivityLifecycleCallbacks callback) {
        synchronized (mActivityLifecycleCallbacks) {
            mActivityLifecycleCallbacks.add(callback);
        }
    }

• 
    接下來我們便可以進行管理了，具體實現方式如下。

public
 
 class ActivityLifeCallbackManager implements Application.ActivityLifecycleCallbacks {
    public final List<WeakReference<Activity>> weakReferences = new LinkedList<WeakReference<Activity>>();
    private boolean isAppForeground;

    @Override
    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
        weakReferences.add(new WeakReference<Activity>(activity));
    }

    @Override
    public void onActivityStarted(Activity activity) {

    }

    @Override
    public void onActivityResumed(Activity activity) {
        isAppForeground = true;
    }

    @Override
    public void onActivityPaused(Activity activity) {
        isAppForeground = false;
    }

    @Override
    public void onActivityStopped(Activity activity) {
    }

    @Override
    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
    }

    @Override
    public void onActivityDestroyed(Activity activity) {
        final Iterator<WeakReference<Activity>> it = weakReferences.iterator();
        while (it.hasNext()) {
            final WeakReference<Activity> weakReference = it.next();
            if (weakReference.get() == null) {
                it.remove();
            } else if (weakReference.get() == activity) {
                it.remove();
            }
        }

    }

    public void finishAll() {
        final Iterator<WeakReference<Activity>> it = weakReferences.iterator();
        while (it.hasNext()) {
            final WeakReference<Activity> weakReference = it.next();
            final Activity activity = weakReference.get();
            if (activity != null) {
                activity.finish();
            }
        }
        weakReferences.clear();
    }

    public Activity getTopActivity() {
        if (weakReferences.size() > 0) {
            return weakReferences.get(weakReferences.size() - 1).get();
        } else {
            return null;
        }
    }

    public void popTopActivity() {
        final Iterator<WeakReference<Activity>> it = weakReferences.iterator();
        final WeakReference<Activity> weakReference = it.next();
        final Activity activity = weakReference.get();
        if (activity == null) {
            it.remove();
        } else {
            activity.finish();
        }
    }

    public boolean isAppForeground() {
        return isAppForeground;
    }
}

• 
    在Application的OnCreate()方法下進行註冊。

ActivityLifeCallbackManager mActivityLifeCallbackManager=new ActivityLifeCallbackManager();
registerActivityLifecycleCallbacks(mActivityLifeCallbackManager);

在BaseActivity中進行管理Activity

  在BaseActivity中進行管理Activity的生命週期是最常見的一種方式，下面簡單進行介紹一下做法。

public final class ActivityLifeCallbackManager {
    // 由於此佇列可能隨時新增，隨時刪除，隨時關閉，所以要同步
    private static ConcurrentLinkedQueue<FragmentActivity> activityList = new ConcurrentLinkedQueue<>();
    private static List<Fragment> fragmentList = new LinkedList<>();
    private static ActivityLifeCallbackManager instance;

    private CMYExitApplication() {
    }

    // 單例模式中獲取唯一的ExitApplication例項
    public static synchronized CMYExitApplication getInstance() {
        if (instance == null) {
            instance = new CMYExitApplication();
        }
        return instance;
    }

    public static boolean isTopActivity(Context ctx) {
        ActivityManager activityManager = (ActivityManager) ctx.getSystemService(Context.ACTIVITY_SERVICE);
        List<RunningTaskInfo> tasksInfo = activityManager.getRunningTasks(1);
        if (tasksInfo.size() > 0) {
            if (ctx.getPackageName().equals(tasksInfo.get(0).topActivity.getPackageName())) {
                return true;
            }
        }
        return false;
    }

    public void addFragment(Fragment fragment) {
        if (fragment != null) {
            fragmentList.add(fragment);
        }
    }

    public void removeFragment(Fragment fragment) {
        if (fragment != null) {
            fragmentList.remove(fragment);
        }
    }

    public void addActivity(FragmentActivity activity) {
        if (activity != null) {
            activityList.add(activity);
        }
    }

    public void removeActivity(Activity activity) {
        if (activity != null) {
            activityList.remove(activity);
        }
    }

    public void finishActivity(String className) {
        Activity target = null;
        for (Activity activity : activityList) {
            if (activity.getClass().getName().equals(className)) {
                target = activity;
            }
        }
        if (target != null)//只關閉最後一個 會執行destroy方法，而此方法中有removeActivity(activity)的方法
            target.finish();
    }

    /**
     * 此activity是否正在執行中
     *
     * @param className
     * @return
     */
    public boolean isExistActivity(String className) {
        for (Activity activity : activityList) {
            if (activity.getClass().getName().equals(className)) {
                return true;
            }
        }
        return false;
    }

    private void finishAllActivitie() {
        if (activityList != null) {
            for (Activity activity : activityList) {
                if (activity != null) {
                    activity.finish();
                }
            }
            activityList.clear();
        }
    }

    public String getTopActivity(Context ctx) {
        ActivityManager activityManager = (ActivityManager) ctx.getSystemService(Context.ACTIVITY_SERVICE);
        List<RunningTaskInfo> tasksInfo = activityManager.getRunningTasks(1);
        if (tasksInfo.size() > 0) {
            return ctx.getPackageName();
        }
        return "";
    }

    /**
     * 獲得最頂端的該類
     *
     * @param className
     * @return
     */
    public FragmentActivity getTopActivity(String className) {
        Iterator<FragmentActivity> iterator = activityList.iterator();
        FragmentActivity targetActivity = null;
        while (iterator.hasNext()) {
            FragmentActivity temp = iterator.next();
            if (temp.getClass().getName().equals(className)) {// 要倒序所以要不斷遍歷，直到最後一個
                targetActivity = temp;
            }
        }
        return targetActivity;
    }

    /**
     * 獲取指定的Fragment
     * @param className
     * @return
     */
    public Fragment getFragmentByName(String className) {
        Iterator<Fragment> iterator = fragmentList.iterator();
        Fragment targetActivity = null;
        while (iterator.hasNext()) {
            Fragment temp = iterator.next();
            if (temp.getClass().getName().equals(className)) {// 要倒序所以要不斷遍歷，直到最後一個
                targetActivity = temp;
            }
        }
        return targetActivity;
    }

    public void exitApp(int type) {

        finishAllActivitie();
        if (type == 1) {// 異常退出
     android.os.Process.killProcess(android.os.Process.myPid());
            System.exit(1);// 非0引數都可以非正常的方式結束虛擬機器
        }else {// 正常退出
         System.exit(0);// 非0引數都可以非正常的方式結束虛擬機器
         }
    }



}

• 
    在BaseActivity的OnCreate()方法下進行註冊。

 ActivityLifeCallbackManager.getInstance().addActivity(this);

  通過以上方式完全可以解決Activity的生命週期的管理問題。更高效的Activity的生命週期管理方式。