美文网首页
jetpack的lifecycle简单分析

jetpack的lifecycle简单分析

作者: nich | 来源:发表于2022-03-14 17:50 被阅读0次

    lifecycle几种使用方式

    //第一种
    class MyObserver2: DefaultLifecycleObserver {
    
        val TAG = "MyObserver2"
    
        override fun onCreate(owner: LifecycleOwner) {
            super.onCreate(owner)
            Log.d(TAG,"onCreate")
        }
    }
    
    //第二种
    class MyObserver : LifecycleObserver{
    
        private val TAG = "myObserver"
    
        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        fun connectionListener() = Log.d(TAG,"ON_RESUME")
    
        @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
        fun lll() = Log.d(TAG,"ON_CREATE")
    
        @OnLifecycleEvent(Lifecycle.Event.ON_START)
        fun lll1111() = Log.d(TAG,"ON_START")
    
    然后在activity里面
    class MainActivity : AppCompatActivity() {
    
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
            lifecycle.addObserver(MyObserver())
        }
    }
    

    lifecycle源码解析

    基础概念

    Lifecycle: 是一个表示android生命周期及状态的对象
    LivecycleOwner:(可以理解为被观察者) 用于连接有生命周期的对象,如activity,fragment
    首先看addObserver点击进去看实现
    LivecycleObserver:(可以理解为观察者) 用于观察LifecycleOwner

    @Override
        public void addObserver(@NonNull LifecycleObserver observer) {
            State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
            ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
            // 将观察者添加到map,如果已经添加,则直接返回。
            // putIfAbsent,如果传入key对应的value已经存在,就返回存在的value,不进行替换。如果不存在,就添加key和value,并返回null。
            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;
            }
    
            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--;
        }
    

    mObserverMap:一般源码大量存在map,便于第一次存第二次直接取
    接下来看LifecycleObserver observer去处

    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;
            }
        }
    
    @NonNull
        static LifecycleEventObserver lifecycleEventObserver(Object object) {
            boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
            boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
            if (isLifecycleEventObserver && isFullLifecycleObserver) {
                return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                        (LifecycleEventObserver) object);
            }
            if (isFullLifecycleObserver) {
                return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
            }
    
            if (isLifecycleEventObserver) {
                return (LifecycleEventObserver) object;
            }
    
            final Class<?> klass = object.getClass();
            int type = getObserverConstructorType(klass);
            if (type == GENERATED_CALLBACK) {
                List<Constructor<? extends GeneratedAdapter>> constructors =
                        sClassToAdapters.get(klass);
                if (constructors.size() == 1) {
                    GeneratedAdapter generatedAdapter = createGeneratedAdapter(
                            constructors.get(0), object);
                    return new SingleGeneratedAdapterObserver(generatedAdapter);
                }
                GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
                for (int i = 0; i < constructors.size(); i++) {
                    adapters[i] = createGeneratedAdapter(constructors.get(i), object);
                }
                return new CompositeGeneratedAdaptersObserver(adapters);
            }
            return new ReflectiveGenericLifecycleObserver(object);
        }
    
    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(@NonNull LifecycleOwner source, @NonNull Event event) {
            mInfo.invokeCallbacks(source, event, mWrapped);
        }
    }
    

    可以看出先调用Lifecycling.lifecycleEventObserver(observer)
    最后访问return new ReflectiveGenericLifecycleObserver(object)
    最后通过mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());获取class名通过mInfo.invokeCallbacks(source, event, mWrapped);反射出去

    接下来看被观察者
    AppCompatActivity->FragmentActivity->ComponentActivity里面实现了LifecycleOwner接口

    //在Componentactivity中
     @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            mSavedStateRegistryController.performRestore(savedInstanceState);
            ReportFragment.injectIfNeededIn(this);
            if (mContentLayoutId != 0) {
                setContentView(mContentLayoutId);
            }
        }
    

    主要是创建了一个空白的ReportFragment来管理

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

    可以看出会走到
    handleLifecycleEvent方法

    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
            State next = getStateAfter(event);//获取下一步的状态码
            moveToState(next);//状态对齐
        }
    
     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);
        }
    //moveToState
    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;
        }
    
      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.
    //map值判断到底是回退还是前进
                if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                    backwardPass(lifecycleOwner);
                }
                Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
                if (!mNewEventOccurred && newest != null
                        && mState.compareTo(newest.getValue().mState) > 0) {
                    forwardPass(lifecycleOwner);
                }
            }
            mNewEventOccurred = false;
        }
    
    
     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();
                }
            }
        }
    
        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();
                }
            }
        }
    
    
     private static Event downEvent(State state) {
            switch (state) {
                case INITIALIZED:
                    throw new IllegalArgumentException();
                case CREATED:
                    return ON_DESTROY;
                case STARTED:
                    return ON_STOP;
                case RESUMED:
                    return ON_PAUSE;
                case DESTROYED:
                    throw new IllegalArgumentException();
            }
            throw new IllegalArgumentException("Unexpected state value " + state);
        }
    
        private static Event upEvent(State state) {
            switch (state) {
                case INITIALIZED:
                case DESTROYED:
                    return ON_CREATE;
                case CREATED:
                    return ON_START;
                case STARTED:
                    return ON_RESUME;
                case RESUMED:
                    throw new IllegalArgumentException();
            }
            throw new IllegalArgumentException("Unexpected state value " + state);
        }
    
    //主要通过 
    前进observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
    或者
    后退
    Event event = downEvent(observer.mState);
                  pushParentState(getStateAfter(event));
                    observer.dispatchEvent(lifecycleOwner, event);
    然后通过本文开头的observer.dispatchEvent把状态码回调出去
    
    void dispatchEvent(LifecycleOwner owner, Event event) {
                State newState = getStateAfter(event);
                mState = min(mState, newState);
                mLifecycleObserver.onStateChanged(owner, event);
                mState = newState;
            }
    
    偷图.png

    打个比方,如果app启动进入activity的onresume状态,那么
    他的reportfragment就会执行 dispatch(Lifecycle.Event.ON_RESUME);然后handleLifecycleEvent里面的getStateAfter(event)返回的state是RESUMED然后在sync中判断map值是前进的话通过while循环里面的upEvent调用->ON_CREATE->ON_START->ON_RESUME
    ,当你activity进入pause方法后调用downEvent方法依次返回ON_PAUSE,ON_STOP状态,在启动时候就执行ON_START, ON_RESUME方法然后销毁执行ON_PAUSE->ON_STOP->ON_DESTROY

    相关文章

      网友评论

          本文标题:jetpack的lifecycle简单分析

          本文链接:https://www.haomeiwen.com/subject/jzqsdrtx.html