Android Jetpack Lifecycle使用介紹和原理分析

Lifecycle使用介紹

Lifecycle是google提供的一個能夠監聽activity、fragment、service、app process生命週期的組件庫

咱們最經常使用的是監聽activity和fragment生命週期，好比使用MVP架構，Presenter通常須要在activity的oncreate方法中初始化變量和資源等，在ondestory中釋放資源等

若是咱們不用Lifecycle組件的寫法是這樣的，必須手動在activity的onCreate和onDestroy方法調presenter對應的方法

class LifecycleActivity : AppCompatActivity() {

    private lateinit var presenter: LifecyclePresenter
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_lifecycle)
        presenter = LifecyclePresenter(this)
        presenter.onCreate()
    }

    override fun onDestroy() {
        super.onDestroy()
        presenter.onDestroy()
    }
	...
}

複製代碼

很顯然 這樣很是不優雅

那咱們該如何使用Lifecycle組件庫呢？

下面主要以Presenter爲Example講解

針對Activity

先定義一個ActivityPresenter

// 先定義一個BasePresenter，並定義對應activity的一系列方法
open class BasePresenter : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    open fun onCreate(owner: LifecycleOwner) {

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    open fun onStart(owner: LifecycleOwner) {

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    open fun onResume(owner: LifecycleOwner) {

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    open fun onPause(owner: LifecycleOwner) {

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    open fun onStop(owner: LifecycleOwner) {

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    open fun onDestroy(owner: LifecycleOwner) {

    }
}

// 定義一個 IActivityView
interface IActivityView {
    fun showContent(content: String)
}

// 繼承BasePresenter，只須要重寫 須要的生命週期方法便可
class ActivityPresenter(var view: IActivityView) : BasePresenter() {
    private var disposable: Disposable? = null
    private var i = 0

    override fun onCreate(owner: LifecycleOwner) {
        super.onCreate(owner)
        loadData()
    }

    override fun onDestroy(owner: LifecycleOwner) {
        super.onDestroy(owner)
        disposable?.dispose()
    }

    private fun loadData() {
        disposable = Flowable.interval(1, 1, TimeUnit.SECONDS)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribeWith(object : DisposableSubscriber<Any>() {
                override fun onComplete() {}

                override fun onNext(t: Any?) {
                    view.showContent("lifecycle: " + i++.toString())
                }

                override fun onError(t: Throwable?) {}
            })
    }
}
複製代碼

而後 主要的 activity代碼實現以下：

// 注意實現LifecycleOwner接口
class LifecycleActivity : Activity(), LifecycleOwner, IActivityView {

    private lateinit var lifecycleRegistry: LifecycleRegistry
    private lateinit var presenter: ActivityPresenter

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_lifecycle)
        // 先建立一個LifecycleRegistry對象
        lifecycleRegistry = LifecycleRegistry(this)
        // 而後在activity對應的每一個生命週期方法中調用handleLifecycleEvent
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)

        presenter = ActivityPresenter(this)
        // 調用addObserver方法，presenter開始觀察activity生命週期
        lifecycle.addObserver(presenter)
    }

    override fun onStart() {
        super.onStart()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
    }

    override fun onResume() {
        super.onResume()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)
    }

    override fun onPause() {
        super.onPause()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    }

    override fun onStop() {
        super.onStop()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
    }

    override fun onDestroy() {
        super.onDestroy()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    }

	//實現getLifecycle方法，返回上面定義好的lifecycleRegistry對象
    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }

    override fun showContent(content: String) {
        tv_text.text = content
    }
}

複製代碼

可見步驟以下：

• 1. 先定義一個class 實現 LifecycleObserver 接口（好比：BasePresenter）
• 2. 再定義一系列的方法 並加上 @OnLifecycleEvent 註解，映射對應Activity的生命週期方法
• 3. 而後定義一個Activity(好比上面的LifecycleActivity)實現LifecycleOwner接口，並實例化一個LifecycleRegistry對象，在getLifecycle()方法中返回此對象
• 4. 而後在activity的每一個生命週期方法中調用handleLifecycleEvent方法，設置並通知Observer當前activity當前生命週期
• 5. 最後調用lifecycle的addObserver方法，使得ActivityPresenter具備監聽activity生命週期的能力

上面的實現可能比較繁瑣，那是由於咱們使用的是Activity，而不是FragmentActivity; 對於Activity 在sdk源碼中沒有幫咱們實現LifecycleOwner接口, 須要咱們本身手動實現

