2. 程式人生 > >Android-Lifecycle超能解析-生命週期的那些事兒

Android-Lifecycle超能解析-生命週期的那些事兒

阿新 • • 發佈：2018-12-10

本文篇幅較長，請大家耐心閱讀。

  • Lifecycle是什麼？

Lifecycle是一個生命週期感知元件，一般用來響應Activity、Fragment等元件的生命週期變化，並將變化通知到已註冊的觀察者。有助於更好地組織程式碼，讓程式碼邏輯符合生命週期規範，減少記憶體洩漏，增強穩定性。

Lifecycle已經納入新版本的AppCompatActivity和Fragment中了，並且Lifecycle還是Android Jetpack中其他兩個元件LiveData和ViewModel的基礎，意味著這個庫可能將持續伴隨著我們後續的開發，因此有什麼理由不學習一番呢?

按照國際規範，我們先講使用，後解析原始碼。

一、使用

1.新增依賴：

在app或者module目錄下的build.gradle中，新增依賴：

dependencies {
    ......
    implementation "android.arch.lifecycle:runtime:1.1.1"
    implementation "android.arch.lifecycle:extensions:1.1.1"
    // 如果你使用java8開發，可以新增這個依賴，裡面只有一個類
    implementation "android.arch.lifecycle:common-java8:1.1.1"
}

2.實現LifecycleObserver介面

public class Java7Observer implements LifecycleObserver {
    private static final String TAG = Java7Observer.class.getSimpleName();

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() { Log.d(TAG, "onCreate"); }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart() { Log.d(TAG, "onStart"); }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() { Log.d(TAG, "onResume"); }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause() { Log.d(TAG, "onPause"); }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() { Log.d(TAG, "onStop"); }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() { Log.d(TAG, "onDestroy"); }
}

首先，我們需要實現LifecycleObserver這個介面，然後在我們的方法上加上@OnLifecycleEvent註解，註解值表示該方法對應生命週期的哪個函式，這裡我們把所有生命週期函式都加上了，並簡單地列印了一句Log。

我想有人會問，為什麼這個class要命名Java7Observer ？ 沒錯，因為Java8中，官方推薦用另外一種方式：

public class Java8Observer implements DefaultLifecycleObserver {
    private static final String TAG = Java8Observer.class.getSimpleName();

    @Override
    public void onCreate(@NonNull LifecycleOwner owner) { Log.d(TAG, "onCreate"); }

    @Override
    public void onStart(@NonNull LifecycleOwner owner) { Log.d(TAG, "onStart"); }

    @Override
    public void onResume(@NonNull LifecycleOwner owner) { Log.d(TAG, "onResume"); }

    @Override
    public void onPause(@NonNull LifecycleOwner owner) { Log.d(TAG, "onPause"); }

    @Override
    public void onStop(@NonNull LifecycleOwner owner) { Log.d(TAG, "onStop"); }

    @Override
    public void onDestroy(@NonNull LifecycleOwner owner) { Log.d(TAG, "onDestroy"); }
}

理由很簡單，Lifecycle原始碼中有一段註釋：

/* .....
 * </pre>
 * If you use <b>Java 7 Language</b>, Lifecycle events are observed using annotations.
 * Once Java 8 Language becomes mainstream on Android, annotations will be deprecated, so between
 * {@link DefaultLifecycleObserver} and annotations,
 * you must always prefer {@code DefaultLifecycleObserver}.
 * <pre>
 * ......
 */

翻譯一下就是：“如果你丫的用的是java7，那你就用註解唄，但是我告訴你，一旦java8上位了，你那些註解就過時了，我勸你最好用DefaultLifecycleObserver”

3.將LifecycleObserver新增到Lifecycle的觀察者列表

如果你使用新版本的AppcompatActivity（>26.1.0），可以這麼寫：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // 直接呼叫getLifecycle()，新增Observer
        getLifecycle().addObserver(new Java7Observer());
        getLifecycle().addObserver(new Java8Observer());
    }
}

