Lifecycle

Lifecycle

• 定义
• Lifecycle使用
• 源码中如何使用Lifecycle

定义

构建生命周期感知型组件，这些组件可以根据 Activity 或 Fragment 的当前生命周期状态调整行为。

Lifecycle使用 三种方式

LifecycleObserver, FullLifecycleObserver, LifecycleEventObserver (后面两个继承前者)

1. 自定义的LifecycleObserver观察者，用注解声明每个方法观察的宿主的状态

class LocationObserver extends LifecycleObserver{
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void onStart(@NotNull LifecycleOwner owner){
      //开启定位
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void onStop(@NotNull LifecycleOwner owner){
       //停止定位
    }

     @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    void onDestroy(@NotNull LifecycleOwner owner){
       //释放资源
    }
}
// 注册观察者,观察宿主生命周期状态变化
// 使用Fragment或者Activity中使用 （Activity使用，需要Activity继承CommontActivity）
class MyFragment extends Fragment{
  public void onCreate(Bundle bundle){
    
    MyLifecycleObserver observer =new MyLifecycleObserver()
    getLifecycle().addObserver(observer);
    
  }
}

使用FullLifecycleObserver

interface FullLifecycleObserver extends LifecycleObserver {

    void onCreate(LifecycleOwner owner);

    void onStart(LifecycleOwner owner);

    void onResume(LifecycleOwner owner);

    void onPause(LifecycleOwner owner);

    void onStop(LifecycleOwner owner);

    void onDestroy(LifecycleOwner owner);
}
// 使用DefaultLifecycleObserver 默认实现了所有接口 实现此接口，不需要所有的方法都要实现
class MyObserver implements DefaultLifecycleObserver {
    void onStart(LifecycleOwner owner) {
    // 开启定位
     }

     void onStop(LifecycleOwner owner) {
      // 停止定位
      }

     void onDestroy(LifecycleOwner owner) {
    // 释放资源
      }
}

// 使用Fragment或者Activity中使用 （Activity使用，需要Activity继承CommontActivity）
class MyFragment extends Fragment{
  public void onCreate(Bundle bundle){
    
    MyObserver observer =new MyObserver()
    getLifecycle().addObserver(observer);
    
  }
}

使用LifecycleEventObserver

public interface LifecycleEventObserver extends LifecycleObserver {
    void onStateChanged(LifecycleOwner source, Lifecycle.Event event);
}

class LocationObserver extends LifecycleEventObserver{
    @override
    void onStateChanged(LifecycleOwner source, Lifecycle.Event event){
      //需要自行判断life-event是onStart, 还是onStop,亦或者是onDestroy
    }
}

Lifecycle 抽象类

• 注册监听

    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);

• 移除监听

    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);

• 获取当前状态

    @MainThread
    @NonNull
    public abstract State getCurrentState();

• Event

public enum Event {
        /**
         * Constant for onCreate event of the {@link LifecycleOwner}.
         */
        ON_CREATE, // 宿主发送onCreate事件
        /**
         * Constant for onStart event of the {@link LifecycleOwner}.
         */
        ON_START,// 宿主发送onStart事件
        /**
         * Constant for onResume event of the {@link LifecycleOwner}.
         */
        ON_RESUME,// 宿主发送onResume事件
        /**
         * Constant for onPause event of the {@link LifecycleOwner}.
         */
        ON_PAUSE,// 宿主发送onPause事件
        /**
         * Constant for onStop event of the {@link LifecycleOwner}.
         */
        ON_STOP,// 宿主发送onStop事件
        /**
         * Constant for onDestroy event of the {@link LifecycleOwner}.
         */
        ON_DESTROY,// 宿主发送onDestroy事件
        /**
         * An {@link Event Event} constant that can be used to match all events.
         */
        ON_ANY  // 宿主发送onCreate事件
    }