那爲何須要咱們手動在activity的生命週期方法中手動調用handleLifecycleEvent方法呢，能不能不寫呢？答案固然是能夠不寫的，可是你必須導入lifecycle-extensions庫

implementation "androidx.lifecycle:lifecycle-extensions:2.0.0"

複製代碼

若是你導入了lifecycle-extensions庫，那麼就不須要你手動調handleLifecycleEvent方法了, 只須要實現LifecycleOwner接口便可

class LifecycleActivity : Activity(), LifecycleOwner, IActivityView {

    private lateinit var lifecycleRegistry: LifecycleRegistry
    private lateinit var presenter: ActivityPresenter

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_lifecycle)
        // 先建立一個LifecycleRegistry對象
        lifecycleRegistry = LifecycleRegistry(this)

        presenter = ActivityPresenter(this)
        // 調用addObserver方法，presenter開始觀察activity生命週期
        lifecycle.addObserver(presenter)
    }

	//實現getLifecycle方法，返回上面定義好的lifecycleRegistry對象
    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }

    override fun showContent(content: String) {
        tv_text.text = content
    }
}

複製代碼

針對FragmentActivity

對於support 包（或androidx包）下的FragmentActivity ，在Support Library 26.1.0起 就已經在源碼層 實現了LifecycleOwner接口，不須要開發者手動實現LifecycleOwner接口，同時也不須要手動調用handleLifecycleEvent方法

// AppCompatActivity 繼承 FragmentActivity
class LifecycleFragmentActivity : AppCompatActivity(), IView {

    private lateinit var presenter: LifecyclePresenter
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_lifecycle)
        presenter = LifecyclePresenter(this)
        lifecycle.addObserver(presenter)
    }

    override fun showContent(content: String) {
        tv_text.text = content
    }
}

複製代碼

如今是否是感受很是簡單，只須要定義一個class 實現 LifecycleObserver 接口，而後經過FragmentActivity自帶的lifecycle對象調用addObserver方法便可

針對support包（或androidx包）下的Fragment

對於support包（或androidx包）下的fragment，在Support Library 26.1.0起 就已經在源碼層 實現了LifecycleOwner接口，不須要開發者手動實現LifecycleOwner接口，同時也不須要手動調用handleLifecycleEvent方法

class AndroidXFragment : Fragment(), IFragmentView {

    private lateinit var presenter: FragmentPresenter

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        presenter = FragmentPresenter(this)
        // 調用addObserver方法就能夠監聽Fragment生命週期了
        lifecycle.addObserver(presenter)
    }

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
        return inflater.inflate(R.layout.fragment_lifecycle, container, false)
    }

    override fun showContent(content: String) {
        tv_text?.text = content
    }
}

interface IFragmentView {
    fun showContent(content: String)
}

class FragmentPresenter(val view: IFragmentView) : BasePresenter() {
    private var disposable: Disposable? = null
    private var i = 0

    override fun onCreate(owner: LifecycleOwner) {
        super.onCreate(owner)
        loadData()
    }

    override fun onDestroy(owner: LifecycleOwner) {
        super.onDestroy(owner)
        disposable?.dispose()
    }

    private fun loadData() {
        disposable = Flowable.interval(1, 1, TimeUnit.SECONDS)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribeWith(object : DisposableSubscriber<Any>() {
                override fun onComplete() {}

                override fun onNext(t: Any?) {
                    view.showContent("Fragment lifecycle: " + i++.toString())
                }

                override fun onError(t: Throwable?) {}
            })
    }
}

複製代碼

針對app包下的Fragment

對於app包下的Fragment, 跟app包下的Activity道理同樣，在sdk 源碼層 沒有幫咱們實現LifecycleOwner接口，因此須要咱們手動實現LifecycleOwner接口

同時與Activity不同的是，即便 你導入了lifecycle-extensions庫，你也必須手動調用handleLifecycleEvent方法

class AppFragment : Fragment(), LifecycleOwner, IFragmentView {

    private lateinit var lifecycleRegistry: LifecycleRegistry
    private lateinit var presenter: FragmentPresenter

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycleRegistry = LifecycleRegistry(this)
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)

        presenter = FragmentPresenter(this)
        lifecycle.addObserver(presenter)
    }

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
        return inflater.inflate(R.layout.fragment_lifecycle, container, false)
    }

    override fun onStart() {
        super.onStart()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
    }

    override fun onResume() {
        super.onResume()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)
    }

    override fun onPause() {
        super.onPause()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    }

    override fun onStop() {
        super.onStop()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
    }

    override fun onDestroy() {
        super.onDestroy()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    }

    override fun showContent(content: String) {
        tv_text?.text = content
    }

    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}

