声明 : https://www.jianshu.com/p/714062a9af75
目录

简介
原理
使用方法

1,Activty 中使用
2,Fragment 中使用
3,service 中使用
4,Application监听 app 的声明周期

❤️ 简介:

  LifeCycle可以帮助开发者创建可感知生命周期的组件,这样, 组件便能够在内部管理自己的声明周期,从而降低模块间的耦合度,并降低内存泄漏发生的可能性.

❤️ 工作原理:

  Jetpack 为我们提供了两个类,LifecycleOwner(被观察者)和 LifecycleObserver(观察者).即通过观察者模式,实现对页面声明周期的监听.通过源码可以看出来,Activity 已经默认实现了 LifecycleOwner 接口,并提供了一个 getLifecycle(LiftcycleObserver observer)方法,LifecycleOwner 正是通过该方法实现观察者模式的.

@RestrictTo(LIBRARY_GROUP_PREFIX)
public class ComponentActivity extends Activity implements
        LifecycleOwner,
        KeyEventDispatcher.Component {
        .......
    /**
     * This is only used for apps that have not switched to Fragments 1.1.0, where this
     * behavior is provided by <code>androidx.activity.ComponentActivity</code>.
     */
    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

     ......

    @CallSuper
    @Override
    protected void onSaveInstanceState(@NonNull Bundle outState) {
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
        super.onSaveInstanceState(outState);
    }
    ......
}

❤️ 使用方法:

1,Activty 中使用:

class MainActivity : AppCompatActivity() {
    companion object {
        const val Tag = "MainActivity"

    }

    var myLifeCycle = MyLifeCycle()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
       //将观察者和被观察者绑定~~~
        lifecycle.addObserver(myLifeCycle)
        Log.i(Tag, "MainAc---OnCreate")
    }

    override fun onStart() {
        super.onStart()
        Log.i(Tag, "MainAc---onStart")

    }
    //........雷同代码不再贴出来

}

MyLifeCycle

class MyLifeCycle : LifecycleObserver {
    companion object {
        const val Tag = "MyLifeCycle"
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun myLifeOnCreate() {
        Log.d(Tag, "MyLifeCycle---OnCreate")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun myLifeonStart() {
        Log.d(Tag, "MyLifeCycle---onStart")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun myLifeonResume() {
        Log.d(Tag, "MyLifeCycle---onResume")
    }

   //.....雷同代码补贴出来了

}

运行一下

结果图.png

结果图 2.png

是不是超级简单啊,😁😁就这样,LifeCycle 就完美的解决了组件对生命周期的依赖问题,使组件能够管理自己的生命周期,降低耦合度.如果与 Activity 数据有交互,那就写一个接口,回调一下的啦~~懒了,不想写代码了,当然了Fragment 同样的使用方法,看下面

2,Fragment 中使用

class HomeFragment : Fragment() {
    var myLifeCycle = MyLifeCycle()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        myLifeCycle = MyLifeCycle()
        lifecycle.addObserver(myLifeCycle)
    }

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
                              savedInstanceState: Bundle?): View? {
        // Inflate the layout for this fragment
        return inflater.inflate(R.layout.fragment_home, container, false)
    }
    
}

so easy~~~运行结果截图就不贴了哈.....因为懒.

3,service 中使用

Android提供了一个名为 LifecycleService 的类,该类继承 Service,并实现了 LifecycleOwner 的接口,与 Activity/Fragment 类似,也提供了一个 getLifecycle()的方法供我们使用.看下源码

public class LifecycleService extends Service implements LifecycleOwner {

    private final ServiceLifecycleDispatcher mDispatcher = new ServiceLifecycleDispatcher(this);

    //.........
    @Override
    @NonNull
    public Lifecycle getLifecycle() {
        return mDispatcher.getLifecycle();
    }
}

好了,开始实现吧.

在 build.gradle 中引用

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

然后开撸代码

class MyService : LifecycleService() {
    companion object {
        const val Tag = "MyService"

    }

    init {
        lifecycle.addObserver(MyLifeCycle())
    }

    override fun onCreate() {
        super.onCreate()
        Log.i(Tag, "MyService---OnCreate")
    }

    override fun onStart(intent: Intent?, startId: Int) {
        super.onStart(intent, startId)
        Log.i(Tag, "MyService---onStart")
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.i(Tag, "MyService---onDestroy")
    }
}

运行一下

image.png

完活~
哦,别忘记,清单文件注册一下服务

image.png

4,Application监听 app 的声明周期

LifeCycle 提供了一个名为 ProcessLifecycleOwner 的类,以便我们知道整个程序的声明周期的情况.
Look下面.
build.gradle 文件

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

Application:

class MyApplication : Application() {
    private val Tag = "MyApplication"
    override fun onCreate() {
        super.onCreate()
        Log.i(Tag, "MyApplication---OnCreate")
        ProcessLifecycleOwner.get().lifecycle.addObserver(MyLifeCycle())
    }
}

MyLifeCycle:
重点看注释,哪些会被调用,哪些不会被调用

class MyLifeCycle : LifecycleObserver {
    companion object {
        const val Tag = "MyLifeCycle"
    }

    //在应用程序整个声明周期中只会被调用一次
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun myLifeOnCreate() {
        Log.d(Tag, "MyLifeCycle---OnCreate")
    }

    //当应用程序出现在前台是被调用
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun myLifeonStart() {
        Log.d(Tag, "MyLifeCycle---onStart")
    }

    //当应用程序出现在前台是被调用
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun myLifeonResume() {
        Log.d(Tag, "MyLifeCycle---onResume")
    }

    //当应用程序出现退出到后台是被调用
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun myLifeonPause() {
        Log.d(Tag, "MyLifeCycle---onPause")
    }

    //当应用程序出现退出到后台是被调用
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun myLifeonStop() {
        Log.d(Tag, "MyLifeCycle---onStop")
    }

    //永远不会被调用,系统不会分发调用ON_DESTROY事件
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun myLifeonDestroy() {
        Log.d(Tag, "MyLifeCycle---onDestroy")
    }
}

运行一下

image.png

image.png

END