如果你的AppCompatActivity沒有更新到最新，那麼你需要自實現LifecycleOwner介面，並在Activity生命週期函式中分發事件

public class MainActivity extends Activity implements LifecycleOwner {
    private LifecycleRegistry mLifecycleRegistry;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mLifecycleRegistry = new LifecycleRegistry(this);
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
        mLifecycleRegistry.addObserver(new TestObserver());
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }

    @Override
    public void onStart() {
        super.onStart();
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
    }

    @Override
    public void onResume() {
        super.onResume();
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
    }

    @Override
    public void onPause() {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
        super.onPause();
    }

    @Override
    public void onStop() {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
        super.onStop();
    }

    @Override
    public void onDestroy() {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
        super.onDestroy();
    }
}

ok，完事兒了，咱們跑起來看一哈，已經成功和生命週期關聯上了。

能舉個熟悉點的例子嗎？

MVP想必大家都用過，或者聽說過，View層通過Presenter層和Model層進行通訊，因此Presenter層如果做了什麼超出View生命週期的事，又沒有及時釋放記憶體，就會造成記憶體洩漏。

所以，原來的Presenter，為了響應生命週期，我們可能會這麼寫：

先定義所有的生命週期函式

public class MainPresenter {
    public void onCreate() { }
    public void onStart() { }
    public void onResume() { }
    public void onPause() { }
    public void onStop() { }
    public void onDestroy() { }
}

然後再與Activity生命週期一一繫結，如果有多個類似的需要響應生命週期的類，Activity的生命週期函式就會變得非常臃腫

public class MainActivity extends AppCompatActivity {
    private MainPresenter mPresenter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mPresenter = new MainPresenter();
        mPresenter.onCreate();
    }

    @Override
    protected void onResume() {
        super.onResume();
        mPresenter.onCreate();
        // VideoPlayer.onResume();
        // ...
    }

    @Override
    protected void onStart() {
        super.onStart();
        mPresenter.onStart();
        // VideoPlayer.onStart();
        // ...
    }

    @Override
    protected void onPause() {
        super.onPause();
        mPresenter.onPause();
        // VideoPlayer.onPause();
        // ...
    }

    @Override
    protected void onStop() {
        super.onStop();
        mPresenter.onStop();
        // VideoPlayer.onStop();
        // ...
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mPresenter.onDestroy();
        // VideoPlayer.onDestroy();
        // ...
    }
}

因此，Lifecycle就是為了解決這個痛點，將生命週期的響應分發到各個觀察者中去，我們只需要在Activity中呼叫一行程式碼：

getLifecycle().addObserver(mPresenter);

程式碼量蹭蹭就下來了。諸如音視訊播放、圖片載入，這些吃記憶體大戶，都應該響應生命週期，及時釋放記憶體，否則很可能就會造成OOM。

二、知其然，還得知其所以然

在專案中引入一個庫，卻不懂是怎麼實現的，是一件非常危險的行為，因此我們不僅要學會怎麼用，還得知道其中的原理。

先看一張官方的圖：

lifecycle-states

可以看到兩個很顯眼的單詞：State和Event，這也是貫穿整個Lifecycle的兩個概念：狀態和事件。

Lifecycle將Activity的生命週期函式對應成State，生命週期改變，會造成State改變，而State變化將觸發Event事件，從而被LifecycleObser接收。

  • State：狀態，是Lifecycle中對應Activity生命週期的一種狀態標識，從圖中可以看到，它有INITIALIZED、DESTROYED、CREATED、STARTED、RESUMED這5中狀態。

    • INITIALIZED：對應Activity的onCreate之前的生命週期
    • DESTROYED：對應Activity的onDestroy
    • CREATED：對應Activity的onCreate到onStop之間的生命週期
    • STARTED：對應Activity的onStart到onPause之間的生命週期
    • RESUMED：對應Activity的onResume
  • Event：事件，當State發生變化時，Lifecycle會向已註冊的LifecycleObserver傳送事件，例如：當State從INITIALIZED變化到CREATED時，就會發出ON_CREATE事件。