複製代碼

可見監聽在app包下的Fragment生命週期，仍是比較蛋疼的，須要寫的代碼比較多

可是在實際應用過程當中咱們大部分狀況下都是使用的support包（或androidx包）下的fragment；同時google也已經標示app包下的fragment已過時，推薦咱們使用support包（或androidx包）下的fragment

/*
 * ...
 * ...
 * @deprecated Use the <a href="{@docRoot}tools/extras/support-library.html">Support Library</a>
 *      {@link android.support.v4.app.Fragment} for consistent behavior across all devices
 *      and access to <a href="{@docRoot}topic/libraries/architecture/lifecycle.html">Lifecycle</a>.
 */
@Deprecated
public class Fragment implements ComponentCallbacks2, OnCreateContextMenuListener {
	...
}

複製代碼

如何監聽service生命週期呢

基本上監聽service生命週期的需求不多，可是咱們仍是能夠了解一下

同理 若是咱們手動實現的話，同樣須要先實現LifecycleOwner，在實例化一個LifecycleRegistry對象，而後在生命週期方法中不斷調用handleLifecycleEvent方法，最後經過addObserver方法監聽

可是慶幸的是google提供了一個LifecycleService，咱們只須要讓咱們的Service繼承LifecycleService便可

class TestLifecycleService : LifecycleService() {
    private lateinit var testServicePresenter: TestServicePresenter
    override fun onCreate() {
        super.onCreate()
        testServicePresenter = TestServicePresenter()
        lifecycle.addObserver(testServicePresenter)
    }
}
複製代碼

這樣的話TestServicePresenter 就能夠監聽到service的生命週期

監聽Service 生命週期回調規則以下

service生命週期	LifecycleObserver生命週期回調
onCreate	onCreate
onBind	onStart
onStart	onStart
onDestroy	先onStop,而後onDestroy

如何監聽整個app的生命週期呢

有些時候咱們須要監聽整個app生命週期，當app退到後臺和進入前臺須要作一些業務邏輯處理等

通常狀況下監聽app先後臺切換的方法以下：

監聽全部activity生命週期方法，同時定義一個counter計數和isForeground（默認false）前臺標示，當每個activity onResume時counter加1，同時若是發現isForeground是false，這表示app進入前臺，同時將isForeground設置成true，當onPause時counter減1，而且當counter == 0時，用handler postDelayed（大概500毫秒左右）檢查counter是否等於0，若是等於0，這表示app進入後臺，同時將isForeground設置成false

大改的邏輯是這樣的，可能還有一些特殊狀況須要慢慢測試和代碼調整

這裏有一個別人寫的監聽app先後臺切換的庫Foredroid供你們參考

那若是咱們用Lifecycle 該怎麼實現呢？？

很簡單，一句代碼就搞定了

ProcessLifecycleOwner.get().lifecycle.addObserver(TestProcessLifecyclePresenter())

複製代碼

Lifecycle監聽app生命週期回調規則以下

觸發回調規則	LifecycleObserver生命週期回調
當app第一次啓動的時候標示	onCreate
當mStartedCounter == 1	onStart
當mResumedCounter == 1	onResume
當mResumedCounter == 0	onPause
當mStartedCounter == 0	onStop

mStartedCounter 標示 當前有幾個activity處於onStart狀態

mResumedCounter 標示 當前有幾個activity處於onResume狀態

注意：當全部activity 被destroy時，是不會調LifecycleObserver的onDestroy方法的，這意味着沒法監聽到整個app的Destroy狀態（onDestroy回調永遠都不會調用）

Lifecycle 原理分析

Lifecycle組件庫是怎麼監聽activity、fragment生命週期的呢？

Lifecycle組件庫監聽activity生命週期原理

若是咱們不用Lifecycle組件庫, 本身實現的話，通常想到的是定義一個BaseActivity，而後在BaseActivity的每一個生命週期方法中調用一個方法 通知Observer(觀察者) 當前activity處理哪一個生命週期方法

上面的實現可能比較low，並且有侷限性，它要求你的activity必須實現BaseActivity，有沒有其它方式呢，答案是有的