• State

 public enum State {
        /**
         * Destroyed state for a LifecycleOwner. After this event, this Lifecycle will not dispatch
         * any more events. For instance, for an {@link android.app.Activity}, this state is reached
         * <b>right before</b> Activity's {@link android.app.Activity#onDestroy() onDestroy} call.
         */
        DESTROYED,

        /**
         * Initialized state for a LifecycleOwner. For an {@link android.app.Activity}, this is
         * the state when it is constructed but has not received
         * {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} yet.
         */
        INITIALIZED,

        /**
         * Created state for a LifecycleOwner. For an {@link android.app.Activity}, this state
         * is reached in two cases:
         * <ul>
         *     <li>after {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} call;
         *     <li><b>right before</b> {@link android.app.Activity#onStop() onStop} call.
         * </ul>
         */
        CREATED,

        /**
         * Started state for a LifecycleOwner. For an {@link android.app.Activity}, this state
         * is reached in two cases:
         * <ul>
         *     <li>after {@link android.app.Activity#onStart() onStart} call;
         *     <li><b>right before</b> {@link android.app.Activity#onPause() onPause} call.
         * </ul>
         */
        STARTED,

        /**
         * Resumed state for a LifecycleOwner. For an {@link android.app.Activity}, this state
         * is reached after {@link android.app.Activity#onResume() onResume} is called.
         */
        RESUMED;

        /**
         * Compares if this State is greater or equal to the given {@code state}.
         *
         * @param state State to compare with
         * @return true if this State is greater or equal to the given {@code state}
         */
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }

• DESTROYED： Activity执行onDestroy的状态
• INITIALIZED：当Activity执行onCreate之前会置为当前状态，也是Activity默认状态
• CREATED： 当执行onCreate之后或者执行onStop后的状态
• STARTED: 执行onStart或者onPause后的状态
• RESUMED：执行onResume后的状态

LifecycleRegistry

• LifecycleRegistry 继承Lifecycle，Activity/Fragment宿主生命周期分发主要的在此类中

LifecycleOwner、Lifecycle、LifecycleObserver

• LifecycleOwner：宿主，一般Fragment和Activity实现LifecycleOwner，并实现getLifecycle()方法，宿主成员变量中创建Lifecycle（LifecycleRegistry）对象，用来事件的分发

• Lifecycle：在宿主中创建，并提供LifecycleRegistry对象，便于外界获取并通知生命周期

• LifecycleObserver： 创建的Observer对象，注册到宿主中LifecycleRegistry对象里，达到对应的生命周期时，做对应的业务

Activity/Fragment生命周期管理

 /**
     * Sets the current state and notifies the observers.
     * <p>
     * Note that if the {@code currentState} is the same state as the last call to this method,
     * calling this method has no effect.
     *
     * @param event The event that was received
     */
  //  Activity/ Fragment 生命周期分发都会走到LifecycleRegistry的当前方法 
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next); // 将当前状态与Activity/Fragment生命周期对其， 会调用到sysc()方法
    }

// 根据当前传入的event  获取对应的状态， 如果是Stop或者Pause 则状态回退
 static State getStateAfter(Event event) {
        switch (event) {
            case ON_CREATE: // 如果是create或者stop 则返回CREATED状态
            case ON_STOP:
                return CREATED;
            case ON_START: // 如果是Start或者Pause 则返回STARTED状态
            case ON_PAUSE:
                return STARTED;
            case ON_RESUME: // 如果是resume，则返回Resumed状态
                return RESUMED;
            case ON_DESTROY: // Destroy 返回Destoryed状态
                return DESTROYED;
            case ON_ANY:
                break;
        }
        throw new IllegalArgumentException("Unexpected event value " + event);
    }

    // happens only on the top of stack (never in reentrance),
    // so it doesn't have to take in account parents
    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()) {
         // 判断条件为，当前宿主的Observer中如果有与宿主对象状态不一致，才会进入循环体，如果一致，则不处理
            mNewEventOccurred = false;
            // no need to check eldest for nullability, because isSynced does it for us.
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                // 判断宿主当前的状态是否比 Observer的状态小，如果是，则原来注册的Observer状态回退
                backwardPass(lifecycleOwner);
            }
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                // 如果Observer状态新加入，则需要将新加进来的Observer对齐宿主状态
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

// 状态回退
 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 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 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);
    }