因此，弄懂Lifecycle，其實也就是需要弄懂兩件事：

  1. State是如何與Activity/Fragment的生命週期繫結的？
  2. Event事件是如何分發到LifecycleObserver的？

ok，帶著這兩個問題，我們開始看原始碼：

1.從AppCompatActivity的getLifecycle()開始

直接ctrl+左鍵跟進原始碼，由於AppCompatActivity繼承自SupportActivity，我們發現，AppCompatActivity.getLifecycle()，最終定位在了SupportActivity.getLifecycle()方法中

public class SupportActivity extends Activity implements LifecycleOwner {
    ......

    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
    }

    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }

    ......
}

不難看到：

  1. 最終getLifecycle()返回的是一個LifecycleRegistry 物件，所以所有對LifecycleObserver的操作都是由LifecycleRegistry 完成的
  2. 在onCreate()方法中，我們還看到了一個ReportFragment.injectIfNeededIn(this)，先做個標記，後面再說

2.LifecycleRegistry

字面意思：生命週期登記處

這個類是Lifecycle中最重要的一個類，它是Lifecycle的子類，起著新增觀察者，響應生命週期事件，分發生命週期事件的作用

public class LifecycleRegistry extends Lifecycle {
    // LifecycleObserver Map，每一個Observer都有一個State
    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = new FastSafeIterableMap<>();
    // 當前的狀態
    private State mState;
    // 生命週期擁有者，上述的SupportActivity繼承了LifecycleOwner
    private final WeakReference<LifecycleOwner> mLifecycleOwner;

    public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        mLifecycleOwner = new WeakReference<>(provider);
        mState = INITIALIZED;
    }

    /**
    * 新增LifecycleObserver觀察者，並將之前的狀態分發給這個Observer,例如我們在onResume之後註冊這個Observer，
    * 該Observer依然能收到ON_CREATE事件
    */
    public void addObserver(@NonNull LifecycleObserver observer) {
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
        ......
        // 例如：Observer初始狀態是INITIALIZED，當前狀態是RESUMED，需要將INITIALIZED到RESUMED之間的
        // 所有事件分發給Observer
        // 
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            popParentState();
            targetState = calculateTargetState(observer);
        }
        ......
    }

    /**
     * 處理生命週期事件
     */
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next);
    }

    /**
     * 改變狀態
     */
    private void moveToState(State next) {
        if (mState == next) {
            return;
        }
        mState = next;
        ......
        sync();
        ......
    }

    /**
     * 同步Observer狀態，並分發事件
     */
    private void sync() {
        LifecycleOwner lfecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn't try dispatch "
                    + "new events from it.");
            return;
        }
        while (!isSynced()) {
            mNewEventOccurred = false;
            // State中，狀態值是從DESTROYED-INITIALIZED-CREATED-STARTED-RESUMED增大
            // 如果當前狀態值 < Observer狀態值，需要通知Observer減小狀態值，直到等於當前狀態值
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
            }
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            // 如果當前狀態值 > Observer狀態值，需要通知Observer增大狀態值，直到等於當前狀態值
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

    /**
     * 向前傳遞事件，對應圖中的INITIALIZED -> RESUMED
     * 增加Observer的狀態值，直到狀態值等於當前狀態值
     */
    private void forwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
                mObserverMap.iteratorWithAdditions();
        while (ascendingIterator.hasNext() && !mNewEventOccurred) {
            Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                pushParentState(observer.mState);
                // 分發狀態改變事件
                observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
                popParentState();
            }
        }
    }

    /**
     * 向後傳遞事件，對應圖中的RESUMED -> DESTROYED
     * 減小Observer的狀態值，直到狀態值等於當前狀態值
     */
    private void backwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
                mObserverMap.descendingIterator();
        while (descendingIterator.hasNext() && !mNewEventOccurred) {
            Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                Event event = downEvent(observer.mState);
                // 分發狀態改變事件
                pushParentState(getStateAfter(event));
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }
}

