一、Android Jetpack
对于任何一个产品来说,我们开发中都会面对哪些问题?如:产品交互、用户体验、代码结构、数据获取、数据存储、网络优化、任务调度等等,虽然在现在的阶段这些问题已经有了很好的解决和优化,也有很多大神的开源组件方便开发者去使用,Android Jetpack就是Google给出的一个官方的处理方法(当然知识处理其中基本问题),Android Jetpack组件的优势:
- 轻松管理应用程序的生命周期
- 构建可观察的数据对象,以便在基础数据库更改时通知视图
- 存储在应用程序轮换中未销毁的UI相关数据,在界面重建后恢复数据
- 轻松的实现SQLite数据库
- 系统自动调度后台任务的执行,优化使用性能
Android Jetpack组件推荐的使用项目架构
上面架构组件的功能如下:
- Activity和Fragment负责产品与用户的交互
- ViewModel作为数据的存储和驱动
- Resposity负责调度数据的获取
- Room储存本地序列化的数据
- Retrofit获取远程数据的数据
二、Android Jetpack组件介绍
应用程序的开发和产品与用户的交互都是从UI开始的,用户可见的和开发者操作的结果都显示在界面上,所以界面的操作在卡法中占据很重要的地位,也是影响我们开发和使用体验的重要部分,常见的问题如:UI的声明周期处理、数据的显示和刷新、注册监听的释放等, Jetpack架构组件就可以帮我们规范化的解决他们。
1.Lifecycler
Lifecycler是一个生命周期感知组件,执行操作以响应另一个组件(例如活动和片段)的生命周期状态的更改,简单来说它可以监听活动组件声明周期的变化,在每个声明周期执行相应的方法,不同于以往想在生命周期中执行相应的方法需要设置接口,然后在声明周期中回调接口,这样会造成代码的耦合,也会引发声明周期的问题
Lifecycler的原理:
Lifecycler为每个活动组件添加了一个没有界面的Fragment,利用Fragment周期会根据活动声明周期变化的特性实现的特性,从而实现生命周期的感知,然后根据注解的Event查找执行相应的方法。
2.LiveData
在产品的开发中我们都有必须的操作就是数据的更新,当用户执行某种操作或服务器数据发生改变后,都要重新获取数据再次刷新界面的UI,每改变一次就要重复一次,从代码封装的角度,有没有一种工具可以监听数据状态,在数据变化的时候自动更新UI呢?LiveData就提供了此项更能,从名字中可以看出这个Data时Live的,不是一个死数据,解决了数据展示和刷新的问题
LiveData原理:
内部保存了LifecycleOwner和Observer,利用LifecycleOwner感知并处理声明中期的变化,Observer在数据改变时遍历所有观察者并回调方法
3.ViewModel
如果你认为上面的方法只是对程序的开发有一点优化的话,那ViewModel的出现确实解决一个简单而又繁琐的问题,大家都知道用户在使用产品的过程中,可能随时会被中断或界面发生重建,如果数据的丢失会造成很差的用户体验,当然现在都知道在onSaveInstanceState()中保存数据,在界面重建时恢复数据,这种虽然可以解决问题,但会造成每个界面都要编写板寸和恢复的代码,而且数据量过大时会影响执行性能,VIewModel的出现就是解决这个问题,它会在活动重建时仍然保存数据,在活动创建完成后从中获取数据
ViewModel原理:
将数据保存到ViewModel中,然后为活动中添加一个HolderFragment,HolderFragment中保存了ViewStore的实例,ViewStore中使用Map保存了ViewModel,从而在活动重新创建时获取到原来的ViewModel
4.Paging
RecyclerView是项目中展示数据所必不可少的控件,伴随者列表展示而来的就是下拉加载,目前有很多开源的框架已支持下拉加载,主要分两种:
- 当滑动到最后一个Item时,触发加载更多的数据,此时用户会看到加载过程并等待加载完成
- 根据显示的position,在未到最后之前就去加载数据并刷新界面,这样用户可以流畅的滑动下去
Paging实现的原理:
简单来说就是在PageListAdapter中显示数据,然后根据显示的position确定是否需要加载数据,当触发加载数据时,PagedList调用DataSource中配置的方法加载数据,并将数据传递到Adapter刷新UI
5.Room
数据库在项目开发中起着至关重要的作用,所有的操作都在修改着数据,而数据的修改驱动UI更新,从而行成了产品的交互;在开发中如果使用Android原生的SQLite数据库,需要编写大量的样板代码,而Room组件可以让你使用几个注解,就可以省略大量的代码,同时支持更强大的数据库访问
Room的实现原理:
Room的实现原理其实是很多框架的实现方式,是一种代码注解,在编译时自动生成的方式如:ButterKnife框架。
6.Navigation
Navigation框架是Jetpack框架中新的组件,也是比较有意思的和创新的框架,它将程序中界面导航像layout文件一样可视化了,在xml中直接可以编辑和修改界面的导航,简化了应用中目标之间导航的实现,如:
7.WorkManger
WorkManger是Android Jetpack提供执行后台任务管理的组件,它适用于需要保证系统即使应用程序退出也会运行的任务,可以根据需求设定执行任务的条件,如:插入电源、空闲状态
三、Lifecycles管理生命周期
Lifecycles
是一个持有组件生命周期状态(如Activity、Fragment)信息的类,并允许其他对象观察此状态。可以帮助我们方便的管理Activity
和Fragment
的生命周期。
1.基本使用
在我们的日常开发中,经常需要我们在Activity或者Fragment的生命周期方法中手动去管理一下资源的释放等行为。举个简单的例子,当我们做自定义相机扫描的时候,camera相关的资源就需要我们手动的去释放及开启预览;或者我们在使用MVP模式去开发的时候,P的创建和销毁也需要我们在生命周期方法中去操作。
通过Lifecycles组件
我们可以这样使用:
我们可以定义一个Observer实现LifecycleObserver
,并且在Activity
或者Fragment
中进行观察:
/**
* created by ${Hankkin}
* on 2019-06-10
*/
class MyObserver : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun onStart() {
Log.e(javaClass.name, "-------onStart")
}
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreate() {
Log.e(javaClass.name, "-------onCreate")
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onResume() {
Log.e(javaClass.name, "-------onResume")
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
fun onPause() {
Log.e(javaClass.name, "-------onPause")
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun onStop() {
Log.e(javaClass.name, "-------onStop")
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun onDestroy() {
Log.e(javaClass.name, "-------onDestroy")
}
}
复制代码
下面是Activity:
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
lifecycle.addObserver(MyObserver())
Log.e(javaClass.name, "-------onCreate")
}
override fun onStart() {
super.onStart()
Log.e(javaClass.name, "-------onStart")
}
override fun onResume() {
super.onResume()
Log.e(javaClass.name, "-------onResume")
}
override fun onPause() {
super.onPause()
Log.e(javaClass.name, "-------onPause")
}
override fun onStop() {
super.onStop()
Log.e(javaClass.name, "-------onStop")
}
override fun onDestroy() {
super.onDestroy()
Log.e(javaClass.name, "-------onDestroy")
}
}
复制代码
启动Activity,我们可以看到控制台中的打印日志:
MainActivity: -------onCreate
MyObserver: -------onCreate
MainActivity: -------onStart
MyObserver: -------onStart
MainActivity: -------onResume
MyObserver: -------onResume
......
复制代码
通过控制台打印我们可以看到我们的观察者Activity和被观察者的日志均被打印了。具体是怎么实现的呢?
2.源码分析
通过代码我们大概能看出来Lifecycles
组件是通过观察者模式来实现的,接下来我们具体分析实现原理,我们发现在Activity
和Fragment
中可以直接通过getLifecycle()
方法获取到Lifecycle
,那么我们就从这里入手:
2.1getLifecycle()
我们点击进去发现ComponentActivity中实现了LifecycleOwner
接口,LifecycleOwner
接口中则声明了getLifecycle()
方法,而ComponentActivity中直接返回了mLifecycleRegistry:
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
LifecycleOwner,
ViewModelStoreOwner,
SavedStateRegistryOwner,
OnBackPressedDispatcherOwner {
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
......
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
复制代码
LifecycleRegistry
是个什么东西呢?原来它继承了Lifecycle
public class LifecycleRegistry extends Lifecycle
复制代码
2.2 Lifecycle和LifecycleRegistry
我们看一下Lifecycle类:
public abstract class Lifecycle {
//注册LifecycleObserver (比如Presenter)
public abstract void addObserver(@NonNull LifecycleObserver observer);
//移除LifecycleObserver
public abstract void removeObserver(@NonNull LifecycleObserver observer);
//获取当前状态
public abstract State getCurrentState();
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY
}
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}
复制代码
Lifecycle中就是声明了一些抽象方法和两个状态的枚举类,具体的实现看LifecycleRegistry:
public class LifecycleRegistry extends Lifecycle {
// LifecycleObserver Map,每一个Observer都有一个State
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = new FastSafeIterableMap<>();
// 当前的状态
private State mState;
// 生命周期拥有者,ComponentActivity继承了LifecycleOwner
private final WeakReference<LifecycleOwner> mLifecycleOwner;
//修改State值
private void moveToState(State next) {
if (mState == next) {
return;
}
mState = next;
if (mHandlingEvent || mAddingObserverCounter != 0) {
mNewEventOccurred = true;
// we will figure out what to do on upper level.
return;
}
mHandlingEvent = true;
sync();
mHandlingEvent = false;
}
/**
* 添加LifecycleObserver观察者,并将之前的状态分发给这个Observer,例如我们在onResume之后注册这个Observer,
* 该Observer依然能收到ON_CREATE事件
*/
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//新建带有状态的观察者
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
......
// 例如:Observer初始状态是INITIALIZED,当前状态是RESUMED,需要将INITIALIZED到RESUMED之间的
// 所有事件分发给Observer
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
popParentState();
targetState = calculateTargetState(observer);
}
......
}
/**
* 同步Observer状态,并分发事件
*/
private void sync() {
LifecycleOwner lfecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn't try dispatch "
+ "new events from it.");
return;
}
while (!isSynced()) {
mNewEventOccurred = false;
// State中,状态值是从DESTROYED-INITIALIZED-CREATED-STARTED-RESUMED增大
// 如果当前状态值 < Observer状态值,需要通知Observer减小状态值,直到等于当前状态值
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
// 如果当前状态值 > Observer状态值,需要通知Observer增大状态值,直到等于当前状态值
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
mNewEventOccurred = false;
}
/**
* 向前传递事件,对应图中的INITIALIZED -> RESUMED
* 增加Observer的状态值,直到状态值等于当前状态值
*/
private void forwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
mObserverMap.iteratorWithAdditions();
while (ascendingIterator.hasNext() && !mNewEventOccurred) {
Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
// 分发状态改变事件
observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
popParentState();
}
}
}
/**
* 向后传递事件,对应图中的RESUMED -> DESTROYED
* 减小Observer的状态值,直到状态值等于当前状态值
*/
private void backwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
mObserverMap.descendingIterator();
while (descendingIterator.hasNext() && !mNewEventOccurred) {
Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
Event event = downEvent(observer.mState);
// 分发状态改变事件
pushParentState(getStateAfter(event));
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}
复制代码
LifecycleRegistry
代码我门看完了,注释也已经很清楚了,基本作用就是添加观察者,响应生命周期事件,分发生命周期事件的作用。
2.3 ReportFragment
接下来我们继续分析ComponentActivity
,我们在onCreate()
声明周期中发现一个比较熟悉ReportFragment
,这个fragment我以前在做内存泄漏优化的时候经常碰到,在leakcanary中经常会报出这个类,所以这里面看看ReportFragment.injectIfNeededIn(this);
到底做了什么?
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP_PREFIX)
public class ReportFragment extends Fragment {
private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
+ ".LifecycleDispatcher.report_fragment_tag";
public static void injectIfNeededIn(Activity activity) {
// ProcessLifecycleOwner should always correctly work and some activities may not extend
// FragmentActivity from support lib, so we use framework fragments for activities
android.app.FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
// Hopefully, we are the first to make a transaction.
manager.executePendingTransactions();
}
}
private void dispatchCreate(ActivityInitializationListener listener) {
if (listener != null) {
listener.onCreate();
}
}
private void dispatchStart(ActivityInitializationListener listener) {
if (listener != null) {
listener.onStart();
}
}
private void dispatchResume(ActivityInitializationListener listener) {
if (listener != null) {
listener.onResume();
}
}
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
dispatchCreate(mProcessListener);
dispatch(Lifecycle.Event.ON_CREATE);
}
@Override
public void onStart() {
super.onStart();
dispatchStart(mProcessListener);
dispatch(Lifecycle.Event.ON_START);
}
@Override
public void onResume() {
super.onResume();
dispatchResume(mProcessListener);
dispatch(Lifecycle.Event.ON_RESUME);
}
@Override
public void onPause() {
super.onPause();
dispatch(Lifecycle.Event.ON_PAUSE);
}
@Override
public void onStop() {
super.onStop();
dispatch(Lifecycle.Event.ON_STOP);
}
@Override
public void onDestroy() {
super.onDestroy();
dispatch(Lifecycle.Event.ON_DESTROY);
// just want to be sure that we won't leak reference to an activity
mProcessListener = null;
}
private void dispatch(Lifecycle.Event event) {
Activity activity = getActivity();
if (activity instanceof LifecycleRegistryOwner) {
((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
return;
}
if (activity instanceof LifecycleOwner) {
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}
复制代码
查看源码我们发现,ReportFragment
在每个生命周期中都做了分发事件的处理,通过调用getLifecycle().handleLifecycleEvent(event)
来做生命周期的分发。意思也就是在ComponentActivity
中添加了一个没有页面的ReportFragment
,当Activity生命周期变化的时候,通过调用LifecycleRegistry.handleLifecycleEvent()
方法通知LifecycleRegistry改变状态,LifecycleRegistry内部调用moveToState()
改变状态,并调用每个LifecycleObserver.onStateChange()方法通知生命周期变化。
我们通过查看ReportFragment调用,发现还有两个类也调用了它,一个是
LifecycleDispatcher
,一个是ProcessLifecycleOwner
,这两个究竟是做什么的呢?
2.4 LifecycleDispatcher
class LifecycleDispatcher {
private static AtomicBoolean sInitialized = new AtomicBoolean(false);
static void init(Context context) {
if (sInitialized.getAndSet(true)) {
return;
}
((Application) context.getApplicationContext())
.registerActivityLifecycleCallbacks(new DispatcherActivityCallback());
}
@SuppressWarnings("WeakerAccess")
@VisibleForTesting
static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks {
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
ReportFragment.injectIfNeededIn(activity);
}
@Override
public void onActivityStopped(Activity activity) {
}
@Override
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
}
}
private LifecycleDispatcher() {
}
}
复制代码
我们查看源码,发现在init()
方法中,通过Application
注册了DispatcherActivityCallback
,并且在onActivityCreated
中将ReportFragment
注入到Activity中。
3.5 ProcessLifecycleOwner
public class ProcessLifecycleOwner implements LifecycleOwner {
private final LifecycleRegistry mRegistry = new LifecycleRegistry(this);
private Runnable mDelayedPauseRunnable = new Runnable() {
@Override
public void run() {
dispatchPauseIfNeeded();
dispatchStopIfNeeded();
}
};
private ActivityInitializationListener mInitializationListener =
new ActivityInitializationListener() {
@Override
public void onCreate() {
}
@Override
public void onStart() {
activityStarted();
}
@Override
public void onResume() {
activityResumed();
}
};
private static final ProcessLifecycleOwner sInstance = new ProcessLifecycleOwner();
public static LifecycleOwner get() {
return sInstance;
}
static void init(Context context) {
sInstance.attach(context);
}
void activityStarted() {
mStartedCounter++;
if (mStartedCounter == 1 && mStopSent) {
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
mStopSent = false;
}
}
void activityResumed() {
mResumedCounter++;
if (mResumedCounter == 1) {
if (mPauseSent) {
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
mPauseSent = false;
} else {
mHandler.removeCallbacks(mDelayedPauseRunnable);
}
}
}
......
private void dispatchStopIfNeeded() {
if (mStartedCounter == 0 && mPauseSent) {
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
mStopSent = true;
}
}
private ProcessLifecycleOwner() {
}
//监听Application生命周期,并分发给Activity
void attach(Context context) {
mHandler = new Handler();
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
Application app = (Application) context.getApplicationContext();
app.registerActivityLifecycleCallbacks(new EmptyActivityLifecycleCallbacks() {
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
ReportFragment.get(activity).setProcessListener(mInitializationListener);
}
@Override
public void onActivityPaused(Activity activity) {
activityPaused();
}
@Override
public void onActivityStopped(Activity activity) {
activityStopped();
}
});
}
}
复制代码
根据官方注释,可以了解到:
- ProcessLifecycleOwner是用来监听Application生命周期的,因此它只会分发一次ON_CREATE事件,并且不会分发ON_DESTROY事件。
- ProcessLifecycleOwner在Activity的onResume和onStop方法中都采用了Handle.postDelayed()方法,是为了处理Activity重建时比如横竖屏幕切换时,不会发送事件。
- ProcessLifecycleOwner一般用来判断应用是在前台还是后台。但由于使用了Handle.postDelayed(),因此这个判断不是即时的,有默认700ms的延迟。
- ProcessLifecycleOwner与LifecycleDispatcher一样,都是通过注册Application.registerActivityLifecycleCallbacks来监听Activity的生命周期回调,来给每个Activity添加ReportFragment的。
看了着两个类我们发现它们的入口均为init()
,所以看一下谁调用了?
2.5ProcessLifecycleOwnerInitializer
public class ProcessLifecycleOwnerInitializer extends ContentProvider {
@Override
public boolean onCreate() {
LifecycleDispatcher.init(getContext());
ProcessLifecycleOwner.init(getContext());
return true;
}
@Nullable
@Override
public Cursor query(@NonNull Uri uri, String[] strings, String s, String[] strings1,
String s1) {
return null;
}
@Nullable
@Override
public String getType(@NonNull Uri uri) {
return null;
}
@Nullable
@Override
public Uri insert(@NonNull Uri uri, ContentValues contentValues) {
return null;
}
@Override
public int delete(@NonNull Uri uri, String s, String[] strings) {
return 0;
}
@Override
public int update(@NonNull Uri uri, ContentValues contentValues, String s, String[] strings) {
return 0;
}
}
复制代码
在ProcessLifecycleOwnerInitializer
的onCreate()
中对这两个进行了初始化,看类名可以翻译成_进程生命周期初始化_,到这里我们对该类就找不到调用者或者使用者了,所以不得不百度一下,发现有人说这个类是在AndroidManifest.xml
中声明的,在构建APK过程中,AS会将多个模块的AndroidManifest.xml
合并到一起,所以查看build目录,具体路径为build/intermediates/bundle_manifest/debug/processDebugManifest/bundle-manifest/AndroidManifest.xml
,果真在里面:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.hankkin.reading_aac"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk
android:minSdkVersion="19"
android:targetSdkVersion="28" />
<application
android:appComponentFactory="androidx.core.app.CoreComponentFactory"
android:debuggable="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:testOnly="true"
android:theme="@style/AppTheme" >
<activity android:name="com.hankkin.reading_aac.ui.LoginActivity" >
</activity>
<activity android:name="com.hankkin.reading_aac.MainActivity" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<provider
android:name="androidx.lifecycle.ProcessLifecycleOwnerInitializer"
android:authorities="com.hankkin.reading_aac.lifecycle-process"
android:exported="false"
android:multiprocess="true" />
</application>
</manifest>
四、Lifecycle解析生命周期
我们可以大概给整个Lifecycle组件分为三部分:
4.1 Lifecycle的初始化
通过在manifest中声明provider,`ProcessLifecycleOwnerInitializer`注册Activity和fragment.的声明周期回调并做监听,同时向Activity中添加一个空白的`ReportFragment`,使用它作为生命周期的事件分发。而当Activity和Fragment生命周期状态发生改变时,都通过LifecycleRegistryOwner来处理生命周期状态的改变。
复制代码
4.2 Lifecycle的状态改变及状态分发
在`ReportFragment`中调用`LifecycleRegister.handleLifecycleEvent(Lifecycle.Event)`,通过**获取事件对应的下一个状态**以及**改变当前状态到下一个状态**,同步分发事件;最后将各个观察者的生命周期状态依次移动到正确状态。
复制代码
可以查看下面的时序图:
4.3 Lifecycle解析生命周期
我们声明的MyObserver中的方法都是带有注解的,查看OnLifecycleEvent
:
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OnLifecycleEvent {
Lifecycle.Event value();
}
复制代码
注解修饰的方法会通过反射的方式获取,并且保存在ClassesInfoCache
中,然后在生命周期发生改变的时候再找到对应 Event 的方法,通过反射来调用方法。
更多jetpack全家桶学习;尽在Jetpack与实战大厂架构深度讲解
五、总结
文章主要介绍Android Jetpack各种组件,以及各个原理;到Lifecycle源码解析再到它的管理生命周期。