先想一想Fragment生命週期 跟 Activity有什麼關係；是否是當activity 處於onResume, fragment 也處於onResume狀態，當activity 處於onPause，fragment也處於onPause狀態, 當activity 處於onDestroy，fragment也處於onDestroy狀態；這樣的話是否是就可使用一個Fragment就能夠監聽當前Activity生命週期的變化，那咱們就只須要給Activity添加一個空的Fragment便可

其時Lifecycle的是現實原理也是給Activity添加一個空的Fragment實現的（若是你看了Glide監聽activity的實現原理的話，其時Glide也是這樣實現的）

1. 先查查 FragmentActivity 源碼中是否是添加了一個空的Fragment

   // 對於androidx包的FragmentActivity繼承ComponentActivity
    // 對於support包的FragmentActivity繼承SupportActivity，同樣的有以下代碼
    @RestrictTo(LIBRARY_GROUP)
    public class ComponentActivity extends Activity
            implements LifecycleOwner, KeyEventDispatcher.Component {
        ...
        
        @Override
        @SuppressWarnings("RestrictedApi")
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            ReportFragment.injectIfNeededIn(this);
        }
    	...
    }
   複製代碼

   可見確實在activity onCreate方法中添加了一個ReportFragment；注意：ComponentActivity實現了LifecycleOwner接口，這也是爲何咱們使用FragmentActivity 不須要手動實現LifecycleOwner接口的緣由

2. 接下來看看ReportFragment源碼是怎麼寫的

   @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    public class ReportFragment extends Fragment {
        private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
                + ".LifecycleDispatcher.report_fragment_tag";
    
        public static void injectIfNeededIn(Activity activity) {
            // ProcessLifecycleOwner should always correctly work and some activities may not extend
            // FragmentActivity from support lib, so we use framework fragments for activities
            android.app.FragmentManager manager = activity.getFragmentManager();
            if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
                manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
                // Hopefully, we are the first to make a transaction.
                manager.executePendingTransactions();
            }
        }
    
        static ReportFragment get(Activity activity) {
            return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
                    REPORT_FRAGMENT_TAG);
        }
    
        private ActivityInitializationListener mProcessListener;
    
        private void dispatchCreate(ActivityInitializationListener listener) {
            if (listener != null) {
                listener.onCreate();
            }
        }
    
        private void dispatchStart(ActivityInitializationListener listener) {
            if (listener != null) {
                listener.onStart();
            }
        }
    
        private void dispatchResume(ActivityInitializationListener listener) {
            if (listener != null) {
                listener.onResume();
            }
        }
    
        @Override
        public void onActivityCreated(Bundle savedInstanceState) {
            super.onActivityCreated(savedInstanceState);
            dispatchCreate(mProcessListener);
            dispatch(Lifecycle.Event.ON_CREATE);
        }
    
        @Override
        public void onStart() {
            super.onStart();
            dispatchStart(mProcessListener);
            dispatch(Lifecycle.Event.ON_START);
        }
    
        @Override
        public void onResume() {
            super.onResume();
            dispatchResume(mProcessListener);
            dispatch(Lifecycle.Event.ON_RESUME);
        }
    
        @Override
        public void onPause() {
            super.onPause();
            dispatch(Lifecycle.Event.ON_PAUSE);
        }
    
        @Override
        public void onStop() {
            super.onStop();
            dispatch(Lifecycle.Event.ON_STOP);
        }
    
        @Override
        public void onDestroy() {
            super.onDestroy();
            dispatch(Lifecycle.Event.ON_DESTROY);
            // just want to be sure that we won't leak reference to an activity
            mProcessListener = null;
        }
    
        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);
                }
            }
        }
    
        void setProcessListener(ActivityInitializationListener processListener) {
            mProcessListener = processListener;
        }
    
        interface ActivityInitializationListener {
            void onCreate();
    
            void onStart();
    
            void onResume();
    	    }
    	}
   複製代碼

   可見 在ReportFragment生命週期方法中都調用了dispatch方法，而在dispatch方法中都調用了handleLifecycleEvent方法；這樣的話是否是就知道了爲何對於FragmentActivity就不須要手動調用handleLifecycleEvent方法了

