Application中ActivityLifecycleCallbacks的原理分析

ActivityLifecycleCallbacks是Application中的一個接口，既然是在Application中，不得不說說Application類，別急，一個個來說道說道

ActivityLifecycleCallbacks接口，如下：

    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);
    }

有很多方法聲明，仔細一看，很熟悉啊，沒錯，這些方法與Activity的整個生命週期相關，而且，通過命名，可以大體猜測，這些方法會在Activity週期方法調用完後被執行

接下來，看看Application中還有哪兒些與ActivityLifecycleCallbacks相關的，代碼如下：

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

    public void unregisterActivityLifecycleCallbacks(ActivityLifecycleCallbacks callback) {
        synchronized (mActivityLifecycleCallbacks) {
            mActivityLifecycleCallbacks.remove(callback);
        }
    }

這裏，兩個方法，一個註冊ActivityLifecycleCallbacks，一個反註冊ActivityLifecycleCallbacks，還有一個mActivityLifecycleCallbacks，可以看出是個成員變量

在Application中定義mActivityLifecycleCallbacks，代碼如下：

private ArrayList<ActivityLifecycleCallbacks> mActivityLifecycleCallbacks = new ArrayList<ActivityLifecycleCallbacks>();

繼續閱讀，會發現如下方法：

    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);
            }
        }
    }

    void dispatchActivityStarted(Activity activity) {
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i=0; i<callbacks.length; i++) {
                ((ActivityLifecycleCallbacks)callbacks[i]).onActivityStarted(activity);
            }
        }
    }

    void dispatchActivityResumed(Activity activity) {
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i=0; i<callbacks.length; i++) {
                ((ActivityLifecycleCallbacks)callbacks[i]).onActivityResumed(activity);
            }
        }
    }

    void dispatchActivityPaused(Activity activity) {
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i=0; i<callbacks.length; i++) {
                ((ActivityLifecycleCallbacks)callbacks[i]).onActivityPaused(activity);
            }
        }
    }

    void dispatchActivityStopped(Activity activity) {
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i=0; i<callbacks.length; i++) {
                ((ActivityLifecycleCallbacks)callbacks[i]).onActivityStopped(activity);
            }
        }
    }

    void dispatchActivitySaveInstanceState(Activity activity, Bundle outState) {
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i=0; i<callbacks.length; i++) {
                ((ActivityLifecycleCallbacks)callbacks[i]).onActivitySaveInstanceState(activity,
                        outState);
            }
        }
    }

    void dispatchActivityDestroyed(Activity activity) {
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i=0; i<callbacks.length; i++) {
                ((ActivityLifecycleCallbacks)callbacks[i]).onActivityDestroyed(activity);
            }
        }
    }

以上這些方法，都有個共同點，就是調用了collectActivityLifecycleCallbacks方法，而且遍歷callbacks，類型轉換爲ActivityLifecycleCallbacks，回調其方法

collectActivityLifecycleCallbacks方法做了什麼呢？將list轉化爲數組，代碼如下：

   private ArrayList<ComponentCallbacks> mComponentCallbacks = new ArrayList<ComponentCallbacks>(); 
   private Object[] collectComponentCallbacks() {
        Object[] callbacks = null;
        synchronized (mComponentCallbacks) {
            if (mComponentCallbacks.size() > 0) {
                callbacks = mComponentCallbacks.toArray();
            }
        }
        return callbacks;
    }

那麼問題來了，Applicatipn中的dispatchActivityXXX的這些方法，是誰調用呢？

如果對Activity源碼瞭解的話，很容易發現如下代碼：

    protected void onCreate(@Nullable Bundle savedInstanceState) {
        //省略
<pre name="code" class="java">        getApplication().dispatchActivityCreated(this, savedInstanceState);

//... }

    protected void onStart() {
        //...
        getApplication().dispatchActivityStarted(this);
    }

    protected void onResume() {
        //...
        getApplication().dispatchActivityResumed(this);
        //...
    }

onPause()，onStop()，onDestroy()，同樣調用getApplication().dispatchActivityPaused(this)

整理整個執行過程：

        需要定義一個類A，實現ActivityLifecycleCallbacks，並且實現接口方法

        registerActivityLifecycleCallbacks註冊類A對象，

        系統調用Activity的attach方法，綁定Application上下文，

        系統調用Activity生命週期方法，相應的調用Application中的dispatchActivityXXX方法，dispatchActivityXXX方法內部，回調A對象中方法的具體實現，從而完成，對Activity生命週期完整的跟蹤監聽

優點：官方提供對Activity生命週期的統一監聽，避免代碼在某類中的顯示調用