Android Jetpack 架構組件系列（二）Lifecycle

1. Lifecycle 簡介

Lifecycle 即生命周期，在Jetpack 架構組件中Lifecycles 是可以為其它組件提供生命周期感知能力的一個組件，因此把Lifecycle 也就生命周期感知組件，這個組件可以用來相應另一個組件（目前有Activity 和 Fragment）生命周期狀態(tài)的變化，從而幫助我們寫出更精簡，更易于維護的代碼。

2. 為什么需要 Lifecycle 組件 ？

Android App 大部分功能都是圍繞著四大組件展開的，很多任務和操作都與四大組件中生命周期方法息息相關。
以Activity 和Fragment為例來說，需要在onCreate()方法回調的時候做什么？ 在onResume()做什么？ onStop(), onDestory()方法回調時又該做什么？ 對于同一個Activity來說可能包含很多的業(yè)務邏輯，而組件的生命周期方法只有一個，這樣就出現(xiàn)了一個問題，隨著業(yè)務邏輯的越來越復雜，這些生命周期方法也會變得又重又難以維護。其實Activity 和 Fragment 作為四大組件中唯一的UI視圖組件，本身只需要處理和用戶的交互邏輯，其他邏輯都應該從其中隔離出來，做到視圖和邏輯的分離，但實際上要做到這點并不容易，為了解決Activity或者生命周期方法會變得又重又難以維護的問題，很多人可能會考慮使用MVP架構來解決問題，這個在很大程度上確實能解決問題，讓視圖和邏輯分離，但其實本質的問題并未解決：隨著業(yè)務邏輯的迭代和復雜，Presenter 會出現(xiàn)所謂的“接口爆炸”， 變得越來越難以維護和測試，并且很容易出現(xiàn)內存泄漏的情況。

3. Lifecycle 組件的使用？

3.1 依賴Lifecycle

Lifecycle 早期包含在 support library 26.1.0 及之后的依賴包中，如果我們的項目依賴的支持庫版本在 26.1.0及以上，那么不需要額外導入 Lifecycle 庫，本篇例子中使用的支持庫是 28.0.0 ：

implementation 'com.android.support:appcompat-v7:28.0.0'

如果項目依賴的support庫小于26.1.0， 此時就需要單獨依賴Lifecycle庫了：

implementation "android.arch.lifecycle:runtime:1.1.1"

如果您的項目已經遷移到AndroidX， 使用下面方式引入：

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

3.2 Lifecycle 兩種使用方式：

3.2.1 使用系統(tǒng)Activity已經實現(xiàn)的LifecycleOwner

繼承自AppCompatActivity，或者FragmentActivity， 可以直接使用實現(xiàn)自己的 LifecycleObserver ，然后addObserver即可。因為 AppCompatActivity，F(xiàn)ragmentActivity都繼承自ComponentActivity， 而 ComponentActivity已經實現(xiàn)了LifecycleOwner接口

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        lifecycle.addObserver(MyObserver())
    }

    class MyObserver : LifecycleObserver {

        @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
        fun onMyCreate() {
            Log.d("MainMyObserver", "onMyCreate")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        fun onMyResume() {
            Log.d("MainMyObserver", "onMyResume")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
        fun onMyOnStop() {
            Log.d("MainMyObserver", "onMyStop")
        }
    }
}

2020-07-04 11:11:46.651 15872-15872/com.cjl.jetpackdemo D/MyObserver: onMyCreate
2020-07-04 11:11:46.677 15872-15872/com.cjl.jetpackdemo D/MyObserver: onMyResume
2020-07-04 11:11:53.936 15872-15872/com.cjl.jetpackdemo D/MyObserver: onMyStop

3.2.2 自己實現(xiàn) LifecycleOwner

class SecondActivity : Activity(), LifecycleOwner{

    private lateinit var lifecycleRegistry : LifecycleRegistry

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.second_main)

        lifecycleRegistry = LifecycleRegistry(this)
        lifecycleRegistry.addObserver(MyObserver())
        lifecycleRegistry.currentState = Lifecycle.State.CREATED

        var state : Lifecycle.State = lifecycleRegistry.currentState
        val isCreated = state.isAtLeast(Lifecycle.State.CREATED)
        Log.d("SecondMyObserver", "isCreated = "+isCreated)
    }

    override fun onResume() {
         super.onResume()
         lifecycleRegistry.currentState = Lifecycle.State.RESUMED
     }
     override fun onDestroy() {
         super.onDestroy()
         lifecycleRegistry.currentState = Lifecycle.State.DESTROYED
     }
     override fun getLifecycle(): Lifecycle {
         return lifecycleRegistry
     }

     class MyObserver : LifecycleObserver {

         @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
         fun onMyCreate() {
             Log.d("SecondMyObserver", "onMyCreate")
         }

         @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
         fun onMyResume() {
             Log.d("SecondMyObserver", "onMyResume")
         }

         @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
         fun onMyOnStop() {
             Log.d("SecondMyObserver", "onMyStop")
         }

         @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
         fun onMyOnDestroy() {
             Log.d("SecondMyObserver", "onMyDestroy")
         }
     }
}