3. 爲何對於App包下的Activity, 須要咱們手動調用handleLifecycleEvent方法，當導入了lifecycle-extensions庫以後，又不須要手動調用handleLifecycleEvent方法呢

   咱們須要手動調用handleLifecycleEvent方法，是由於在Activity源碼裏沒有幫咱們添加ReportFragment；那導入lifecycle-extensions依賴以後呢？

   先看看導入lifecycle-extensions依賴以後，它都作了什麼

   你會發現當導入lifecycle-extensions依賴以後，多了一系列lifecycle擴展庫；其中咱們比較關心的是lifecycle-process；它裏面有一個LifecycleDispatcher類，先看看它的源碼

   class LifecycleDispatcher {
   
        private static AtomicBoolean sInitialized = new AtomicBoolean(false);
    
        static void init(Context context) {
            if (sInitialized.getAndSet(true)) {
                return;
            }
            ((Application) context.getApplicationContext())
                    .registerActivityLifecycleCallbacks(new DispatcherActivityCallback());
        }
    
        @SuppressWarnings("WeakerAccess")
        @VisibleForTesting
        static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks {
    
            @Override
            public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
                ReportFragment.injectIfNeededIn(activity);
            }
    
            @Override
            public void onActivityStopped(Activity activity) {
            }
    
            @Override
            public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
            }
        }
    
        private LifecycleDispatcher() {
        }
    }
   複製代碼

   可見它使用了Application的registerActivityLifecycleCallbacks註冊了一個DispatcherActivityCallback對象，並在onActivityCreated回調中添加了ReportFragment，而在ReportFragment類中會自動調用handleLifecycleEvent方法

   LifecycleDispatcher 的 init 方法是何時調用的呢？？

   你會發現lifecycle-process庫裏有一個ProcessLifecycleOwnerInitializer類

   @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    public class ProcessLifecycleOwnerInitializer extends ContentProvider {
        @Override
        public boolean onCreate() {
            LifecycleDispatcher.init(getContext());
            ProcessLifecycleOwner.init(getContext());
            return true;
        }
    
        @Nullable
        @Override
        public Cursor query(@NonNull Uri uri, String[] strings, String s, String[] strings1,
                String s1) {
            return null;
        }
    
        @Nullable
        @Override
        public String getType(@NonNull Uri uri) {
            return null;
        }
    
        @Nullable
        @Override
        public Uri insert(@NonNull Uri uri, ContentValues contentValues) {
            return null;
        }
    
        @Override
        public int delete(@NonNull Uri uri, String s, String[] strings) {
            return 0;
        }
    
        @Override
        public int update(@NonNull Uri uri, ContentValues contentValues, String s, String[] strings) {
            return 0;
        }
    }
   複製代碼

   你會發現ProcessLifecycleOwnerInitializer是一個ContentProvider（ProcessLifecycleOwnerInitializer會自動在你的AndroidManifest.xml中註冊）, LifecycleDispatcher 是在ContentProvider的onCreate()初始化的，而ContentProvider的onCreate()調用時機是介於Application的attachBaseContext和onCreate之間，也就是app啓動的時候調用

   除了知道LifecycleDispatcher的init方法調用時機以外，你是否是發現了一塊新大陸，原來咱們能夠定義一個ContentProvider 巧妙的初始化咱們的一些Library, 作到開發無感知，只須要添加依賴便可

   若是你細心的話，你會發現ProcessLifecycleOwner也是在ContentProvider的onCreate()初始化的(ProcessLifecycleOwner 是用來監聽整個app生命週期的)

針對監聽activity生命週期原理就先講到這裏，下面咱們看看監聽fragment生命週期原理

Lifecycle組件庫監聽Fragment生命週期原理

1. 針對support包（或androidx包）下的fragment

   其實監聽Fragment生命週期也能夠像Activity同樣，給Fragment添加一個空的Fragment接口便可(好久之前看Glide源碼是這麼實現的)

   可是Lifecycle並非這麼實現的，而是直接在Fragment源碼層作了深度集成

   public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner,
            ViewModelStoreOwner {
            
        void performCreate(Bundle savedInstanceState) {
            ...
        	mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
        }
        
        void performStart() {
        	...
            mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
        }
        
        void performResume() {
        	...
            mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
        }
        
        void performPause() {
            mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
            ...
        }
        
        void performStop() {
            mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
            ...
        }
        
        void performDestroy() {
            mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
            ...
        }
    }
   複製代碼

   可見Fragment在源碼層 調用了handleLifecycleEvent方法，並實現了LifecycleOwner接口; 讓咱們很是方便的使用Lifecycle監聽Fragment生命週期

2. 針對app包下的Fragment

   很差意思，google並無對app包下的Fragment作任何處理，方便開發者使用Lifecycle監聽生命週期, 其全部的功能都須要本身手動實現（就像上面的example同樣）

   同時google已經標示app包下的Fragment爲過時，不推薦使用了；而是推薦使用support包（或androidx包）下的Fragment了