基础五：不在Application类里面如何对全部activity生命周期监听

直接上代码，解决的问题就是不在Application的onCreate里面注册Application.ActivityLifecycleCallbacks，如何做到监听全部的Activity生命周期变化，以及原理解析

---

主Application类，可以发现没做任何处理

public class MyApplication extends Application {
	
	@Override
	public void onCreate() {
        // TODO Auto-generated method stub
        super.onCreate();
        Log.d("hwj", "**MyApplication onCreate**");
    }
}

新建生命周期监听类

package com.hwj.util;

import android.app.Activity;
import android.app.Application;
import android.os.Bundle;
import android.util.Log;


public class AppDataGetUtil implements Application.ActivityLifecycleCallbacks{


    @Override
    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
        Log.d("hwj","**AppDataGetUtil onActivityCreated**" + activity.getClass().getSimpleName() + "**" + activity.getIntent().toString());
    }

    @Override
    public void onActivityStarted(Activity activity) {
        Log.d("hwj","**AppDataGetUtil onActivityStarted**" + activity.getClass().getSimpleName());
    }

    @Override
    public void onActivityResumed(Activity activity) {
        Log.d("hwj","**AppDataGetUtil onActivityResumed**" + activity.getClass().getSimpleName());
    }

    @Override
    public void onActivityPaused(Activity activity) {
        Log.d("hwj","**AppDataGetUtil onActivityPaused**" + activity.getClass().getSimpleName());
    }

    @Override
    public void onActivityStopped(Activity activity) {
        Log.d("hwj","**AppDataGetUtil onActivityStopped**" + activity.getClass().getSimpleName());
    }

    @Override
    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
        Log.d("hwj","**onActivitySaveInstanceState**" + activity.getClass().getSimpleName());
    }

    @Override
    public void onActivityDestroyed(Activity activity) {
        Log.d("hwj","**AppDataGetUtil onActivityDestroyed**" + activity.getClass().getSimpleName());
    }

    public void registerLifeCallBack(Application application){
        application.registerActivityLifecycleCallbacks(this);
    }
}

项目主启动Activity，在其onCreate方法中调用AppDataGetUtil 的registerLifeCallBack方法，完成对全部Activity的注册

public class HwjMainActivity extends Activity{

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_hwj_main_layout);
		Application application = this.getApplication();
        AppDataGetUtil util = new AppDataGetUtil();
        util.registerLifeCallBack(application);
    }
}

代码很简单，只不过是改变原有的认知，只能在Application类注册才能监听activity的生命周期变化的误区；

---

下面说下原理：以如何监听Activity的onCreate生命周期为例，先看下Activity的onCreate方法

    protected void onCreate(@Nullable Bundle savedInstanceState) {
        /**省略代码**/
        getApplication().dispatchActivityCreated(this, savedInstanceState);       
        /**省略代码**/
    }

在我们调用Activity的onCreate方法的时候，就会调用Application的dispatchActivityCreated方法来完成回调

---

疑问1：这里的getApplication（）返回Applcaition是不是全局唯一，即是不是每次都new 一个Application？如果不是全局唯一，岂不是所有地方都要注册这个监听？

    /**Activity.java**/
    public final Application getApplication() {
        return mApplication;
    }

接着看下mApplication的赋值的地方

/**Activity.java**/
    final void attach(Context context, ActivityThread aThread,
            Instrumentation instr, IBinder token, int ident,
            Application application, Intent intent, ActivityInfo info,
            CharSequence title, Activity parent, String id,
            NonConfigurationInstances lastNonConfigurationInstances,
            Configuration config, IVoiceInteractor voiceInteractor) {
        /*省略代码*/
        mApplication = application;
       /*省略代码*/
    }

mApplication的赋值是在Activity的attach方法中，而attach的方法是在ActivityThread.java的performLaunchActivity方法中被调用的，至于为什么是performLaunchActivity，请参考Activity启动过程

    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        
    /*省略代码*/
        try {
            Application app = r.packageInfo.makeApplication(false, mInstrumentation);
            /*省略代码*/
            activity.attach(appContext, this, getInstrumentation(), r.token,
                    r.ident, app, r.intent, r.activityInfo, title, r.parent,
                    r.embeddedID, r.lastNonConfigurationInstances, config,
                    r.voiceInteractor);
        }
    /*省略代码*/
    }

在performLaunchActivity方法中，调用的attach方法的参数app是由makeApplication方法得到的

    public Application makeApplication(boolean forceDefaultAppClass,
            Instrumentation instrumentation) {
        if (mApplication != null) {
            return mApplication;
        }

        Application app = null;

        String appClass = mApplicationInfo.className;
        if (forceDefaultAppClass || (appClass == null)) {
            appClass = "android.app.Application";
        }

        try {
            java.lang.ClassLoader cl = getClassLoader();
            if (!mPackageName.equals("android")) {
                initializeJavaContextClassLoader();
            }
            ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
            app = mActivityThread.mInstrumentation.newApplication(
                    cl, appClass, appContext);
            appContext.setOuterContext(app);
        } catch (Exception e) {
            if (!mActivityThread.mInstrumentation.onException(app, e)) {
                throw new RuntimeException(
                    "Unable to instantiate application " + appClass
                    + ": " + e.toString(), e);
            }
        }
        mActivityThread.mAllApplications.add(app);
        mApplication = app;
        /*省略代码*/
        return app;
    }

这个方法的主要作用有两个
1：如果有全局Application变量，则返回此变量；因此我们可以回答疑问1了，即Activity.java调用的getApplication（）返回Applcaition是全局唯一的，我们不需要在每次都注册监听
2：第一次启动的时候，mApplication为空，就通过mActivityThread.mInstrumentation.newApplication方法完成mApplication对象的创建，我们查看newApplication方法可知

    static public Application newApplication(Class<?> clazz, Context context)
            throws InstantiationException, IllegalAccessException, 
            ClassNotFoundException {
        Application app = (Application)clazz.newInstance();
        app.attach(context);
        return app;
    }

Application 对象的创建是通过反射机制的newInstance来实现的

---

接着我们看Appliation.java的dispatchActivityCreated方法

    /* package */ void dispatchActivityCreated(Activity activity, Bundle savedInstanceState) {
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i=0; i<callbacks.length; i++) {
                ((ActivityLifecycleCallbacks)callbacks[i]).onActivityCreated(activity,
                        savedInstanceState);
            }
        }
    }

可以看出这是一个protect的方法，主要功能就是回调onActivityCreated方法

---

总结下：
1：注册ActivityLifecycleCallbacks接口，这个动作主要就是在mActivityLifecycleCallbacks这个list里面添加mActivityLifecycleCallbacks接口实例
2：Activity在调用onCreate方法的时候，调用Application的dispatchActivityCreated方法
3：dispatchActivityCreated方法回调onActivityCreated方法，因此所有的Activity的onCreate生命周期便会检测到