// ViewModel and LiveData
implementation “androidx.lifecycle:lifecycle-extensions:
l
i
f
e
c
y
c
l
e
v
e
r
s
i
o
n
"
/
/
a
l
t
e
r
n
a
t
i
v
e
l
y
−
j
u
s
t
V
i
e
w
M
o
d
e
l
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
−
v
i
e
w
m
o
d
e
l
:
lifecycle_version" // alternatively - just ViewModel implementation "androidx.lifecycle:lifecycle-viewmodel:
lifecycleversion"//alternatively−justViewModelimplementation"androidx.lifecycle:lifecycle−viewmodel:lifecycle_version” // For Kotlin use lifecycle-viewmodel-ktx
// alternatively - just LiveData
implementation “androidx.lifecycle:lifecycle-livedata:
l
i
f
e
c
y
c
l
e
v
e
r
s
i
o
n
"
/
/
a
l
t
e
r
n
a
t
i
v
e
l
y
−
L
i
f
e
c
y
c
l
e
s
o
n
l
y
(
n
o
V
i
e
w
M
o
d
e
l
o
r
L
i
v
e
D
a
t
a
)
.
S
o
m
e
U
I
/
/
A
n
d
r
o
i
d
X
l
i
b
r
a
r
i
e
s
u
s
e
t
h
i
s
l
i
g
h
t
w
e
i
g
h
t
i
m
p
o
r
t
f
o
r
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
−
r
u
n
t
i
m
e
:
lifecycle_version" // alternatively - Lifecycles only (no ViewModel or LiveData). Some UI // AndroidX libraries use this lightweight import for Lifecycle implementation "androidx.lifecycle:lifecycle-runtime:
lifecycleversion"//alternatively−Lifecyclesonly(noViewModelorLiveData).SomeUI//AndroidXlibrariesusethislightweightimportforLifecycleimplementation"androidx.lifecycle:lifecycle−runtime:lifecycle_version”
annotationProcessor “androidx.lifecycle:lifecycle-compiler: l i f e c y c l e v e r s i o n " / / F o r K o t l i n u s e k a p t i n s t e a d o f a n n o t a t i o n P r o c e s s o r / / a l t e r n a t e l y − i f u s i n g J a v a 8 , u s e t h e f o l l o w i n g i n s t e a d o f 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" // For Kotlin use kapt instead of annotationProcessor // alternately - if using Java8, use the following instead of lifecycle-compiler implementation "androidx.lifecycle:lifecycle-common-java8: lifecycleversion"//ForKotlinusekaptinsteadofannotationProcessor//alternately−ifusingJava8,usethefollowinginsteadoflifecycle−compilerimplementation"androidx.lifecycle:lifecycle−common−java8:lifecycle_version”
// optional - ReactiveStreams support for LiveData
implementation “androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version” // For Kotlin use lifecycle-reactivestreams-ktx
// optional - Test helpers for LiveData
testImplementation “androidx.arch.core:core-testing:$lifecycle_version”
}
官网用的是AndroidX,因为使用AndroidX,可能会产生一些迁移的问题,这里的举例就不使用AndroidX,而是使用lifecycleandroid.arch.lifecycle库,如下所示。
dependencies {
def lifecycle_version = “1.1.1”
// 包含ViewModel和LiveData
implementation “android.arch.lifecycle:extensions:
l
i
f
e
c
y
c
l
e
v
e
r
s
i
o
n
"
/
/
仅仅包含
V
i
e
w
M
o
d
e
l
i
m
p
l
e
m
e
n
t
a
t
i
o
n
"
a
n
d
r
o
i
d
.
a
r
c
h
.
l
i
f
e
c
y
c
l
e
:
v
i
e
w
m
o
d
e
l
:
lifecycle_version" // 仅仅包含ViewModel implementation "android.arch.lifecycle:viewmodel:
lifecycleversion"//仅仅包含ViewModelimplementation"android.arch.lifecycle:viewmodel:lifecycle_version” // For Kotlin use viewmodel-ktx
// 仅仅包含LiveData
implementation “android.arch.lifecycle:livedata:
l
i
f
e
c
y
c
l
e
v
e
r
s
i
o
n
"
/
/
仅仅包含
L
i
f
e
c
y
c
l
e
s
i
m
p
l
e
m
e
n
t
a
t
i
o
n
"
a
n
d
r
o
i
d
.
a
r
c
h
.
l
i
f
e
c
y
c
l
e
:
r
u
n
t
i
m
e
:
lifecycle_version" // 仅仅包含Lifecycles implementation "android.arch.lifecycle:runtime:
lifecycleversion"//仅仅包含Lifecyclesimplementation"android.arch.lifecycle:runtime:lifecycle_version”
annotationProcessor “android.arch.lifecycle:compiler: l i f e c y c l e v e r s i o n " / / F o r K o t l i n u s e k a p t i n s t e a d o f a n n o t a t i o n P r o c e s s o r / / 如果用 J a v a 8 , 用于替代 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 . a r c h . l i f e c y c l e : c o m m o n − j a v a 8 : lifecycle_version" // For Kotlin use kapt instead of annotationProcessor // 如果用Java8, 用于替代compiler implementation "android.arch.lifecycle:common-java8: lifecycleversion"//ForKotlinusekaptinsteadofannotationProcessor//如果用Java8,用于替代compilerimplementation"android.arch.lifecycle:common−java8:lifecycle_version”
// 可选,ReactiveStreams对LiveData的支持
implementation “android.arch.lifecycle:reactivestreams:$lifecycle_version”
// 可选,LiveData的测试
testImplementation “android.arch.core:core-testing:$lifecycle_version”
}
实际上我们不需要全部把这些代码全写进build.gralde进去(当然全写进去也不会有什么错),因为Gradle默认是支持依赖传递的,不知道什么是依赖传递的看Android Gradle (二)签名配置和依赖管理这篇文章。
我们直接添加如下依赖就可以满足日常的工作,如果缺少哪个库,再去单独添加就好了。
2.2 Lifecycle基本用法
先不谈Activity和Fragment中如何使用,先举一个Lifecycle的简单例子。
public class MyObserver implements LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
public void connectListener() {
…
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
public void disconnectListener() {
…
}
}
myLifecycleOwner.getLifecycle().addObserver(new MyObserver());//1
新建一个MyObserver类,它实现了LifecycleObserver接口,说明MyObserver成为了一个Lifecycle的观察者。
然后在注释1处将MyObserver添加到LifecycleOwner中。LifecycleOwner是一个接口,其内部只有一个方法getLifecycle(),getLifecycle方法用于获取Lifecycle,这样就可以将MyObserver添加到Lifecycle中,当Lifecycle的生命周期发生变化时,MyObserver就会观察到,或者说是感知到。
如果使用是Java8 ,那么可以使用DefaultLifecycleObserver来替代LifecycleObserver:
class MyObserver implements DefaultLifecycleObserver {
@Override
public void onCreate(LifecycleOwner owner) {
…
}
}
除此之外,不要忘了在build.gradle添加 "androidx.lifecycle:common-java8:<version>"
3.Lifecycle应用举例
应用举例准备两个示例,一个是在Activity中使用,一个是在第一小节的MVP例子上进行改进。
3.1 Activity中使用
package com.example.lifecycledemo1;
import android.arch.lifecycle.Lifecycle;
import android.arch.lifecycle.LifecycleObserver;
import android.arch.lifecycle.OnLifecycleEvent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
public class MainActivity extends AppCompatActivity {
private static final String TAG = “MainActivity”;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
getLifecycle().addObserver(new MyObserver());//1
}
public class MyObserver implements LifecycleObserver{
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
void onResume(){
Log.d(TAG, “Lifecycle call onResume”);
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
void onPause(){
Log.d(TAG, “Lifecycle call onPause”);
}
}
@Override
protected void onResume() {
super.onResume();
Log.d(TAG, “onResume”);
}
@Override
protected void onPause() {
super.onPause();
Log.d(TAG, “onPause”);
}
}
先实现MyObserver,对ON_CREATE和ON_RESUME事件进行监听。因为在Android Support Library 26.1.0 及其之后的版本,Activity和Fragment已经默认实现了LifecycleOwner接口,所以在注释1处可以直接使用getLifecycle方法获取Lifecycle对象,这样MyObserver就可以观察MainActivity的生命周期变化了,LifecycleOwner可以理解为被观察者,MainActivity默认实现了LifecycleOwner接口,也就是说MainActivity是被观察者。
运行程序,打印的log如下所示。
D/MainActivity: onResume
D/MainActivity: Lifecycle call onResume
D/MainActivity: Lifecycle call onPause
D/MainActivity: onPause
只要在MainActivity的onCreate方法中添加MyObserver,那么MyObserver就可以观察到MainActivity的各个生命周期的变化。
3.2 MVP中使用
改写第一小节MVP的例子,先实现MyPresenter,如下所示。
public class MyPresenter implements IPresenter {
private static final String TAG = “test”;
@Override
public void onResume() {
Log.d(TAG, “Lifecycle call onResume”);
}
@Override
public void onPause() {
Log.d(TAG, “Lifecycle call onPause”);
}
}
interface IPresenter extends LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
void onResume();
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
void onPause();
}
IPresenter接口继承自LifecycleObserver接口,MyPresenter又实现了IPresenter接口,这样MyPresenter成为了一个观察者。
接在在MainActivity中加入MyPresenter:
public class MainActivity extends AppCompatActivity {
private static final String TAG = “test”;
private IPresenter mPresenter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mPresenter = new MyPresenter();
getLifecycle().addObserver(mPresenter);
}
@Override
protected void onResume() {
super.onResume();
Log.d(TAG, “onResume”);
}
@Override
protected void onPause() {
super.onPause();
Log.d(TAG, “onPause”);
}
}
MainActivity成为了被观察者,当它的生命周期发生变化时,MyPresenter就可以观察到,这样就不需要在MainActivity的多个生命周期方法中调用MyPresenter的方法了。
打印的日志如下:
D/test: onResume
D/test: Lifecycle call onResume
D/test: Lifecycle call onPause
D/test: onPause
4.自定义LifecycleOwner
如果想实现自定义LifecycleOwner,可以使用LifecycleRegistry,它是Lifecycle的实现类。Android Support Library 26.1.0及其之后的版本,Activity和Fragment已经默认实现了LifecycleOwner接口,因此我们可以这么写:
import android.arch.lifecycle.Lifecycle;
import android.arch.lifecycle.LifecycleRegistry;
import android.support.annotation.NonNull;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
public class MyActivity extends AppCompatActivity {
private LifecycleRegistry lifecycleRegistry;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数初中级Android工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则近万的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注:Android)
结尾
最后,针对上面谈的内容,给大家推荐一个Android资料,应该对大家有用。
首先是一个知识清单:(对于现在的Android及移动互联网来说,我们需要掌握的技术)
泛型原理丶反射原理丶Java虚拟机原理丶线程池原理丶
注解原理丶注解原理丶序列化
Activity知识体系(Activity的生命周期丶Activity的任务栈丶Activity的启动模式丶View源码丶Fragment内核相关丶service原理等)
代码框架结构优化(数据结构丶排序算法丶设计模式)
APP性能优化(用户体验优化丶适配丶代码调优)
热修复丶热升级丶Hook技术丶IOC架构设计
NDK(c编程丶C++丶JNI丶LINUX)
如何提高开发效率?
MVC丶MVP丶MVVM
微信小程序
Hybrid
Flutter
接下来是资料清单:(敲黑板!!!)
1.数据结构和算法
2.设计模式
3.全套体系化高级架构视频;七大主流技术模块,视频+源码+笔记
4.面试专题资料包(怎么能少了一份全面的面试题总结呢~)
不论遇到什么困难,都不应该成为我们放弃的理由!共勉~
如果你看到了这里,觉得文章写得不错就给个赞呗?如果你觉得那里值得改进的,请给我留言。一定会认真查询,修正不足。谢谢。
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!
么能少了一份全面的面试题总结呢~)
[外链图片转存中…(img-2NIgLUxc-1713209274652)]
不论遇到什么困难,都不应该成为我们放弃的理由!共勉~
如果你看到了这里,觉得文章写得不错就给个赞呗?如果你觉得那里值得改进的,请给我留言。一定会认真查询,修正不足。谢谢。
[外链图片转存中…(img-2qiWlq0z-1713209274653)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!