我們再看看新版AppCompatActivity是如何將事件分發給LifecycleRegistry的，還記得SupportActivity中有這麼一段邏輯嗎：

public class SupportActivity extends Activity implements LifecycleOwner {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
    }
}

我們看看ReportFragment是什麼

3.ReportFragment

public class ReportFragment extends Fragment {

    public static void injectIfNeededIn(Activity activity) {
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            manager.executePendingTransactions();
        }
    }

    @Override
    public void onStart() {
        super.onStart();
        dispatchStart(mProcessListener);
        dispatch(Lifecycle.Event.ON_START);
    }

    // ...... 其他生命週期也是同樣呼叫了dispatch(Lifecycle.Event.xxx)分發事件

    @Override
    public void onPause() {
        super.onPause();
        dispatch(Lifecycle.Event.ON_PAUSE);
    }

    private void dispatch(Lifecycle.Event event) {
        Activity activity = getActivity();
        if (activity instanceof LifecycleRegistryOwner) {
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }

        if (activity instanceof LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }
}

可以看到，SupportActivity添加了一個沒有頁面的ReportFragment，在ReportFragment的生命週期函式中，呼叫了LifecycleRegistry.handleLifecycleEvent()方法來分發生命週期事件。用一張圖總結一下就是：

AppCompatActivity中添加了一個ReportFragment，其生命週期變化時，呼叫LifecycleRegistry.handleLifecycleEvent()方法通知LifecycleRegistry改變狀態，LifecycleRegistry內部呼叫moveToState()改變狀態，並呼叫每個LifecycleObserver.onStateChange()方法通知生命週期變化。

  • 為什麼不直接在SupportActivity的生命週期函式中給Lifecycle分發生命週期事件，而是要加一個Fragment呢？
因為不是所有的頁面都繼承AppCompatActivity，為了相容非AppCompatActivity，所以封裝一個同樣具有生命週期的Fragment來給Lifecycle分發生命週期事件。
  • 那我們不繼承新版本AppCompatActivity時，Lifecycle是如何通過ReportFragment來分發生命週期事件的呢？
這裡我們直接使用AndroidStudio強大的搜尋功能，alt+F7搜尋ReportFragment的呼叫者，我們發現：除了SupportActivity以外，還有兩個地方使用到了ReportFragment：LifecycleDispatcher和ProcessLifecycleOwner

4.LifecycleDispatcher

字面意思：生命週期分發者

class LifecycleDispatcher {
    static void init(Context context) {
        ((Application) context.getApplicationContext())
            .registerActivityLifecycleCallbacks(new DispatcherActivityCallback());
    }

    /**
     * 給所有子Fragment設定State
     */
    private static void markState(FragmentManager manager, State state) {
        Collection<Fragment> fragments = manager.getFragments();
        if (fragments == null) {
            return;
        }
        for (Fragment fragment : fragments) {
            if (fragment == null) {
                continue;
            }
            markStateIn(fragment, state);
            if (fragment.isAdded()) {
                markState(fragment.getChildFragmentManager(), state);
            }
        }
    }

    private static void markStateIn(Object object, State state) {
        if (object instanceof LifecycleRegistryOwner) {
            LifecycleRegistry registry = ((LifecycleRegistryOwner) object).getLifecycle();
            registry.markState(state);
        }
    }

