private val context: Context,
private val lifecycle: Lifecycle,
private val callback: (Location) -> Unit
): LifecycleObserver {
private var enabled = false
@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun start() {
if (enabled) {
// connect
}
}
fun enable() {
enabled = true
if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
// connect if not connected
}
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun stop() {
// disconnect if connected
}
}
复制代码
对于此实现，LocationListener 类可以完全感知生命周期。如果我们需要从另一个 Activity 或 Fragment 使用 LocationListener，只需对其进行初始化。所有设置和拆解操作都由类本身管理。
如果您尝试管理整个应用进程的生命周期，请参阅 ProcessLifecycleOwner。
Applicaiton 生命周期 ProcessLifecycleOwner
通常我们判断在应用是不是处于前后台的做法是：注册一个 registerActivityLifecycleCallbacks(callback)，然后在 callback 中利用一个全局变量做计数，在onActivityStarted()中计数加1，在onActivityStopped方法中计数减1，从而判断前后台切换。
而使用ProcessLifecycleOwner可以直接获取应用前后台切换状态（记得先引入lifecycle-process依赖）。使用方式和Activity 中类似，只不过要使用 ProcessLifecycleOwner.get() 获取 ProcessLifecycleOwner，代码如下：
public class MyApplication extends Application {
@Override
public void onCreate() {
super.onCreate();
//注册App生命周期观察者
ProcessLifecycleOwner.get().getLifecycle().addObserver(new ApplicationLifecycleObserver());
}
/**
Application生命周期观察，提供整个应用进程的生命周期 Lifecycle.Event.ON_CREATE只会分发一次，Lifecycle.Event.ON_DESTROY不会被分发。 第一个Activity进入时，ProcessLifecycleOwner将分派Lifecycle.Event.ON_START, Lifecycle.Event.ON_RESUME。 而Lifecycle.Event.ON_PAUSE, Lifecycle.Event.ON_STOP，将在最后一个Activit退出后后延迟分发。如果由于配置更改而销毁并重新创建活动，则此延迟足以保证ProcessLifecycleOwner不会发送任何事件。 作用：监听应用程序进入前台或后台
*/
private static class ApplicationLifecycleObserver implements LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_START)
private void onAppForeground() {
Log.w(TAG, “ApplicationObserver: app moved to foreground”);
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
private void onAppBackground() {
Log.w(TAG, “ApplicationObserver: app moved to background”);
}
}
}
复制代码
实现自定义 LifecycleOwner
支持库 26.1.0 及更高版本中的 Fragment 和 Activity 已实现 LifecycleOwner接口。如果你有一个自定义类并希望使其成为 LifecycleOwner，可以使用 LifecycleRegistry类，但需要将事件转发到该类，代码如下：
class MyActivity : Activity(), LifecycleOwner {
private lateinit var lifecycleRegistry: LifecycleRegistry
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
lifecycleRegistry = LifecycleRegistry(this)
lifecycleRegistry.markState(Lifecycle.State.CREATED)
}
public override fun onStart() {
super.onStart()
lifecycleRegistry.markState(Lifecycle.State.STARTED)
}
override fun getLifecycle(): Lifecycle {
return lifecycleRegistry
}
}
复制代码
该 MainActivty 是实现了 Activity 类，而不是 AppcompatActivity（FragmentActivity） 类，所以需要这样的处理。我们来看看 FragmentActivity 中的源码，比如 onCreate方法和 onPause方法
public class FragmentActivity extends ComponentActivity implements
ActivityCompat.OnRequestPermissionsResultCallback,
ActivityCompat.RequestPermissionsRequestCodeValidator {
/**
A {@link Lifecycle} that is exactly nested outside of when the FragmentController has its state changed, providing the proper nesting of Lifecycle callbacks TODO(b/127528777) Drive Fragment Lifecycle with LifecycleObserver
*/
final LifecycleRegistry mFragmentLifecycleRegistry = new LifecycleRegistry(this);
protected void onCreate(@Nullable Bundle savedInstanceState) {
···
mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
···
}
@Override
protected void onPause() {
super.onPause();
···
mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
}
}
//ComponentActivity.java
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
LifecycleOwner,
ViewModelStoreOwner,
SavedStateRegistryOwner,
OnBackPressedDispatcherOwner {
复制代码
明白了基本的操作，我们再看看看源码是如何实现的，注意，本文不会仔细深究源码，而是梳理一个大概的思路，如果想要讲具体深入每个细节，则可以照着我这个思路深入研究。
源码分析
Lifecycle 五种状态对应六个事件（生命周期）
首先我们来看 Lifecycle 这个类，让脑子里面有一个大致的概念
public abstract class Lifecycle {
/**
Lifecycle coroutines extensions stashes the CoroutineScope into this field. @hide used by lifecycle-common-ktx
*/
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
@NonNull
AtomicReference mInternalScopeRef = new AtomicReference<>();
// 添加观察者
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);
// 移除观察者
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);
@MainThread
@NonNull
public abstract State getCurrentState(); // 获取当前状态，共五种状态
@SuppressWarnings(“WeakerAccess”)
public enum Event { //对应六个生命周期方法，还多个一个 ON_ANY，可以响应任何事件
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY
}
/**
Lifecycle states. You can consider the states as the nodes in a graph and {@link Event}s as the edges between these nodes.
*/
@SuppressWarnings(“WeakerAccess”)
public enum State { //五种状态，对应生命周期的方法/Event 方法
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}
复制代码
如果你觉得还不够清楚，只需要要记住五种状态对应六个生命周期方法（六个事件，ON_ANY 可以忽略）。然后我们再来看看官方的图，五个状态对应六个生命周期方法，六个事件，这句话一定要记住。
Event 表示生命周期事件，与 Activity/Fragment 生命周期方法对应。State 是 Lifecycle 这些生命周期对应的状态，为什么不直接用对应的生命周期设置对应的状态呢，而是设置了五个状态呢？原因很简单，因为 Lifecycle 不仅仅只是给自己用这些状态，还有 LiveData，ViewMode 等控件也会用到这些状态的进行逻辑判断，所以 Google 工程师做了更好的封装和管理。
//Lifecycle.class
{@link Event#ON_CREATE}, {@link Event#ON_START}, {@link Event#ON_RESUME} events in this class are dispatched after the {@link LifecycleOwner}'s related method returns. {@link Event#ON_PAUSE}, {@link Event#ON_STOP}, {@link Event#ON_DESTROY} events in this class are dispatched before the {@link LifecycleOwner}'s related method is called.
复制代码
Event 中的 ON_CREATE，ON_START，ON_RESUME 是在 LifecyclerOwner 对应的方法执行之后分发，ON_PAUSE，ON_STOP，ON_DESTROY 是在 LifecyclerOwner 对应的方法执行之前分发。
我们的 Activity 因为实现了 LifecycleOwner 才能直接调用 getLifecycle()，从前面的分析我们可以看到是在 ComponentActivity 中实现了该接口
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
LifecycleOwner,
ViewModelStoreOwner,
SavedStateRegistryOwner,
OnBackPressedDispatcherOwner {
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mSavedStateRegistryController.performRestore(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
if (mContentLayoutId != 0) {
setContentView(mContentLayoutId);
}
}
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
// LifecycleRegistry.java
public class LifecycleRegistry extends Lifecycle {
复制代码
getLifecycle().addObserver(MyObserver()) 是我们添加观察者的方式，我们来看看addObserver方法的实现，因为的实现是LifecycleRegistry
//LifecycleRegistry.java
@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);
if (previous != null) {
return;
}
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
// it is null we should be destroyed. Fallback quickly
return;
}
//下面代码的逻辑：通过while循环，把新的观察者的状态 连续地 同步到最新状态mState。
//意思就是：虽然可能添加的晚，但把之前的事件一个个分发给你(upEvent方法)，即粘性
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
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–;
}
复制代码
通过statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));分发事件，我们先来看ObserverWithState
static class ObserverWithState {
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
//分发，通知观察者
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
复制代码
mLifecycleObserver的值为Lifecycling.lifecycleEventObserver(observer);，然后查看方法lifecycleEventObserver
@NonNull
static LifecycleEventObserver lifecycleEventObserver(Object object) {
boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
···
return new ReflectiveGenericLifecycleObserver(object);
}
复制代码
查看最后一行中的ReflectiveGenericLifecycleObserver
class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
private final Object mWrapped;
private final CallbackInfo mInfo;
ReflectiveGenericLifecycleObserver(Object wrapped) {
mWrapped = wrapped;
mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass()); //存放了注解方法的信息
}
@Override
public void onStateChanged(LifecycleOwner source, Event event) {
mInfo.invokeCallbacks(source, event, mWrapped); //执行状态变化对应的方法
}
}
复制代码
getInfo的内容如下：
CallbackInfo getInfo(Class klass) {
CallbackInfo existing = mCallbackMap.get(klass);
if (existing != null) {
return existing;
}
existing = createInfo(klass, null);
return existing;
}
复制代码
处理注解
接下来是重要方法createInfo，在该方法中进行注解的处理，并存储到 mCallbackMap。提供给后面的观察者调用
//createInfo,遍历方法 处理注解，将
private CallbackInfo createInfo(Class klass, @Nullable Method[] declaredMethods) {
Class superclass = klass.getSuperclass();
Map
if (superclass != null) {
CallbackInfo superInfo = getInfo(superclass);
if (superInfo != null) {
handlerToEvent.putAll(superInfo.mHandlerToEvent);
}
}
Class[] interfaces = klass.getInterfaces();
for (Class intrfc : interfaces) {
for (Map.Entry
intrfc).mHandlerToEvent.entrySet()) {
verifyAndPutHandler(handlerToEvent, entry.getKey(), entry.getValue(), klass);
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）
如果你进阶的路上缺乏方向，可以加入我们的圈子和安卓开发者们一起学习交流！
Android进阶学习全套手册 Android对标阿里P7学习视频 BATJ大厂Android高频面试题
最后，借用我最喜欢的乔布斯语录，作为本文的结尾：
人这一辈子没法做太多的事情，所以每一件都要做得精彩绝伦。 你的时间有限，所以不要为别人而活。不要被教条所限，不要活在别人的观念里。不要让别人的意见左右自己内心的声音。 最重要的是，勇敢的去追随自己的心灵和直觉，只有自己的心灵和直觉才知道你自己的真实想法，其他一切都是次要。
img-lcZcV9oL-1711809315595)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android） [外链图片转存中…(img-xWSJ7Epf-1711809315595)]
如果你进阶的路上缺乏方向，可以加入我们的圈子和安卓开发者们一起学习交流！
Android进阶学习全套手册 [外链图片转存中…(img-A2pq5jQ1-1711809315596)] Android对标阿里P7学习视频 [外链图片转存中…(img-WhVx0t5i-1711809315596)] BATJ大厂Android高频面试题 [外链图片转存中…(img-j6v65kiI-1711809315596)]
最后，借用我最喜欢的乔布斯语录，作为本文的结尾：
人这一辈子没法做太多的事情，所以每一件都要做得精彩绝伦。 你的时间有限，所以不要为别人而活。不要被教条所限，不要活在别人的观念里。不要让别人的意见左右自己内心的声音。 最重要的是，勇敢的去追随自己的心灵和直觉，只有自己的心灵和直觉才知道你自己的真实想法，其他一切都是次要。
本文已被CODING开源项目：《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》收录
推荐链接
您阅读本篇文章共花了：
发表评论