2020-07-04 19:15:26.635 21824-21824/com.cjl.jetpackdemo D/SecondMyObserver: onMyCreate
2020-07-04 19:15:26.636 21824-21824/com.cjl.jetpackdemo D/SecondMyObserver: isCreated = true
2020-07-04 19:15:26.642 21824-21824/com.cjl.jetpackdemo D/SecondMyObserver: onMyResume
2020-07-04 19:15:31.884 21824-21824/com.cjl.jetpackdemo D/SecondMyObserver: onMyStop
2020-07-04 19:15:31.884 21824-21824/com.cjl.jetpackdemo D/SecondMyObserver: onMyDestroy

為了更加方便使用，Lifecycle 還提供了查詢當前組件所處的生命周期狀態(tài)的方法, 源碼如下：

public boolean isAtLeast(@NonNull State state) {
       return compareTo(state) >= 0;
}

具體使用如下：

  var state : Lifecycle.State = lifecycleRegistry.currentState
  val isCreated = state.isAtLeast(Lifecycle.State.CREATED)
  Log.d("SecondMyObserver", "isCreated = "+isCreated)

4. Lifecycle 的狀態(tài)

Lifecycle 的狀態(tài)定義在State枚舉類中，代碼具體如下：

 public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }

以上這五種狀態(tài)似乎我們Activity的狀態(tài)并不完全統(tǒng)一，沒有Stop，多了個INITIALIZED， 下面我們就通過Demo來測試這五種狀態(tài)觸發(fā)的具體時機吧， Demo代碼如下：

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        Log.d("MainMyObserver", "[onCreate start] lifecycle is---->"+lifecycle.currentState)
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        btn_second.setOnClickListener { startActivity(Intent(this@MainActivity, SecondActivity::class.java)) }
        lifecycle.addObserver(MyObserver())
        Log.d("MainMyObserver", "[onCreate end] lifecycle is---->"+lifecycle.currentState)
    }

    override fun onStart() {
        Log.d("MainMyObserver", "[onStart start] lifecycle is---->"+lifecycle.currentState)
        super.onStart()
        Log.d("MainMyObserver", "[onStart end] lifecycle is---->"+lifecycle.currentState)
    }

    override fun onResume() {
        Log.d("MainMyObserver", "[onResume start] lifecycle is---->"+lifecycle.currentState)
        super.onResume()
        Log.d("MainMyObserver", "[onResume end] lifecycle is---->"+lifecycle.currentState)
    }

    override fun onPause() {
        Log.d("MainMyObserver", "[onPause start] lifecycle is---->"+lifecycle.currentState)
        super.onPause()
        Log.d("MainMyObserver", "[onPause end] lifecycle is---->"+lifecycle.currentState)
    }

    override fun onStop() {
        Log.d("MainMyObserver", "[onStop start] lifecycle is---->"+lifecycle.currentState)
        super.onStop()
        Log.d("MainMyObserver", "[onStop end] lifecycle is---->"+lifecycle.currentState)
    }

    override fun onDestroy() {
        Log.d("MainMyObserver", "[onDestroy start] lifecycle is---->"+lifecycle.currentState)
        super.onDestroy()
        Log.d("MainMyObserver", "[onDestroy end] lifecycle is---->"+lifecycle.currentState)
    }

    class MyObserver : LifecycleObserver {

        @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
        fun onMyCreate() {
            Log.d("MainMyObserver", "onMyCreate")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_START)
        fun onMyStart() {
            Log.d("MainMyObserver", "onMyStart")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        fun onMyResume() {
            Log.d("MainMyObserver", "onMyResume")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
        fun onMyPause() {
            Log.d("MainMyObserver", "onMyPause")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
        fun onMyOnStop() {
            Log.d("MainMyObserver", "onMyStop")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
        fun onMyOnDestroy() {
            Log.d("MainMyObserver", "onMyDestroy")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
        fun onMyAny() {
//            Log.d("MainMyObserver", "onMyAny")
        }
    }
}

測試后log如下：

2020-07-04 19:42:37.290 28018-28018/com.cjl.jetpackdemo D/MainMyObserver: [onCreate start] lifecycle is---->INITIALIZED
2020-07-04 19:42:37.340 28018-28018/com.cjl.jetpackdemo D/MainMyObserver: [onCreate end] lifecycle is---->INITIALIZED
2020-07-04 19:42:37.341 28018-28018/com.cjl.jetpackdemo D/MainMyObserver: onMyCreate
2020-07-04 19:42:37.345 28018-28018/com.cjl.jetpackdemo D/MainMyObserver: [onStart start] lifecycle is---->CREATED
2020-07-04 19:42:37.346 28018-28018/com.cjl.jetpackdemo D/MainMyObserver: [onStart end] lifecycle is---->CREATED
2020-07-04 19:42:37.346 28018-28018/com.cjl.jetpackdemo D/MainMyObserver: onMyStart
2020-07-04 19:42:37.347 28018-28018/com.cjl.jetpackdemo D/MainMyObserver: [onResume start] lifecycle is---->STARTED
2020-07-04 19:42:37.348 28018-28018/com.cjl.jetpackdemo D/MainMyObserver: [onResume end] lifecycle is---->STARTED
2020-07-04 19:42:37.348 28018-28018/com.cjl.jetpackdemo D/MainMyObserver: onMyResume
2020-07-04 19:42:44.705 28018-28018/com.cjl.jetpackdemo D/MainMyObserver: onMyPause
2020-07-04 19:42:44.705 28018-28018/com.cjl.jetpackdemo D/MainMyObserver: [onPause start] lifecycle is---->STARTED
2020-07-04 19:42:44.706 28018-28018/com.cjl.jetpackdemo D/MainMyObserver: [onPause end] lifecycle is---->STARTED
2020-07-04 19:42:45.099 28018-28018/com.cjl.jetpackdemo D/MainMyObserver: onMyStop
2020-07-04 19:42:45.100 28018-28018/com.cjl.jetpackdemo D/MainMyObserver: [onStop start] lifecycle is---->CREATED
2020-07-04 19:42:45.101 28018-28018/com.cjl.jetpackdemo D/MainMyObserver: [onStop end] lifecycle is---->CREATED
2020-07-04 19:42:45.104 28018-28018/com.cjl.jetpackdemo D/MainMyObserver: onMyDestroy
2020-07-04 19:42:45.105 28018-28018/com.cjl.jetpackdemo D/MainMyObserver: [onDestroy start] lifecycle is---->DESTROYED
2020-07-04 19:42:45.106 28018-28018/com.cjl.jetpackdemo D/MainMyObserver: [onDestroy end] lifecycle is---->DESTROYED

從log中我們可以看出以下幾點結論：

  1. Lifecycle 中的回調方法的調用有些是在Activity 生命周期方法執(zhí)行完后才回調的，有些是在Activity生命周期方法執(zhí)行之前回調的，具體來說Lifecycle的 onCreate, onStart, onResume 方法是在Activity生命周期調用之后才回調的； 而Lifecycle的 onPause， onStop， onDestroy是在Activity生命周期方法執(zhí)行之前就先回調的；
  2. 在Activity 的 onCreate 方法中，Lifecycle 的狀態(tài)一直INITIALIZED；
  3. 在Activity 的 onStart 方法中，Lifecycle 的狀態(tài)一直CREATED；
  4. 在Activity 的 onResume 方法中，Lifecycle 的狀態(tài)一直STARTED；
  5. 在Activity 的 onPause 即將調用之前，Lifecycle 的狀態(tài)仍然是STARTED；
  6. 在Activity 的 onStop 即將調用之前，Lifecycle 的狀態(tài)仍然是CREATED；
  7. 在Activity 的 onDestroy 即將調用之前，Lifecycle 的狀態(tài)已經是DESTROYED了；

以上就是Lifecycle的基本使用方法，可以看出其實很簡單，趕緊用在項目中吧。下篇我們去看源碼，探究具體是如何實現(xiàn)的。

?著作權歸作者所有,轉載或內容合作請聯(lián)系作者
【社區(qū)內容提示】社區(qū)部分內容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發(fā)布，文章內容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

友情鏈接更多精彩內容