综合技术

Lifecycle使用与分析-基础

微信扫一扫,分享到朋友圈

Lifecycle使用与分析-基础
0

Lifecycle是一个持有组件生命周期状态信息的类,并且允许其他对象观察该状态.

本文基于 Lifecycle 2.0.0版本,Android API 28.

首先我们先看一下如何使用Lifecycle实现生命周期的监听.

基础用法

public class HippoX implements LifecycleObserver {

    private static final String TAG_LOG = "HippoX";

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void init() {
        Log.e(TAG_LOG, "init exec");
    }
}
public class MainActivity extends AppCompatActivity {
    private static final String TAG_LOG = "HippoX";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        getLifecycle().addObserver(new HippoX());
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.e(TAG_LOG, "onResumes execute");
    }
}

Logcat日志:

E/HippoX: onResumes execute
E/HippoX: init exec

日志打印结果表明上述代码确实实现了观察生命周期的功能.

别问我为啥这样就监听成功了,往下看.

生命周期事件及状态

Lifecycle使用两个主要枚举来跟踪其关联组件的生命周期状态.

  • Event 描述从框架和Lifecycle类中派发的生命周期事件.
  • State 描述Lifecycle对象跟踪的组件的当前状态.

Lifecycle.Event

public enum Event {
       ON_CREATE,    //用于匹配生命周期所有者的onCreate事件.
       ON_START,     //用于匹配生命周期所有者的onStart事件.
       ON_RESUME,    //用于匹配生命周期所有者的onResume事件.
       ON_PAUSE,     //用于匹配生命周期所有者的onCreate事件.
       ON_STOP,      //用于匹配生命周期所有者的onStop事件.
       ON_DESTROY,   //用于匹配生命周期所有者的onDestroy事件.
       ON_ANY        //用于匹配生命周期所有者的所有事件.
   }

Lifecycle.State

public enum State {
       DESTROYED,    //表示生命周期所有者创建的状态.对于Activity来说,在onCreate执行之后,onStop执行之前.
       INITIALIZED,  //表示生命周期所有者销毁的状态.
       CREATED,      //表示生命周期所有者初始化的状态.
       STARTED,      //表示生命周期所有者恢复的状态.
       RESUMED;      //表示生命周期所有者启动的状态.
       
       public boolean isAtLeast(@NonNull State state) {    //比较此状态是否大于或等于给定状态
           return compareTo(state) >= 0;
       }
   }

Event与State的关系

lifecycle-states.png

生命周期所有者和观察者

LifecycleOwner 生命周期所有者

public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();   //返回lifecycle
}

官方文档的描述是持有Android生命周期的类,通过实现该类可以在非Activity和Fragment中来处理生命周期事件.

注:Activity和Fragment都实现了该接口,并提供

LifecycleObserver 生命周期观察者

public interface LifecycleObserver {

}

官方文档的描述是将实现该接口的类标记为生命周期观察者,且依赖于通过 OnLifecycleEvent 注解实现的方法.

先了解到这里,我们开始正式的分析lifecycle是如何实现生命周期的监听的.

Activity和Fragment的实现过程基本相同,我们在这里就分析Activity.

首先我们由MainActivity的 getLifecycle() 方法往里跟,最终找到他的父父父类 ComponentActivity 实现了 LifecycleOwner 接口.

public class ComponentActivity extends Activity
        implements LifecycleOwner, KeyEventDispatcher.Component {
        
    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
        
        ...
            @Override
    @SuppressWarnings("RestrictedApi")
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
    }
        
        
            @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }

        }

其中比较重要的是 LifecycleRegistry 类和 ReportFragment .我们再来继续分析.

LifecycleRegistry

LifecycleRegistry是Lifecycle的实现类,能够管理多个生命周期观察者.

提供的主要方法如下:

  • void addObserver(LifecycleObserver observer) 添加一个生命周期观察者(下文简称观察者),当生命周期所有者状态改变时将会进行通知.
  • Lifecycle.State getCurrentState() 获取生命周期的当前状态.
  • int getObserverCount() 返回观察者的个数.
  • void handleLifecycleEvent(Lifecycle.Event event) 设置当前状态并通知观察者.
  • void removeObserver(LifecycleObserver observer) 从观察者列表中移除指定的观察者.
  • void setCurrentState(Lifecycle.State state) 设置生命周期为指定的状态,并将事件分派给观察者.

ReportFragment

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();
        }
    }

    static ReportFragment get(Activity activity) {
        return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
                REPORT_FRAGMENT_TAG);
    }
    
    ...
    
    @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);
            }
        }
    }
  ...
}

查看源码可以发现,lifecycle是通过 ReportFragment 来实现生命周期的监听的,重写了生命周期的回调方法,在生命周期回调方法的内部调用 dispatch 的方法来派发生命周期事件.并且 ComponentActivity 的onCreate方法中通过 injectIfNeededIn 方法进行了注入.到这儿我们就已经清楚了Lifecycle实现生命周期的具体方式以及基本使用方式.

如果本文帮助到你了,麻烦您点个喜欢,如有错误欢迎指正,下篇文章将会怼Lifecycle进阶进行分析.

阅读原文...


微信扫一扫,分享到朋友圈

Lifecycle使用与分析-基础
0

简书

在python异步协程中处理流程分析(二)

上一篇

无货源店群规则不断,还能走多远?精细化运营操作,迎合规则稳定发展

下一篇

评论已经被关闭。

插入图片

热门分类

往期推荐

Lifecycle使用与分析-基础

长按储存图像,分享给朋友