Android项目中Activity生命周期高效的管理方式

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的生命周期管理方式。