一 背景
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)生命周期邏輯處理好就好。當然，這里也是一種解耦方式，采用觀察者模式實現(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類進行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)勢，支持正逆向遍歷。 如果當前狀態(tài)小于以前狀態(tài)， 正向回調(diào)， 否則逆向回調(diào)。這里處理與fragment生命周期狀態(tài)類似。狀態(tài)機，貼一下官方盜圖：
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)。
