在项目开发中，会涉及到像百度地图一样的sdk的使用，在使用百度定位的时候，在当前页面进行定位注册后，根据其文档需要在当前页面的onStart、onStop、onDestory等生命周期回调中进行定位的注册、注销等操作，如果重写当前页面的生命周期等方法，然后在生命周期中进行逻辑实现，会导致当前页面代码逻辑变的臃肿，并且基本没有解耦性；也可以自己写一个类，然后通过callback回调进行处理；
class MyLocationListener {
public MyLocationListener(Context context, Callback callback) {
// ...
}
void start() {
// connect to system location service
}
void stop() {
// disconnect from system location service
}
}
class MyActivity extends AppCompatActivity {
private MyLocationListener myLocationListener;
@Override
public void onCreate(...) {
myLocationListener = new MyLocationListener(this, (location) -> {
// update UI
});
}
@Override
public void onStart() {
super.onStart();
myLocationListener.start();
// manage other components that need to respond
// to the activity lifecycle
}
@Override
public void onStop() {
super.onStop();
myLocationListener.stop();
// manage other components that need to respond
// to the activity lifecycle
}
}
这样比起直接在activity中实现要好些了，但是其解耦性还是不怎么好；在jetpack中，google提供了一个生命周期感知型组件——Lifecyle。
Lifecyle是一个类，用于存储有关组件(如activity或者fragment)的生命周期状态的信息，并允许其他对象观察次状态，这些组件有助于编写出更有条理且往往更精简的代码，可以有效的实现activity和一些业务的解耦，更易于维护。
Lifecyle的使用也比较简单，通过实现LifecycleObserver接口，OnLifecycleEvent注解来关联对应的生命周期，在activity或者fragment中通过Lifecycle的addObserver方法添加注册。
dependencies {
def lifecycle_version = "2.3.0"
def arch_version = "2.1.0"
// ViewModel
implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
// LiveData
implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
// Lifecycles only (without ViewModel or LiveData)
implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"
// Saved state module for ViewModel
implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"
// Annotation processor
annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
// alternately - if using Java8, use the following instead of lifecycle-compiler
implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"
// optional - helpers for implementing LifecycleOwner in a Service
implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"
// optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"
// optional - ReactiveStreams support for LiveData
implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version"
// optional - Test helpers for LiveData
testImplementation "androidx.arch.core:core-testing:$arch_version"
}
上面是一些依赖库，根据实际的需要进行添加。
public interface LifecycleObserver {
}
LifecycleObserver目的是将一个类标记为LifecleObserver，它没有任何方法，通过依靠OnLifecycleEvent注释的方法；OnLifecycleEvent就是一个注解，通过Lifecycle中的Event枚举类标记对应的生命周期；
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OnLifecycleEvent {
Lifecycle.Event value();
}
public enum Event {
/**
* Constant for onCreate event of the {@link LifecycleOwner}.
*/
ON_CREATE,
/**
* Constant for onStart event of the {@link LifecycleOwner}.
*/
ON_START,
/**
* Constant for onResume event of the {@link LifecycleOwner}.
*/
ON_RESUME,
/**
* Constant for onPause event of the {@link LifecycleOwner}.
*/
ON_PAUSE,
/**
* Constant for onStop event of the {@link LifecycleOwner}.
*/
ON_STOP,
/**
* Constant for onDestroy event of the {@link LifecycleOwner}.
*/
ON_DESTROY,
/**
* An {@link Event Event} constant that can be used to match all events.
*/
ON_ANY
}
Event中的元素对应activity或者fragment中的对应的生命周期；通过Lifecycle中的addObserver方法对LifecycleObserver进行注册；
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
//获取当前的状态
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//将LifecycleObserver和State进行绑定关联
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//LifecycleObserver实例对象为key ObserverWithState为value 存储在HashMap中
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
if (previous != null) {
return;
}
//获取LifecycleOwner实例 LifecycleOwner是一个拥有安卓生命周期的接口 activity和fragment都实现了该接口
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
// it is null we should be destroyed. Fallback quickly
return;
}
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
//计算目标的State
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
//statefulObserver.mState.compareTo(targetState) 当前LifecycleObserver的State和目标的State大小比较
//mObserverMap.contains(observer) 到这里的话，LifecyclerObserver已经添加到HashMap中了
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
//进行状态的监听分发
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
popParentState();
// mState / subling may have been changed recalculate
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
// we do sync only on the top level.
sync();
}
mAddingObserverCounter--;
}
@Override
public V putIfAbsent(@NonNull K key, @NonNull V v) {
//从HashMap中直接获取 如果有就直接返回从HashMap中获取的
Entry current = get(key);
if (current != null) {
return current.mValue;
}
//添加的HashMap中进行保存
mHashMap.put(key, put(key, v));
return null;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
最终状态的改变会调用LifecycleEventObserver接口中的onStateChange方法，在系统的ComponentActivity的构造函数中，就注册了LifecycleEventObserver监听了；
public ComponentActivity() {
Lifecycle lifecycle = getLifecycle();
//noinspection ConstantConditions
if (lifecycle == null) {
throw new IllegalStateException("getLifecycle() returned null in ComponentActivity's "
+ "constructor. Please make sure you are lazily constructing your Lifecycle "
+ "in the first call to getLifecycle() rather than relying on field "
+ "initialization.");
}
if (Build.VERSION.SDK_INT >= 19) {
getLifecycle().addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_STOP) {
Window window = getWindow();
final View decor = window != null ? window.peekDecorView() : null;
if (decor != null) {
decor.cancelPendingInputEvents();
}
}
}
});
}
getLifecycle().addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_DESTROY) {
if (!isChangingConfigurations()) {
//如果不是因为配置改变导致activity销毁的话，在activity销毁时，就会去清空存储的ViewModel实例，
getViewModelStore().clear();
}
}
}
});
if (19 <= SDK_INT && SDK_INT <= 23) {
getLifecycle().addObserver(new ImmLeaksCleaner(this));
}
}
LifecycleObserver已经注册好了，同时对State、Event等状态也进行了监听，那么当activity或者fragment生命周期改变是时如何告知监听者的呢？找到系统的FragmentActivity，会看到
final LifecycleRegistry mFragmentLifecycleRegistry = new LifecycleRegistry(this);
LifecycleRegistry是Lifecycle的实现类，可以处理多个观察者，找的FragmentActivity中的onCreate方法，
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
mFragments.attachHost(null /*parent*/);
......
super.onCreate(savedInstanceState);
//进行onCreate生命周期的处理 会设置当前的状态并通知观察者
mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
mFragments.dispatchCreate();
}
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
//获取State状态
State next = getStateAfter(event);
moveToState(next);
}
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;
}
在getStateAfter中根据生命周期进行了State状态的划分；
static State getStateAfter(Event event) {
switch (event) {
case ON_CREATE:
case ON_STOP:
return CREATED;
case ON_START:
case ON_PAUSE:
return STARTED;
case ON_RESUME:
return RESUMED;
case ON_DESTROY:
return DESTROYED;
case ON_ANY:
break;
}
throw new IllegalArgumentException("Unexpected event value " + event);
}
可以看到onCreate和onStop是一致的，onStart和onPause是一致的，而对于State来说STARTED和RESUMED是处于活跃状态，其他的处于非活跃状态，得到State状态后，就会和之前保存的LifecycleObserver的状态进行对比，确定如何通知观察者；
private void sync() {
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
+ "garbage collected. It is too late to change lifecycle state.");
}
while (!isSynced()) {
mNewEventOccurred = false;
// no need to check eldest for nullability, because isSynced does it for us.
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
Entry newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
mNewEventOccurred = false;
}
最终都是通过LifecycleObserver的onStateChanged方法回调通知的，onStart、onPause等生命周期中也都是一样的都是通过LifecycleRegistry实例中的handleLifecycleEvent方法去通知观察者activity或者fragment生命周期改变的；
@Override
protected void onPause() {
super.onPause();
mResumed = false;
mFragments.dispatchPause();
mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
}
不过在使用的时候会发现如果继承的是AppCompactActivity或者FragmentActivity时，系统已经给实现这些了，可以通过
getLifecycle().addObserver(new MyObserver());
这样子进行注册，然后在对应的生命周期也都做了对应的处理，但是系统的Activity并没有实现LifeycleOwner接口，不过可以实现自定义的LifecycleOwner；
public class MyActivity extends Activity implements LifecycleOwner {
private LifecycleRegistry lifecycleRegistry;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
lifecycleRegistry = new LifecycleRegistry(this);
lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
@Override
protected void onStart() {
super.onStart();
lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
}
@Override
protected void onStop() {
super.onStop();
lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
}
@Override
protected void onResume() {
super.onResume();
lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
}
@Override
protected void onPause() {
super.onPause();
lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
}
@Override
protected void onDestroy() {
super.onDestroy();
lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
}
@NonNull
@Override
public Lifecycle getLifecycle() {
return lifecycleRegistry;
}
}
然后后面的activity继承自MyActivity就可以了，这样就可以正常使用Lifecycle了，Fragment也是一样的，实现了LifecycleOwner接口，并在构造函数中初始化了LifecycleRegistry实例，
private void initLifecycle() {
mLifecycleRegistry = new LifecycleRegistry(this);
mSavedStateRegistryController = SavedStateRegistryController.create(this);
if (Build.VERSION.SDK_INT >= 19) {
mLifecycleRegistry.addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_STOP) {
if (mView != null) {
mView.cancelPendingInputEvents();
}
}
}
});
}
}
然后在对应的生命周期通过handleLifecycleEvent方法通知观察者，不过需要注意的是它的调用并不是在生命周期回调方法中，而是在performCreate或者performStart等方法中；
void performCreate(Bundle savedInstanceState) {
mChildFragmentManager.noteStateNotSaved();
mState = CREATED;
mCalled = false;
mSavedStateRegistryController.performRestore(savedInstanceState);
onCreate(savedInstanceState);
mIsCreated = true;
if (!mCalled) {
throw new SuperNotCalledException("Fragment " + this
+ " did not call through to super.onCreate()");
}
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
这样Lifecycle就可以轻松的感知activity和fragment的生命周期了。