一 背景

google的Architecture Components Components(lz 簡寫AAC)出來好久了鸟整，但一直沒時間閱讀源碼京髓，趁最近空擋洒缀，閱讀了AAC的源碼跷坝，分享下閱讀的理解倦蚪。

二 AAC是個什么東西

其實，AAC就是google提出的一種app開發(fā)框架痢法，里面最基礎(chǔ)的應(yīng)該就是Lifecycle-Aware了狱窘。 在這之前，我們組開發(fā)采用的mvvm + data binding 模式疯暑。 這個模式中训柴，我們常常這樣一個需求哑舒， 我們需要在fragment onDestroy 或 onPause時妇拯，反注冊ViewModel中釋放資源， 需要層層經(jīng)過洗鸵， ViewModel -- > adapter--> fragment ViewModel ——> fragment等幾級回調(diào)越锈。而Lifecycle-Aware 這時就有一個優(yōu)勢，就是跟生命周期綁定膘滨， 直接在相應(yīng)生命周期邏輯處理好就好甘凭。當(dāng)然，這里也是一種解耦方式火邓，采用觀察者模式實現(xiàn)丹弱。

三 Lifecycle-Aware 的源碼

觀察者模式

a 首先找使用入口， 一般我們是這樣使用Lifecycle-Aware的铲咨，

Lifecycle lifecycle = lifecycleOwner.getLifecycle();
        lifecycle.addObserver((GenericLifecycleObserver) (source, event) -> {
           
        });

b lifecycle的addObserver方法躲胳，如下：

@Override
    public void addObserver(LifecycleObserver observer) {
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

      //已添加
        if (previous != null) {
            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(mLifecycleOwner, 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--;
    }

statefulObserver.dispatchEvent(mLifecycleOwner, upEvent(statefulObserver.mState))一句就會調(diào)用 mLifecycleObserver.onStateChanged(owner, event);即我們上述入口的GenericLifecycleObserver的 void onStateChanged(LifecycleOwner source, Lifecycle.Event event)方法。

c 特別說明下纤勒，ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);

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

d 包裝Observer為 GenericLifecycleObserver坯苹。 這里我們注意到，使用了反射摇天。 同事在使用時粹湃，遇到一個bug就是正式包會crash， 原因就是此版本的混淆文件沒對Lifecycling類進(jìn)行keep泉坐。

static GenericLifecycleObserver getCallback(Object object) {
        if (object instanceof GenericLifecycleObserver) {
            return (GenericLifecycleObserver) object;
        }
        //noinspection TryWithIdenticalCatches
        try {
            final Class<?> klass = object.getClass();
            Constructor<? extends GenericLifecycleObserver> cachedConstructor = sCallbackCache.get(
                    klass);
            if (cachedConstructor != null) {
                return cachedConstructor.newInstance(object);
            }
            cachedConstructor = getGeneratedAdapterConstructor(klass);
            if (cachedConstructor != null) {
                if (!cachedConstructor.isAccessible()) {
                    cachedConstructor.setAccessible(true);
                }
            } else {
                cachedConstructor = sREFLECTIVE;
            }
            sCallbackCache.put(klass, cachedConstructor);
            return cachedConstructor.newInstance(object);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        }
    }

e 另外为鳄， sync()方法如下：

// happens only on the top of stack (never in reentrance),
    // so it doesn't have to take in account parents
    private void sync() {
        while (!isSynced()) {
            mNewEventOccurred = false;
            // no need to check eldest for nullability, because isSynced does it for us.
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass();
            }
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass();
            }
        }
        mNewEventOccurred = false;
    }

f 如果處于初始化周期，onResume及以前forwardPass()腕让，正向回調(diào)之前的生命周期嫌松。 onPause及以后， 逆向回調(diào)backwardPass()枝冀。

這時，特別數(shù)據(jù)結(jié)構(gòu)FastSafeIterableMap就比較優(yōu)勢构捡，支持正逆向遍歷。 如果當(dāng)前狀態(tài)小于以前狀態(tài)壳猜， 正向回調(diào)勾徽， 否則逆向回調(diào)。這里處理與fragment生命周期狀態(tài)類似统扳。狀態(tài)機(jī)喘帚，貼一下官方盜圖：

image.png

trick 1 無ui fragment 綁定命周期

a 目前Android sdk 26.1.0 已支持了 Lifecycle-Aware。 我們先選取Activity 來看咒钟。Lifecycle-Aware的 初始化邏輯在SupportActivity 吹由， BaseFragmentActivityApi14 extends SupportActivity，可以看出最低版本是sdk 14 朱嘴， 最后繼承的是我們最熟悉的子類是FragmentActivity extends BaseFragmentActivityApi16倾鲫。

image.png

b 這里是整個AAC常見的套路， 使用無ui fragment來同步activity的生命周期萍嬉。具體ReportFragment inject的代碼如下乌昔。

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

c 代碼比較簡單在create等回調(diào)，dispatch對應(yīng)的事件壤追。

 @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        dispatchCreate(mProcessListener);
        dispatch(Lifecycle.Event.ON_CREATE);
    }

給對應(yīng)實現(xiàn)了的LifecycleRegistryOwner或LifecycleOwner activity回調(diào)

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

 public void handleLifecycleEvent(Lifecycle.Event event) {
        mState = getStateAfter(event);
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            // we will figure out what to do on upper level.
            return;
        }
        mHandlingEvent = true;
        sync();
        mHandlingEvent = false;
    }

這時會去同步一遍狀態(tài)

sample trick 2

另外一個小的點是磕道，在BaseSample中使用ContentProvider onCreate中綁定activity和fragment生命周期，這點就不詳述了行冰。

public class ProcessLifecycleOwnerInitializer extends ContentProvider {
    @Override
    public boolean onCreate() {
        LifecycleDispatcher.init(getContext());
        ProcessLifecycleOwner.init(getContext());
        return true;
    } 
  溺蕉。。悼做。
}

image.png

繼續(xù)盜圖疯特，左邊部分就是目前的回調(diào)。