Jetpack lifeCycle快速上手

Lifecycle的好处是什么?

通过使用可感知生命周期的组件，可以将生命周期方法中关于这些组件的代码，移动到组件的内部。

Lifecyle基础使用

使用时不需要添加额外的依赖库，默认创建project的时候，core\appcompat的androidx依赖库即包含对应lifecycle的依赖 。

使用时直接继承ComponentActivity的子类即可使用LifeCycle。

下面我们通过对比来看下使用lifecycle和原始书写方式之间的差别。

我们模拟一个播放器的例子，我们知道播放器需要在activity恰当的生命周期中做适当的工作，例如在onResume时播放器也resume，在界面onPause时播放器也要pause掉，如果不使用lifeCycle组件，我们会写出下面的代码，

普通写法：

class MainActivity : AppCompatActivity() {

    private val mockPlayer = MockMediaPlayer()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        mockPlayer.onCreate()
        Log.i("MainActivity", "onCreate")
    }

    override fun onResume() {
        super.onResume()
        mockPlayer.onResume()
        Log.i("MainActivity", "onResume")
    }

    override fun onPause() {
        super.onPause()
        mockPlayer.onPause()
        Log.i("MainActivity", "onPause")
    }


    override fun onDestroy() {
        super.onDestroy()
        mockPlayer.onDestroy()
        Log.i("MainActivity", "onDestroy")
    }
}

需要在activity的声明周期中去处理播放器对应的操作。

我们模拟在播放器中做处理：

class MockMediaPlayer {

    private lateinit var player: MediaPlayer

    fun onCreate() {
        player = MediaPlayer()
        Log.d("MockMediaPlayer", "onCreate")
    }

    fun onResume() {
        thread {
            SystemClock.sleep(3000)//模拟阻塞3s
            player.start()
            Log.d("MockMediaPlayer", "onResume")
        }
    }

    fun onPause() {
        player.stop()
        Log.d("MockMediaPlayer", "onPause")
    }

    fun onDestroy() {
        player.release()
        Log.d("MockMediaPlayer", "onDestroy")
    }

}

使用LifeCycle方式，写法一：

步骤一：继承LifecycleObserver

class MockMediaPlayer2(private val owner: LifecycleOwner) : LifecycleObserver {

    private lateinit var player: MediaPlayer

    init {
        //关联生命周期的观察者
        owner.lifecycle.addObserver(this)
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate() {
        player = MediaPlayer()
        Log.d("MockMediaPlayer2", "onCreate")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun onResume() {
        thread {

            SystemClock.sleep(3000)//模拟阻塞1s
            if (owner.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
                player.start()
                Log.d("MockMediaPlayer2", "onResume")
            }
        }
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun onPause() {
        player.stop()
        Log.d("MockMediaPlayer2", "onPause")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy() {
        player.release()
        Log.d("MockMediaPlayer2", "onDestroy")
    }

}

步骤二：在Activity中，关联生命周期的观察者getLifecycle.addObserver(this)

public class MainActivity extends AppCompatActivity {

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

        //添加一个生命周期观察者    getLifecycle()是FragmentActivity中的方法
        MyObserver observer = new MockMediaPlayer2();
        getLifecycle().addObserver(observer);
    }
}

 

使用LifeCycle方式，写法二：

步骤一：继承LifecycleEventObser

class MockMediaPlayer3(private val owner: LifecycleOwner) : LifecycleEventObserver {

    private lateinit var player: MediaPlayer

    init {
        //关联生命周期的观察者
        owner.lifecycle.addObserver(this)
    }

    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when (event) {
            Lifecycle.Event.ON_CREATE -> {
                Log.d("MockMediaPlayer3", "onCreate")
                player = MediaPlayer()
            }
            Lifecycle.Event.ON_START, Lifecycle.Event.ON_RESUME -> {
                if (owner.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
                    player.start()
                    Log.d("MockMediaPlayer3", "onResume")
                }
            }
            Lifecycle.Event.ON_PAUSE, Lifecycle.Event.ON_STOP -> {
                player.stop()
                Log.d("MockMediaPlayer3", "onPause")
            }
            Lifecycle.Event.ON_DESTROY -> {
                player.release()
                Log.d("MockMediaPlayer3", "onDestroy")
            }
            Lifecycle.Event.ON_ANY -> Log.d("MockMediaPlayer3", "onAny")
        }
    }

}

步骤二：在Activity中，关联生命周期的观察者getLifecycle.addObserver(this)

public class MainActivity extends AppCompatActivity {

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

        //添加一个生命周期观察者    getLifecycle()是FragmentActivity中的方法
        MyObserver observer = new MockMediaPlayer2();
        getLifecycle().addObserver(observer);
    }
}

 

LifeCycle写法方式二，需要继承LifecycleEventObserver，然后重写onStateChanged方法即可，方法内会有LifeCycle相关Event的回调，我们在对应的回调中处理相关业务即可。

完整项目代码