jetpack--Lifecycle 扩展(1)

最新推荐文章于 2024-11-04 11:45:54 发布

bp粉

最新推荐文章于 2024-11-04 11:45:54 发布

阅读量715

点赞数 13

分类专栏：程序员文章标签： android

本文链接：https://blog.csdn.net/m0_67392182/article/details/137562564

版权

程序员专栏收录该内容

71 篇文章 0 订阅

订阅专栏

postDispatchRunnable(Lifecycle.Event.ON_START);
}

//service onStart/onStartCommand onServicePreSuperOnStart 分发 ON_START 事件，在service 调用super.OnStart之前
public void onServicePreSuperOnStart() {
postDispatchRunnable(Lifecycle.Event.ON_START);
}

//service onDestroy onServicePreSuperOnDestroy 分发 ON_STOP/ON_DESTROY 事件，在service 调用super.OnDestroy之前
public void onServicePreSuperOnDestroy() {
postDispatchRunnable(Lifecycle.Event.ON_STOP);
postDispatchRunnable(Lifecycle.Event.ON_DESTROY);
}

/**

@return {@link Lifecycle} for the given {@link LifecycleOwner}
*/
@NonNull
public Lifecycle getLifecycle() {
return mRegistry;
}

static class DispatchRunnable implements Runnable {
private final LifecycleRegistry mRegistry;
final Lifecycle.Event mEvent;
private boolean mWasExecuted = false;

DispatchRunnable(@NonNull LifecycleRegistry registry, Lifecycle.Event event) {
mRegistry = registry;
mEvent = event;
}

@Override
public void run() {
if (!mWasExecuted) {
mRegistry.handleLifecycleEvent(mEvent);
mWasExecuted = true;
}
}
}
}

小结

LifeCycleService借助ServiceLifecycleDispatcher 来进行LifeCycle的获取和事件分发。

Service.OnCreate 中会触发分发ON_CTEATE 事件

Service.OnStart/onStartCommand/OnBind 中会触发分发 ON_START 事件

Service.onDestroy 会触发分发 ON_STOP 、ON_DESTROY 事件

二、ProcessLifecycleOwner

public class ProcessLifecycleOwner implements LifecycleOwner {

@VisibleForTesting
static final long TIMEOUT_MS = 700; //mls

//记录start的activity的数量
private int mStartedCounter = 0;
//记录 resume 的activity 的数量
private int mResumedCounter = 0;
//是否发送了应用pause 事件
private boolean mPauseSent = true;
//是否发送了应用Stop事件
private boolean mStopSent = true;

private Handler mHandler;

private final LifecycleRegistry mRegistry = new LifecycleRegistry(this);
//事件分发任务
private Runnable mDelayedPauseRunnable = new Runnable() {
@Override
public void run() {
dispatchPauseIfNeeded();
dispatchStopIfNeeded();
}
};
//activity 初始化监听只监听了 onCreate onStart onResume
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();

//返回单例
@NonNull
public static LifecycleOwner get() {
return sInstance;
}
//关联context,初始化
static void init(Context context) {
sInstance.attach(context);
}
//分发应用ON_START 事件 start 的 activity 数量等于1 且且mStopSent 是true
void activityStarted() {
mStartedCounter++;
if (mStartedCounter == 1 && mStopSent) {
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
mStopSent = false;
}
}

//分发应用ON_RESUME 事件 resume 的 activity 数量等于1 且且mPanseSent 是true,如果mPauseSent 不为true,移除即将要发送的 mDelayedPauseRunnable
void activityResumed() {
mResumedCounter++;
if (mResumedCounter == 1) {
if (mPauseSent) {
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
mPauseSent = false;
} else {
mHandler.removeCallbacks(mDelayedPauseRunnable);
}
}
}

//mResumedCounter 等于 0 的时候延时700 ms触发 mDelayedPauseRunnable 任务
void activityPaused() {
mResumedCounter–;
if (mResumedCounter == 0) {
mHandler.postDelayed(mDelayedPauseRunnable, TIMEOUT_MS);
}
}
//stop 时
void activityStopped() {
mStartedCounter–;
dispatchStopIfNeeded();
}
//如果mResumedCounter == 0 分发 ON_PAUSE 事件
void dispatchPauseIfNeeded() {
if (mResumedCounter == 0) {
mPauseSent = true;
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
}
}
//如果mStartedCounter == 0 且发送了onpause 则分发ON_STOP 事件
void dispatchStopIfNeeded() {
if (mStartedCounter == 0 && mPauseSent) {
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
mStopSent = true;
}
}
//私有构造函数
private ProcessLifecycleOwner() {
}
//attach 会触发分发onCreate事件，并在api >= 29时通过 activity.registerActivityLifecycleCallbacks 时感知acitivity 生命周期，<29时通过setProcessListener(mInitializationListener) 来感知
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 onActivityPreCreated(@NonNull Activity activity,
@Nullable Bundle savedInstanceState) {
activity.registerActivityLifecycleCallbacks(new EmptyActivityLifecycleCallbacks() {
@Override
public void onActivityPostStarted(@NonNull Activity activity) {
activityStarted();
}

@Override
public void onActivityPostResumed(@NonNull Activity activity) {
activityResumed();
}
});
}

@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {

if (Build.VERSION.SDK_INT < 29) {
ReportFragment.get(activity).setProcessListener(mInitializationListener);
}
}

@Override
public void onActivityPaused(Activity activity) {
activityPaused();
}

@Override
public void onActivityStopped(Activity activity) {
activityStopped();
}
});
}

@NonNull
@Override
public Lifecycle getLifecycle() {
return mRegistry;
}
}

//ReportFragment 会先进行 mProcessListener 的分发，然后进行ON_CREATE 分发
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
dispatchCreate(mProcessListener);
dispatch(Lifecycle.Event.ON_CREATE);
}
//activity 会先进行 dispatchActivityPreCreated 分发，然后是 fragment 的 dispatchActivityCreated，然后是 activity 的 onCreate
@UnsupportedAppUsage
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。