对于位置跟踪示例,我们可以让 MyLocationListener
类实现 LifecycleObserver
,然后在 onCreate()
方法中使用 Activity 的 Lifecycle
对其进行初始化。这样,MyLocationListener
类便可以“自给自足”,这意味着,对生命周期状态的变化做出响应的逻辑会在 MyLocationListener
(而不是在 Activity)中进行声明。让各个组件存储自己的逻辑可使 Activity 和 Fragment 逻辑更易于管理。
class MyActivity extends AppCompatActivity {
private MyLocationListener myLocationListener;
public void onCreate(…) {
myLocationListener = new MyLocationListener(this, getLifecycle(), location -> {
// update UI
});
Util.checkUserStatus(result -> {
if (result) {
myLocationListener.enable();
}
});
}
}
一个常见的用例是,如果 Lifecycle
现在未处于良好的状态,则应避免调用某些回调。例如,如果回调在 Activity 状态保存后运行 Fragment 事务,就会触发崩溃,因此我们绝不能调用该回调。
为简化此使用场景,Lifecycle
类允许其他对象查询当前状态。
class MyLocationListener implements LifecycleObserver {
private boolean enabled = false;
public MyLocationListener(Context context, Lifecycle lifecycle, Callback callback) {
…
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
void start() {
if (enabled) {
// connect
}
}
public void enable() {
enabled = true;
if (lifecycle.getCurrentState().isAtLeast(STARTED)) {
// connect if not connected
}
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
void stop() {
// disconnect if connected
}
}
对于此实现,LocationListener
类可以完全感知生命周期。如果我们需要从另一个 Activity 或 Fragment 使用 LocationListener
,只需对其进行初始化。所有设置和拆解操作都由类本身管理。
如果库提供了需要使用 Android 生命周期的类,我们建议您使用生命周期感知型组件。库客户端可以轻松集成这些组件,而无需在客户端进行手动生命周期管理。
1.3 Lifecycle 的使用
1.3.1 引入依赖
① 非 androidX 项目引入
implementation “android.arch.lifecycle:extensions:1.1.1”
添加这一句代码就依赖了如下的库:
② androidX 项目引入
如果项目已经依赖了 androidX:
implementation ‘androidx.appcompat:appcompat:1.2.0’
那么我们就可以使用Lifecycle库了,因为appcompat依赖了androidx.fragment,而androidx.fragment下依赖了ViewModel和 LiveData,LiveData内部又依赖了Lifecycle。
如果想要单独引入依赖,则如下:
在项目根目录的build.gradle添加 google() 代码库,然后app的build.gradle引入依赖,官方给出的依赖如下:
//根目录的 build.gradle
repositories {
google()
…
}
//app的build.gradle
dependencies {
def lifecycle_version = “2.2.0”
def arch_version = “2.1.0”
// ViewModel
implementation “androidx.lifecycle:lifecycle-viewmodel:
l
i
f
e
c
y
c
l
e
v
e
r
s
i
o
n
"
/
/
L
i
v
e
D
a
t
a
i
m
p
l
e
m
e
n
t
a
t
i
o
n
"
a
n
d
r
o
i
d
x
.
l
i
f
e
c
y
c
l
e
:
l
i
f
e
c
y
c
l
e
−
l
i
v
e
d
a
t
a
:
lifecycle_version" // LiveData implementation "androidx.lifecycle:lifecycle-livedata:
lifecycleversion"//LiveDataimplementation"androidx.lifecycle:lifecycle−livedata:lifecycle_version”
// 只有Lifecycles (不带 ViewModel or LiveData)
implementation “androidx.lifecycle:lifecycle-runtime:$lifecycle_version”
// Saved state module for ViewModel
implementation “androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version”
// lifecycle注解处理器
annotationProcessor “androidx.lifecycle:lifecycle-compiler:
l
i
f
e
c
y
c
l
e
v
e
r
s
i
o
n
"
/
/
替换
−
如果使用
J
a
v
a
8
,
就用这个替换上面的
l
i
f
e
c
y
c
l
e
−
c
o
m
p
i
l
e
r
i
m
p
l
e
m
e
n
t
a
t
i
o
n
"
a
n
d
r
o
i
d
x
.
l
i
f
e
c
y
c
l
e
:
l
i
f
e
c
y
c
l
e
−
c
o
m
m
o
n
−
j
a
v
a
8
:
lifecycle_version" // 替换 - 如果使用Java8,就用这个替换上面的lifecycle-compiler implementation "androidx.lifecycle:lifecycle-common-java8:
lifecycleversion"//替换−如果使用Java8,就用这个替换上面的lifecycle−compilerimplementation"androidx.lifecycle:lifecycle−common−java8:lifecycle_version”
//以下按需引入
// 可选 - 帮助实现Service的LifecycleOwner
implementation “androidx.lifecycle:lifecycle-service:
l
i
f
e
c
y
c
l
e
v
e
r
s
i
o
n
"
/
/
可选
−
P
r
o
c
e
s
s
L
i
f
e
c
y
c
l
e
O
w
n
e
r
给整个
a
p
p
进程提供一个
l
i
f
e
c
y
c
l
e
i
m
p
l
e
m
e
n
t
a
t
i
o
n
"
a
n
d
r
o
i
d
x
.
l
i
f
e
c
y
c
l
e
:
l
i
f
e
c
y
c
l
e
−
p
r
o
c
e
s
s
:
lifecycle_version" // 可选 - ProcessLifecycleOwner给整个 app进程 提供一个lifecycle implementation "androidx.lifecycle:lifecycle-process:
lifecycleversion"//可选−ProcessLifecycleOwner给整个app进程提供一个lifecycleimplementation"androidx.lifecycle:lifecycle−process:lifecycle_version”
// 可选 - ReactiveStreams support for LiveData
implementation “androidx.lifecycle:lifecycle-reactivestreams:
l
i
f
e
c
y
c
l
e
v
e
r
s
i
o
n
"
/
/
可选
−
T
e
s
t
h
e
l
p
e
r
s
f
o
r
L
i
v
e
D
a
t
a
t
e
s
t
I
m
p
l
e
m
e
n
t
a
t
i
o
n
"
a
n
d
r
o
i
d
x
.
a
r
c
h
.
c
o
r
e
:
c
o
r
e
−
t
e
s
t
i
n
g
:
lifecycle_version" // 可选 - Test helpers for LiveData testImplementation "androidx.arch.core:core-testing:
lifecycleversion"//可选−TesthelpersforLiveDatatestImplementation"androidx.arch.core:core−testing:arch_version”
}
看着有很多,实际上如果只使用Lifecycle,只需要引入lifecycle-runtime即可。但通常都是和 ViewModel、 LiveData 配套使用的,所以lifecycle-viewmodel、lifecycle-livedata 一般也会引入。
另外,lifecycle-process是给整个app进程提供一个lifecycle,会面也会提到。
1.3.2 使用方法
Lifecycle的使用很简单:
- 1、生命周期拥有者 使用getLifecycle()获取Lifecycle实例,然后代用addObserve()添加观察者;
- 2、观察者实现LifecycleObserver,方法上使用OnLifecycleEvent注解关注对应生命周期,生命周期触发时就会执行对应方法;
① 基本使用
在Activity(或Fragment)中 一般用法如下:
public class LifecycleTestActivity extends AppCompatActivity {
private String TAG = “Lifecycle_Test”;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_lifecycle_test);
//Lifecycle 生命周期
getLifecycle().addObserver(new MyObserver());
Log.i(TAG, "onCreate: ");
}
@Override
protected void onResume() {
super.onResume();
Log.i(TAG, "onResume: ");
}
@Override
protected void onPause() {
super.onPause();
Log.i(TAG, "onPause: ");
}
}
Activity(或Fragment)是生命周期的拥有者,通过getLifecycle()方法获取到生命周期Lifecycle对象,Lifecycle对象使用addObserver方法 给自己添加观察者,即MyObserver对象。当Lifecycle的生命周期发生变化时,MyObserver就可以感知到。
MyObserver是如何使用生命周期的呢?看下MyObserver的实现:
public class MyObserver implements LifecycleObserver {
private String TAG = “Lifecycle_Test”;
@OnLifecycleEvent(value = Lifecycle.Event.ON_RESUME)
public void connect(){
Log.i(TAG, "connect: ");
}
@OnLifecycleEvent(value = Lifecycle.Event.ON_PAUSE)
public void disConnect(){
Log.i(TAG, "disConnect: ");
}
}
首先MyObserver实现了接口LifecycleObserver,LifecycleObserver用于标记一个类是生命周期观察者。 然后在connectListener()、disconnectListener()上 分别都加了@OnLifecycleEvent注解,且value分别是Lifecycle.Event.ON_RESUME、Lifecycle.Event.ON_PAUSE,这个效果就是:connectListener()会在ON_RESUME时执行,disconnectListener()会在ON_PAUSE时执行。
我们打开LifecycleTestActivity 然后退出,日志打印如下:
2020-11-09 17:25:40.601 4822-4822/com.hfy.androidlearning I/Lifecycle_Test: onCreate:
2020-11-09 17:25:40.605 4822-4822/com.hfy.androidlearning I/Lifecycle_Test: onResume:
2020-11-09 17:25:40.605 4822-4822/com.hfy.androidlearning I/Lifecycle_Test: connect:
2020-11-09 17:25:51.841 4822-4822/com.hfy.androidlearning I/Lifecycle_Test: disConnect:
2020-11-09 17:25:51.841 4822-4822/com.hfy.androidlearning I/Lifecycle_Test: onPause:
可见MyObserver的方法 确实是在对应关注的生命周期触发时调用。
② MVP框架中的使用
如果是 在MVP架构中,那么就可以把presenter作为观察者:
public class LifecycleTestActivity extends AppCompatActivity implements IView {
private String TAG = “Lifecycle_Test”;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_lifecycle_test);
//Lifecycle 生命周期
// getLifecycle().addObserver(new MyObserver());
//MVP中使用Lifecycle
getLifecycle().addObserver(new MyPresenter(this));
Log.i(TAG, "onCreate: ");
}
@Override
protected void onResume() {
super.onResume();
Log.i(TAG, "onResume: ");
}
@Override
protected void onPause() {
super.onPause();
Log.i(TAG, "onPause: ");
}
@Override
public void showView() {}
@Override
public void hideView() {}
}
//Presenter
class MyPresenter implements LifecycleObserver {
private static final String TAG = “Lifecycle_Test”;
private final IView mView;
public MyPresenter(IView view) {mView = view;}
@OnLifecycleEvent(value = Lifecycle.Event.ON_START)
private void getDataOnStart(LifecycleOwner owner){
Log.i(TAG, "getDataOnStart: ");
Util.checkUserStatus(result -> {
//checkUserStatus是耗时操作,回调后检查当前生命周期状态
if (owner.getLifecycle().getCurrentState().isAtLeast(STARTED)) {
start();
mView.showView();
}
});
}
@OnLifecycleEvent(value = Lifecycle.Event.ON_STOP)
private void hideDataOnStop(){
Log.i(TAG, "hideDataOnStop: ");
stop();
mView.hideView();
}
}
//IView
interface IView {
void showView();
void hideView();
}
这里是让Presenter实现LifecycleObserver接口,同样在方法上注解要触发的生命周期,最后在Activity中作为观察者添加到Lifecycle中。
这样做好处是啥呢? 当Activity生命周期发生变化时,MyPresenter就可以感知并执行方法,不需要在MainActivity的多个生命周期方法中调用MyPresenter的方法了。
- 所有方法调用操作都由组件本身管理:Presenter类自动感知生命周期,如果需要在其他的Activity/Fragment也使用这个Presenter,只需添加其为观察者即可。
- 让各个组件存储自己的逻辑,减轻Activity/Fragment中代码,更易于管理;
另外,注意到 getDataOnStart()中耗时校验回调后,对当前生命周期状态进行了检查:至少处于STARTED状态才会继续执行start()方法,也就是保证了Activity停止后不会走start()方法;
更多: www.jianshu.com/p/f300279d1…
1.4 生命周期感知型组件的最佳做法
- 使界面控制器(Activity 和 Fragment)尽可能保持精简。它们不应试图获取自己的数据,而应使用
ViewModel
执行此操作,并观察LiveData
对象以将更改体现到视图中。 - 设法编写数据驱动型界面,对于此类界面,界面控制器的责任是随着数据更改而更新视图,或者将用户操作通知给
ViewModel
。 - 将数据逻辑放在
ViewModel
类中。ViewModel
应充当界面控制器与应用其余部分之间的连接器。不过要注意,ViewModel
不负责获取数据(例如,从网络获取)。但是,ViewModel
应调用相应的组件来获取数据,然后将结果提供给界面控制器。 - 使用数据绑定在视图与界面控制器之间维持干净的接口。这样一来,您可以使视图更具声明性,并尽量减少需要在 Activity 和 Fragment 中编写的更新代码。如果您更愿意使用 Java 编程语言执行此操作,请使用诸如 Butter Knife 之类的库,以避免样板代码并实现更好的抽象化。
- 如果界面很复杂,不妨考虑创建 presenter 类来处理界面的修改。这可能是一项艰巨的任务,但这样做可使界面组件更易于测试。
- 避免在
ViewModel
中引用View
或Activity
上下文。如果ViewModel
存在的时间比 Activity 更长(在配置更改的情况下),Activity 将泄漏并且不会获得垃圾回收器的妥善处置。 - 使用 Kotlin 协程管理长时间运行的任务和其他可以异步运行的操作。
1.4.1 案例
生命周期感知型组件可使您在各种情况下更轻松地管理生命周期。下面列举几个例子:
- 在粗粒度和细粒度位置更新之间切换。使用生命周期感知型组件可在位置应用可见时启用细粒度位置更新,并在应用位于后台时切换到粗粒度更新。借助生命周期感知型组件
LiveData
,应用可以在用户使用位置发生变化时自动更新界面。 - 停止和开始视频缓冲。使用生命周期感知型组件可尽快开始视频缓冲,但会推迟播放,直到应用完全启动。此外,应用销毁后,您还可以使用生命周期感知型组件终止缓冲。
- 开始和停止网络连接。借助生命周期感知型组件,可在应用位于前台时启用网络数据的实时更新(流式传输),并在应用进入后台时自动暂停。
- 暂停和恢复动画可绘制资源。借助生命周期感知型组件,可在应用位于后台时暂停动画可绘制资源,并在应用位于前台后恢复可绘制资源。
最后
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数初中级Android工程师,想要提升技能,往往是自己摸索成长,自己不成体系的自学效果低效漫长且无助。
因此我收集整理了一份《2024年Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点!不论你是刚入门Android开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
片转存中…(img-zqCiZG8A-1715756635379)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点!不论你是刚入门Android开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!