    // 通過註冊Application.registerActivityLifecycleCallbacks來獲取Activity的生命週期回撥
    static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks {
            @Override
            public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
                if (activity instanceof FragmentActivity) {
                    ((FragmentActivity) activity).getSupportFragmentManager()
                            .registerFragmentLifecycleCallbacks(mFragmentCallback, true);
                }
                // 給每個Activity新增ReportFragment
                ReportFragment.injectIfNeededIn(activity);
            }

            @Override
            public void onActivityStopped(Activity activity) {
                if (activity instanceof FragmentActivity) {
                    markState((FragmentActivity) activity, CREATED);
                }
            }

            @Override
            public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
                if (activity instanceof FragmentActivity) {
                    markState((FragmentActivity) activity, CREATED);
                }
            }
        }
}

可以看到LifecycleDispatcher是通過註冊Application.registerActivityLifecycleCallbacks來監聽Activity的生命週期回撥的。

  • 在onActivityCreated()中新增ReportFragment，將Activity的生命週期交給ReportFragment去分發給LifecycleRegistry
  • 在onActivityStopped()以及onActivitySaveInstanceState()中，將Activity及其所有子Fragment的State置為CREATED

5.ProcessLifecycleOwner

字面意思：執行緒生命週期擁有者

public class ProcessLifecycleOwner implements LifecycleOwner {
    public static LifecycleOwner get() { return sInstance; }

    static void init(Context context) {
        sInstance.attach(context);
    }

    void activityResumed() {
        mResumedCounter++;
        if (mResumedCounter == 1) {
            if (mPauseSent) {
                mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
                mPauseSent = false;
            } else {
                mHandler.removeCallbacks(mDelayedPauseRunnable);
            }
        }
    }

    void activityPaused() {
        mResumedCounter--;
        if (mResumedCounter == 0) {
            mHandler.postDelayed(mDelayedPauseRunnable, TIMEOUT_MS);
        }
    }

    private ActivityInitializationListener mInitializationListener = new ActivityInitializationListener() {
        @Override
        public void onCreate() {}

        @Override
        public void onStart() {
            activityStarted();
        }

        @Override
        public void onResume() {
            activityResumed();
        }
    };

    void attach(Context context) {
        mHandler = new Handler();
        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
        Application app = (Application) context.getApplicationContext();
        app.registerActivityLifecycleCallbacks(new EmptyActivityLifecycleCallbacks() {
            @Override
            public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
                ReportFragment.get(activity).setProcessListener(mInitializationListener);
            }

            @Override
            public void onActivityPaused(Activity activity) {
                activityPaused();
            }

            @Override
            public void onActivityStopped(Activity activity) {
                activityStopped();
            }
        });
    }
}

根據官方註釋，我們可以瞭解到：

  • ProcessLifecycleOwner是用來監聽Application生命週期的，因此它只會分發一次ON_CREATE事件，並且不會分發ON_DESTROY事件。
  • ProcessLifecycleOwner在Activity的onResume和onStop方法中都採用了Handle.postDelayed()方法，是為了處理Activity重建時比如橫豎螢幕切換時，不會發送事件。
  • ProcessLifecycleOwner一般用來判斷應用是在前臺還是後臺。但由於使用了Handle.postDelayed()，因此這個判斷不是即時的，有預設700ms的延遲。
  • ProcessLifecycleOwner與LifecycleDispatcher一樣，都是通過註冊Application.registerActivityLifecycleCallbacks來監聽Activity的生命週期回撥，來給每個Activity新增ReportFragment的。
那麼問題又來了，ProcessLifecycleOwner和LifecycleDispatcher兩個類是在哪裡初始化呢？

從原始碼中我們看到，他們的入口都是init(Context)，繼續搜尋原始碼，我們發現：

public class ProcessLifecycleOwnerInitializer extends ContentProvider {
    @Override
    public boolean onCreate() {
        LifecycleDispatcher.init(getContext());
        ProcessLifecycleOwner.init(getContext());
        return true;
    }
    // ......
}


