Decoupling pages and components using lifecycle

Lifecycle Principle introduction

Jetpack Two classes are provided for us ,LifecyleOwner( Observed ) and LifecyleObserver( The observer ）, Monitor the page life cycle through observer mode .

Lifecycle Yes Activity Life cycle monitoring

• binding activity Life cycle of

class LifeCycleListener(val activity: Activity, private val onChangeListener: OnChangeListener) :LifecycleObserver {
    companion object{
        init {
            Log.e("tagLifeCycleListener", ":  perform " )
        }
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private fun onCreated(){
        onChangeListener.onChange(" Callback  onCreated  perform ")
        Log.e("tagLifeCycleListener", ":onCreated  perform " )
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    private fun onResume(){
        Log.e("tagLifeCycleListener", ":onResume  perform " )
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    private fun onPause(){
        Log.e("tagLifeCycleListener", ":onPause  perform " )
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    private fun onDestroy(){
        Log.e("tagLifeCycleListener", ":onDestroy  perform " )
    }

    interface OnChangeListener{
        fun onChange(des:String)
    }
}

• Bind the observer to the observed

 Log.e(TAG, "onCreate:  perform ", )
        lifecycleListener = LifeCycleListener(this, object : LifeCycleListener.OnChangeListener {
            override fun onChange(des: String) {
                Log.e(TAG, " Accept to  onChange: ")
            }

        })
        //lifecycle Bind the observer to the observed , Solving component pair activity The dependency of life cycle 
        lifecycle.addObserver(lifecycleListener)
        
 override fun onResume() {
        super.onResume()
        Log.e(TAG, "onResume:  perform ", )
    }

    override fun onPause() {
        super.onPause()
        Log.e(TAG, "onPause:  perform ", )
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.e(TAG, "onDestroy:  perform ", )
    }

Lifecycle Yes Service Life cycle monitoring

• LifecycleObserver The observer

class MyServiceObserver :LifecycleObserver{
    private  val MyServiceObserverTAG = "MyServiceObserver"

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    private fun onStart(){
        Log.e(MyServiceObserverTAG, "start:  perform " )
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    private fun onDestroy(){
        Log.e(MyServiceObserverTAG, "onDestroy:  perform " )
    }

}

• LifecycleService The binding of

class MyService: LifecycleService() {
    private  var myServiceObserver:MyServiceObserver = MyServiceObserver()
    init {
        lifecycle.addObserver(myServiceObserver)
    }
}

fun launchService(view: View) {
        startService(Intent(this,MyService::class.java))
    }
    fun closeService(view: View) {
        stopService(Intent(this,MyService::class.java))
    }

ProcessLifecycleOwner monitor APP Front and back of

• App Listening in the foreground or background

class ApplicationObserver:LifecycleObserver {
    private  val ApplicationObserverTAG = "ApplicationObserver"

    /**
     *  Listen to the application's onCreate Method , The entire lifecycle is called only once 
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private fun onCreated(){
        Log.e(ApplicationObserverTAG, "Application onCreated:  perform " )
    }

    /**
     *  Listen to the application call when it is in the foreground 
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    private fun onStart(){
        Log.e(ApplicationObserverTAG, "Application onStart:  Front desk Executive " )
    }

    /**
     *  Listen to the application call when it is in the foreground 
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    private fun onResume(){
        Log.e(ApplicationObserverTAG, "Application onResume:  Front desk Executive " )
    }

    /**
     *  Listen for application calls in the background 
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    private fun onPause(){
        Log.e(ApplicationObserverTAG, "Application onPause:  The background to perform " )
    }

    /**
     *  Listen for application calls in the background 
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    private fun onStop(){
        Log.e(ApplicationObserverTAG, "Application onStop:  The background to perform " )
    }

    /**
     *  Never call , The system does not distribute calls on_destroy event 
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    private fun onDestroy(){
        Log.e(ApplicationObserverTAG, "Application onDestroy:  Not execute " )
    }
}

class APP: Application() {
    override fun onCreate() {
        super.onCreate()
        ProcessLifecycleOwner.get().lifecycle.addObserver(ApplicationObserver())
    }
}

lifecycle Sample code