43. LifeCycle與LiveData

LifeCycle

LifeCycle是Google提供的用於監控Activity和Fragment生命週期的一種解耦的實現方式

使用方法舉例

如下面的代碼，當Activity生命週期變化時，在MyLifeCycleListener中就可以收到相應的回調

public class MainActivity extends AppCompatActivity{
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        MyLifeCycleListener lifeCycleListener = new MyLifeCycleListener();
        getLifecycle().addObserver(lifeCycleListener);
    }
}

public class MyLifeCycleListener implements LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void onCreate(LifecycleOwner owner) {

    }
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void onStart(LifecycleOwner owner) {
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void onStop(LifecycleOwner owner) {
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    void onResume(LifecycleOwner owner) {
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    void onPause(LifecycleOwner owner) {
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    void onDestroy(LifecycleOwner owner) {
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    void onAny(LifecycleOwner owner) {
    }
}

怎麼做到的？

AppCompatActivity -> FragmentActivity -> ComponentActivity
在ComponentActivity中創建了一個LifecycleRegistry(繼承自Lifecycle),所以getLifecycle()獲取到的就是這個對象

private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

進入它的addObserver方法中

    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        //看這一行
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ......
    }

    ObserverWithState(LifecycleObserver observer, State initialState) {
        mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
        mState = initialState;
    }

    @NonNull
    static LifecycleEventObserver lifecycleEventObserver(Object object) {
          ......
          return new ReflectiveGenericLifecycleObserver(object);
    }

    ReflectiveGenericLifecycleObserver(Object wrapped) {
        ......
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    }

    CallbackInfo getInfo(Class klass) {
        ......
        existing = createInfo(klass, null);
        return existing;
    }

最終在createInfo方法中發現它遍歷了我們MyLifeCycleListener類中所有的註解方法並保存了起來。也就是說在addObserver的時候就已經通過註解和反射拿到相應的生命週期方法了

    private CallbackInfo createInfo(Class klass, @Nullable Method[] declaredMethods) {
        ......

        Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
        boolean hasLifecycleMethods = false;
        for (Method method : methods) {
            OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
            if (annotation == null) {
                continue;
            }
            hasLifecycleMethods = true;
            Class<?>[] params = method.getParameterTypes();
            int callType = CALL_TYPE_NO_ARG;
            if (params.length > 0) {
                callType = CALL_TYPE_PROVIDER;
                ......
            }
            Lifecycle.Event event = annotation.value();

            if (params.length > 1) {
                callType = CALL_TYPE_PROVIDER_WITH_EVENT;
                ......
            }
            ......
            MethodReference methodReference = new MethodReference(callType, method);
            verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
        }
        CallbackInfo info = new CallbackInfo(handlerToEvent);
        mCallbackMap.put(klass, info);
        mHasLifecycleMethods.put(klass, hasLifecycleMethods);
        return info;
    }

怎麼調用生命週期方法的？

我們進入ComponentActivity中查找真相，在ComponentActivity中你會發現這樣一行代碼。看到這一行是不是想到了Glide中對生命週期監聽的實現方式？將 一個空白的fragment添加到Activity中，fragment可以響應activity的生命週期，從而實現對生命週期的監聽

    ReportFragment.injectIfNeededIn(this);
    public static void injectIfNeededIn(Activity activity) {
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            manager.executePendingTransactions();
        }
    }

在ReportFragment中當執行到相應的生命週期方法時,最終通過dispatch方法將回調分發出去

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

LiveData

LiveData你可以把它當作一個可以替換EventBus的實現方案。LiveData 是一個抽象類，它的實現子類有 MutableLiveData ，MediatorLiveData。在實際使用中，用得比較多的是 MutableLiveData

用LiveData實現一個“EventBus”

public class EventBus {
    private Map<String, MutableLiveData<Object>> bus;

    private static EventBus liveDataBus = new EventBus();

    private EventBus() {
        bus = new HashMap<>();
    }

    public static EventBus getInstance() {
        return liveDataBus;
    }

    public synchronized <T> MutableLiveData<T> with(String key, Class<T> type) {
        if (!bus.containsKey(key)) {
            bus.put(key, new MutableLiveData<Object>());
        }
        return (MutableLiveData<T>) bus.get(key);
    }
}

當我們需要監聽某一數據變化的時候

EventBus.getInstance().with("list", ArrayList.class)
                .observe(this, arrayList -> {
                    if (arrayList != null) {
                        Log.i("", "收到了數據" + arrayList.toString());
                    }
                });       

當數據發生變化，要通知監聽者的時候

        ArrayList data = new ArrayList<>();    
        data.add("1");
        EventBus.getInstance().with("list", ArrayList.class).postValue(data);