AndroidManifest.xml
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
  ......
  <provider
    android:name="android.arch.lifecycle.ProcessLifecycleOwnerInitializer"
    android:authorities="me.baron.achitecturelearning.lifecycle-trojan"
    android:exported="false"
    android:multiprocess="true" />
</manifest>

瞭然，Lifecycle自動在我們的AndroidManifest.xml中添加了一個ContentProvider，用於初始化ProcessLifecycleOwner和LifecycleDispatcher，這麼做的好處是，不需要我們在Application中顯示呼叫，不需要我們寫一行程式碼。

總結

回到我們最初的兩個問題：

  • State是如何與Activity/Fragment的生命週期繫結的？
在Activity中新增一個ReportFragment(如果你的Activity繼承AppCompatActivity，會在父類的onCreate()中新增ReportFragment，否則由LifecycleDispatcher新增)，在ReportFragment生命週期函式中呼叫LifecycleRegistry.handleLifecycleEvent()方法改變State。
  • Event事件是如何分發到LifecycleObserver的？
LifecycleRegistry在收到handleLifecycleEvent()後，內部呼叫moveToState()方法，改變State值，每一次State值改變，都會呼叫LifecycleObserver.onStateChanged()方法將Event分發到LifecycleObserver

漲知識？學技能？關注微信公眾號：Android必修課

相關推薦

Android-Lifecycle超能解析-生命週期的那些事兒

本文篇幅較長，請大家耐心閱讀。 Lifecycle是什麼？ Lifecycle是一個生命週期感知元件，一般用來響應Activity、Fragment等元件的生命週期變化，並將變化通知到已註冊的觀察者。有助於更好地組織程式碼，讓程式碼邏輯符合生命週期規範，減少記憶

Android Fragment的十一個生命週期的作用

要知道fragment的作用就要先知道fragment是幹什麼用的 Fragment 是什麼？       Fragment是Activity中的模組，這個模組有自己的佈局，有自己的生命週期，單獨處理自己的輸入，在Activity執行的時候可以載入或者移除F

android 橫豎屏切換的生命週期

如下設定，當橫豎屏切換時，activity的狀態是不會改變的 在manifest中設定該Activity的configChanges為android:configChanges="screenSize|keyboardHidden|orientation" 總結如下：

Android四大元件之Activity-生命週期

一. Android 四大元件包括 Activity 活動 Service 服務 Broadcast Receiver 廣播接收者 Content Provider 內容提供者 1.什麼是Activity？ 使用者可與其提供的螢幕進行互動，以執行撥打電話、拍

Android 四大元件之 Activity生命週期

一、 Activity 的生命週期概念 Activity 的生命週期指的是， Activity 物件從被建立到銷燬的全過程 二、 Activity 的狀態 執行狀態（ Running）： 該狀態表示 Activity 可見並且擁有使用者焦點； 暫停狀

【架構分析】Android鎖屏與Activity生命週期的變化

概述 Android開機啟動後預設會先進入鎖屏然後滅屏休眠, 本文旨在介紹這個過程中最先啟動的Home Launch Activity (其實在Android N上最早被啟動的是Settings中的FallbackHome Activity) 如何發生相關的生命週期變化, 以及AMS

Android學習之碎片的生命週期

一、碎片的狀態： 1、執行狀態：當一個碎片是可見的，並且它所關聯的活動正處於執行狀態時，該碎片也處於執行狀態。 2、暫停狀態：當一個活動進入暫停狀態時（由於另一個未佔滿螢幕的活動被新增到了棧頂），與它相關聯的可見碎片就會進入到暫停狀態。 3、停止狀態：當一

Android 程序和應用的生命週期

程序和應用的生命週期 多數情況下，應用執行在他自己的Linux程序裡。當需要執行程式碼時，系統為應用程式分配一個程序，應用一直執行在該程序裡，一直到不再需要了，系統重新收回這部分記憶體供其它應用使用。 Android中一個特殊的地方在於應用程序的生命週期不完全由應用自己控制。而是系統通過正在

