声明 : 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 androidx.activity.ComponentActivity.
*/
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
通过以上代码可以看出来,当 Service 的声明周期发生变化时,不在需要主动对组件进行通知,LifecycleService很好的实现了组件与 Service 之间解耦.
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
红色框框里面的是,是我按了 home 键,回到桌面,然后又打开 app 的操作.
注意事项
one: ProcessLifecycleOwner 是针对整个应用程序的.
two: Lifecycle.Event.ON_CREATE 只会被调用一次,Lifecycle.Event.ON_DESTROY永远不会调用.
three: 当 app从后台回到前台时,依次会走Lifecycle.Event.ON_START和Lifecycle.Event.ON_RESUME
four: 当app 从前台回到后台时,会依次走Lifecycle.Event.ON_PAUSE和Lifecycle.Event.ON_STOP.
(((但是需要注意的是,这两个调用有一定的延迟,因为系统需要为屏幕旋转,由于配置发生变化而导致 Acvtivty重新创建等情况预留一些时间,也就是说,系统需要保证当设备出现这种情况时,这两个事件不会被调用,以为旋转屏幕时,app 没有退到后台,只是进入了横屏/竖屏模式而已.)))
------->实不相瞒,括号里面的内容我没验证过,因为我都强制竖屏或者变形,哈哈哈哈哈.
image.png