Android中Fragment巢狀生命週期響應問題

問題闡述 ： 主介面有四個Fragment 分別為A、B、C、D 這些為第一層Fragment（建立方式是由事務提交形式），其中B Fragment中佈局為ViewPager，裡面是放的三個Fragment 分別為B_1、B_2、B_3,這些稱為第二層Frag

淺談Android中的 Fragment、生命週期回撥方法 以及使用

        4onActivityCreated()              當Activity中的onCreate方法執行完後呼叫。 注意了：從這句官方的話可以看出：當執行onActivityCreated()的時候 activity的onCreate才剛完成。所以在onActivityCrea

Android—第一張（Activity+生命週期）

當啟動一個Activity，Android系統就會一次呼叫 1.Create（） (Killable NO) //當Activity第一次被建立的時候會呼叫此方法. //用法，一般都會在onCreate的方法裡寫，呼叫配置檔案，繫結監聽器，獲得佈局屬性等等； 2 onS

Android - 解決Fragment + ViewPager的生命週期問題

public class FragmentVisibleHelper implements LifecycleObserver { private static final String TAG = "VisibleHelper"; public interface

Android自定義View的生命週期淺析

原文連結：http://www.jianshu.com/p/29bb35a4860e 簡介 每天我們都會使用很多的應用程式，儘管他們有不同的約定，但大多數應用的設計是非常相似的。這就是為什麼許多客戶要求使用一些其他應用程式沒有的設計，使得應用程式顯得獨特和不同。 如果功能佈局要求非常定製

Android Application的作用以及生命週期

第一篇技術文件來先了解下Application。 Android 和activity，service一樣都是Android的系統控制元件。Application 只建立一個，屬於單例模式。 如何使用Application: 定義一個類MyApplication繼承Ap

Android中靜態變數的生命週期

靜態變數的生命週期，起始於類的載入，終止於類的釋放。 什麼時候類會載入呢? 我們知道，在app開啟時，會建立一個程序，然後初始化一個dvm的例項，負責類的載入釋放 和 垃圾回收等。 換句話說，在程序建立之後，就會載入類，靜態變數誕生了。 那何時釋放? 當然是在類解除安裝的

Android的四大元件以及生命週期和啟動方式（初步簡介）

前言：生命不止，學習不止。我們為了一個更好的薪資加強學習，讓我們在知識的海洋裡遨遊...... Android四大基本元件分別是Activity，Service服務,Content Provider內

Android筆記：Activity的生命週期以及啟動模式

Activity生命週期 activity的生命週期: onCreate        onStart           onRestart        onResume       onPaus

Android四大元件——Activity的生命週期

  Activivity作為android四大元件之首，在使用中是最多的元件，在中文直譯為活動，在一個專案中，正常情況下，除了Window,dialog,Toast之外，我們見到的介面只有Activity。 那麼我們就來研究下一般情況下Activity的生命週期吧。  

死磕 java執行緒系列之執行緒池深入解析——生命週期

（手機橫屏看原始碼更方便） 注：java原始碼分析部分如無特殊說明均基於 java8 版本。 注：執行緒池原始碼部分如無特殊說明均指ThreadPoolExecutor類。 簡介 上一章我們一起重溫了下執行緒的生命週期（六種狀態還記得不？），但是你知不知道其實執行緒池也是有生命週期的呢？！ 問題 （1）

Android中的自繪View的那些事兒（五）之 遮罩濾鏡：BlurMaskFilter 和 EmbossMaskFilter 的簡介

MaskFilter MaskFilter翻譯過來叫遮罩濾鏡，它可以為Paint邊緣的alpha通道應用轉換。目前有兩個子類：BlurMaskFilter 和 EmbossMaskFilter。它們分別可實現出模糊效果和浮雕效果。 BlurMaskFilter BlurM