Android Jetpack架構組件之Lifecycle
Lifecycle簡介
一直以來，解藕都是軟件開發永恆的話題。在Android開發中，解藕很大程度上表現爲系統組件的生命週期與普通組件之間的解藕，由於普通組件在使用過程當中須要依賴系統組件的的生命週期。javascript
舉個例子，咱們常常須要在頁面的onCreate()方法中對組件進行初始化，而後在onStop()中中止組件，或者在onDestory()方法中對進行進行銷燬。事實上，這樣的工做很是繁瑣，會讓頁面和頁面耦合度變高，但又不得不作，由於若是不即時的釋放資源，有可能會致使內存泄露。例如，下面是一個在Activity的不一樣生命週期方法中監聽調用的例子，代碼以下。java
public class MainActivity extends AppCompatActivity {
private MyListener myListener;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
myListener = new MyListener(MainActivity.this);
}
@Override
protected void onStart() {
super.onStart();
myListener.start();
}
@Override
protected void onStop() {
super.onStop();
myListener.stop();
}
}
class MyListener {
public MyListener(Context context) {
...
}
void start() {
...
}
void stop() {
...
}
}
雖然，代碼看起來沒什麼問題，但在實際開發中可能會有多個組件在Activity的生命週期中進行回調，這樣Activity的生命週期的方法中可能就須要編寫大量的代碼，這就使得它們難以維護。
咱們但願在對組件進行管理不依賴頁面的生命週期的回調方法，同時當頁面生命週期發生改變時，也可以即時的收到通知。這在Android組件化和架構設計的時候表現的尤其明顯。react
那糾結什麼是Lifecycle組件呢？總的來講，Lifecycle 就是具備生命週期感知能力的組件。簡單的理解就是，當Activity/Fragment的生命週期產生變化時，Lifecycle組件會感應相應的生命週期變化，固然咱們還能夠經過使用Lifecycle組件來在自定義的類中管理Activity/fragment的生命週期。android
目前，Lifecycle生命週期組件主要由Lifecycle、LifecycleOwner、LifecycleObserver三個對象構成。架構
- Lifecycle：是一個持有組件生命週期狀態與事件（如Activity或Fragment）的信息的類。
- LifecycleOwner：Lifecycle的提供者，經過實現LifecycleOwner接口來訪問Lifecycle生命週期對象。Fragment和FragmentActivity類實現了LifecycleOwner接口，它具備訪問生命週期的getLifecycle方法，使用時須要在本身的類中實現LifecycleOwner。
- LifecycleObserver：Lifecycle觀察者，可使用LifecycleOwner類的addObserver()方法進行註冊，被註冊後LifecycleObserver即可以觀察到LifecycleOwner的生命週期事件。
Lifecycle使用
使用Lifecycle進行應用開發以前，須要先在app的build.gradle文件中添加以下依賴代碼。app
dependencies {
def lifecycle_version = "2.2.0"
def arch_version = "2.1.0"
// ViewModel
implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
// LiveData
implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
// Lifecycles only (without ViewModel or LiveData)
implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"
// Saved state module for ViewModel
implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"
// Annotation processor
annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
// alternately - if using Java8, use the following instead of lifecycle-compiler
implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"
// optional - helpers for implementing LifecycleOwner in a Service
implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"
// optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"
// optional - ReactiveStreams support for LiveData
implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version"
// optional - Test helpers for LiveData
testImplementation "androidx.arch.core:core-testing:$arch_version"
}
官網用的是AndroidX，由於使用AndroidX可能會產生一些遷移的問題，這裏的例子就不使用AndroidX，使用lifecycleandroid.arch.lifecycle庫便可，以下所示。ide
dependencies {
implementation fileTree(dir: "libs", include: ["*.jar"])
implementation 'androidx.appcompat:appcompat:1.2.0'
implementation 'androidx.constraintlayout:constraintlayout:2.0.2'
testImplementation 'junit:junit:4.12'
androidTestImplementation 'androidx.test.ext:junit:1.1.2'
androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
def lifecycle_version = "2.2.0"
// 包含ViewModel和LiveData
implementation "android.arch.lifecycle:extensions:$lifecycle_version"
// 僅僅包含ViewModel
implementation "android.arch.lifecycle:viewmodel:$lifecycle_version" // For Kotlin use viewmodel-ktx
// 僅僅包含LiveData
implementation "android.arch.lifecycle:livedata:$lifecycle_version"
// 僅僅包含Lifecycles
implementation "android.arch.lifecycle:runtime:$lifecycle_version"
//noinspection LifecycleAnnotationProcessorWithJava8
annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version" // For Kotlin use kapt instead of annotationProcessor
// 若是用Java8, 用於替代compiler
implementation "android.arch.lifecycle:common-java8:$lifecycle_version"
// 可選，ReactiveStreams對LiveData的支持
implementation "android.arch.lifecycle:reactivestreams:$lifecycle_version"
// 可選，LiveData的測試
testImplementation "android.arch.core:core-testing:$lifecycle_version"
}
按照Lifecycle的使用流程，須要先定義觀察者，並重寫對應的生命週期，代碼以下。函數
public class MyObserver implements LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
void onResume(){
Log.d(TAG, "Lifecycle call onResume");
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
void onPause(){
Log.d(TAG, "Lifecycle call onPause");
}
}
而後，咱們在onCreate()方法中添加觀察者，代碼以下。源碼分析
getLifecycle().addObserver(new MyObserver());
完整的代碼以下所示。組件化
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
getLifecycle().addObserver(new MyObserver());
}
@Override
protected void onResume() {
super.onResume();
Log.d(TAG, "onResume");
}
@Override
protected void onPause() {
super.onPause();
Log.d(TAG, "onPause");
}
//自定義觀察者
public class MyObserver implements LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
void onResume(){
Log.d(TAG, "Lifecycle call onResume");
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
void onPause(){
Log.d(TAG, "Lifecycle call onPause");
}
}
}
通過上面的處理後，MyObserver就能夠觀察MainActivity的生命週期變化了。在上面的示例中，LifecycleOwner能夠理解爲被觀察者，MainActivity默認實現了LifecycleOwner接口，也就是說MainActivity是被觀察者。運行上面的代碼，獲得以下的日誌。
com.xzh.androidx D/MainActivity: MainActivity onResume com.xzh.androidx D/MainActivity: Lifecycle call onResume com.xzh.androidx D/MainActivity: Lifecycle call onPause com.xzh.androidx D/MainActivity: MainActivity onPause
固然，在被觀察者中進行註冊時，咱們還能夠對代碼進行拆解，寫成下面的方式。
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
private LifecycleRegistry registry;
private MyObserver myObserver = new MyObserver();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
init();
}
@Override
protected void onResume() {
super.onResume();
registry.setCurrentState(Lifecycle.State.RESUMED);
}
@NonNull
@Override
public Lifecycle getLifecycle() {
return registry;
}
private void init() {
registry = new LifecycleRegistry(this);
registry.addObserver(myObserver);
}
... //省略MyObserver代碼
}
在自定義的Activity或Fragment中實現LifeCycleOwner時，能夠實現LifecycleRegistryOwner接口，以下所示。
public class MyFragment extends Fragment implements LifecycleRegistryOwner {
LifecycleRegistry lifecycleRegistry = new LifecycleRegistry(this);
@Override
public LifecycleRegistry getLifecycle() {
return lifecycleRegistry;
}
}
經過示例的分析能夠發現，Android的Lifecycle組件須要先建立一個觀察者，當組件生命週期發生變化時，通知觀察者LifeCycle註解的方法作出響應。
Lifecycle源碼分析
Lifecycle註冊流程
Lifecycle使用兩個枚舉來跟蹤其關聯組件的生命週期狀態，這兩個枚舉分別是Event和State。
- State：Lifecycle的生命週期所處的狀態。
- Event：Lifecycle生命週期對應的事件，這些事件會映射到Activity和Fragment中的回調事件中。
打開lifecycle:common庫下的Lifecycle類，
public abstract class Lifecycle {
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
@NonNull
AtomicReference<Object> mInternalScopeRef = new AtomicReference<>();
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);
@MainThread
@NonNull
public abstract State getCurrentState();
@SuppressWarnings("WeakerAccess")
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY
}
@SuppressWarnings("WeakerAccess")
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}
能夠發現，Lifecycle是一個抽象類，其內部不只包括了添加和移除觀察者的方法，還包括了Event和State兩個枚舉。而且，Event中的事件和Activity的生命週期幾乎是對應的，除了ON_ANY，它可用於匹配全部事件。State與Event的生命週期關係的時序圖以下圖所示。
在Lifecycle抽象類中，enum枚舉定義了全部State，各個狀態都是按照固定的順序來變化的，因此State具有了生命週期的概念。Lifecycle是抽象類，惟一的具體實現類爲 LifecycleRegistry，源碼以下。
public class LifecycleRegistry extends Lifecycle {
/**
* 一個列表，而且能夠在遍歷期間添加或者刪除元素
* 新觀察者的狀態必定是小於等於以前的觀察者的
*/
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
new FastSafeIterableMap<>();
/**
* 當前狀態
*/
private State mState;
/**
* 以弱引用保存LifecycleOwner，防止內存泄漏
*/
private final WeakReference<LifecycleOwner> mLifecycleOwner;
}
LifecycleRegistry將事件通知給全部觀察者以前，存在一個同步的過程。這個同步的過程當中，前面的觀察者已經通知到了，後面的觀察者還沒被通知，因而全部觀察者之間的狀態就不一致了，各觀察者狀態之間便產生了差別，只有第一個觀察者的狀態等於最後一個觀察者的狀態，而且等於LifecycleRegistry中的當前狀態mState，才說明狀態同步整個完成了。
加下來，咱們來看一下Lifecycle的註冊流程，addObserver() 方法是註冊觀察者的入口，源碼以下。
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
if (previous != null) {
return;
}
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == 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(lifecycleOwner, upEvent(statefulObserver.mState));
popParentState();
// 從新計算狀態，用於循環退出條件：直到observer的狀態從INITIALIZED的狀態遞進到當前LifecyleOwner的狀態
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
sync();
}
mAddingObserverCounter--;
}
在上面的源碼中，代碼的來前幾行是將 state與observer 包裝成ObserverWithState類型，state 的初始值爲 INITIALIZED ，而後存入集合，若是observer以前已經存在的話，就認定重複添加，直接返回。當添加的observer爲新的時候，執行循環流程。接着判斷了一下isReentrance的值，表示是否重入，便是否須要同時執行添加addObserver()的流程或者同時有其餘Event事件正在分發。而後，在while循環中，執行事件的分發邏輯。while循環中有兩個比較重要的方法：dispatchEvent() 和 upEvent()。
首先，咱們來看一下dispatchEvent()方法的源碼，以下所示。
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);
// observer的回調函數
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
而後再調用了 observer的回調方法onStateChanged()更新組件的狀態mState。
通知觀察者
前面咱們分析了Lifecycle的註冊觀察者的流程，接下來咱們看一下Lifecycle又是如何通知Activity或Fragment的生命週期改變的呢？在Android 8.0時，FragmentActivity繼承自SupportActivity，而在Android 9.0，FragmentActivity繼承自ComponentActivity 。SupportActivity和ComponentActivity的代碼區別不大，以ComponentActivity來講，源碼以下。
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
LifecycleOwner,
ViewModelStoreOwner,
... //省略其餘代碼
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
... //省略其餘代碼
ReportFragment.injectIfNeededIn(this);
if (mContentLayoutId != 0) {
setContentView(mContentLayoutId);
}
}
... //省略其餘代碼
}
接下來，咱們看一下ReportFragment的源碼。
public class ReportFragment extends Fragment {
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();
}
}
...
@Override
public void onActivityCreated(Bundle savedInstanceState) {
dispatch(Lifecycle.Event.ON_CREATE);
}
@Override
public void onStart() {
dispatch(Lifecycle.Event.ON_START);
}
... //省略其餘代碼
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);
}
}
}
在上面的ReportFragment類中，Activity 經過注入一個沒有UI的 ReportFragment ，而後在 ReportFragment的的生命週期回調中調用dispathch() 方法分發生命週期狀態的改變。由於Fragment依賴於建立它的Activity，因此Fragment的生命週期和Activity生命週期同步，這樣就間接實現了 Lifecycle 監聽Activity生命週期的功能。接下來，看一下是dispatch()方法是如何分發Event的，源碼以下。
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);
}
}
}
能夠發現，在調用getActivity()方法後向上轉型強制轉換爲LifecycleOwner，而後調用了LifecycleRegistry類的handleLifecycleEvent()方法，而後邏輯又回到了LifecycleRegistry類中，進而將事件Event分發交由LifecycleRegistry進行處理。其中，handleLifecycleEvent(event)的實現以下所示。
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}
private void moveToState(State next) {
// 將 mState 更新爲當前的 State
mState = next;
...
mHandlingEvent = true;
sync();
mHandlingEvent = false;
}
更新了mState的值以後，就調用sync()方法，sync()方法就是根據 mState 的改變作出同步操做，並執行分發事件，sync()方法的源碼以下。
private void sync() {
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
// 判斷是否須要同步，沒有同步則一直進行
while (!isSynced()) {
mNewEventOccurred = false;
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 boolean isSynced() {
if (mObserverMap.size() == 0) {
return true;
}
State eldestObserverState = mObserverMap.eldest().getValue().mState;
State newestObserverState = mObserverMap.newest().getValue().mState;
return eldestObserverState == newestObserverState && mState == newestObserverState;
}
首先，經過調用isSynced() 方法來判斷是否須要同步。isSynced()方法比較簡單，主要經過比較第一個observer和最後一個observer，他們的 mState 值是否相等，相等的話則說明同步完畢，不相等的話繼續同步，直到相等爲止。
同時，sync()方法中會根據當前狀態和mObserverMap中的eldest和newest的狀態作對比 ，判斷當前狀態是向前仍是向後，以向後爲例。
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();//1
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));//2
popParentState();
}
}
}
forwardPass()方法最核心的就是獲取ObserverWithState狀態，ObserverWithState的代碼以下。
static class ObserverWithState {
State mState;
GenericLifecycleObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.getCallback(observer);//1
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
ObserverWithState類包括了State和GenericLifecycleObserver成員變量，GenericLifecycleObserver是一個接口，它繼承了LifecycleObserver接口。
ReflectiveGenericLifecycleObserver和CompositeGeneratedAdaptersObserver是GenericLifecycleObserver的實現類，這裏主要查看ReflectiveGenericLifecycleObserver的onStateChanged方法是如何實現的，源碼以下。
class ReflectiveGenericLifecycleObserver implements GenericLifecycleObserver {
private final Object mWrapped;
private final CallbackInfo mInfo;
ReflectiveGenericLifecycleObserver(Object wrapped) {
mWrapped = wrapped;
mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
}
@Override
public void onStateChanged(LifecycleOwner source, Event event) {
mInfo.invokeCallbacks(source, event, mWrapped);//1
}
}
onStateChanged()方法會調用CallbackInfo的invokeCallbacks()方法，這裏會用到CallbackInfo類，代碼以下。
static class CallbackInfo {
final Map<Lifecycle.Event, List<MethodReference>> mEventToHandlers;
final Map<MethodReference, Lifecycle.Event> mHandlerToEvent;
CallbackInfo(Map<MethodReference, Lifecycle.Event> handlerToEvent) {
mHandlerToEvent = handlerToEvent;
mEventToHandlers = new HashMap<>();
for (Map.Entry<MethodReference, Lifecycle.Event> entry : handlerToEvent.entrySet()) {//1
Lifecycle.Event event = entry.getValue();
List<MethodReference> methodReferences = mEventToHandlers.get(event);
if (methodReferences == null) {
methodReferences = new ArrayList<>();
mEventToHandlers.put(event, methodReferences);
}
methodReferences.add(entry.getKey());
}
}
@SuppressWarnings("ConstantConditions")
void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);//2
invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,
target);
}
private static void invokeMethodsForEvent(List<MethodReference> handlers,
LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
if (handlers != null) {
for (int i = handlers.size() - 1; i >= 0; i--) {
handlers.get(i).invokeCallback(source, event, mWrapped);//1
}
}
}
在CallbackInfo代碼中，首先使用循環將handlerToEvent進行數據類型轉換，轉化爲一個HashMap，key的值爲事件，value的值爲MethodReference。而invokeMethodsForEvent()方法會傳入mEventToHandlers.get(event)，也就是事件對應的MethodReference的集合。而後，invokeMethodsForEvent方法中會遍歷MethodReference的集合，調用MethodReference的invokeCallback方法。其中，MethodReference類的代碼以下。
@SuppressWarnings("WeakerAccess")
static class MethodReference {
final int mCallType;
final Method mMethod;
MethodReference(int callType, Method method) {
mCallType = callType;
mMethod = method;
mMethod.setAccessible(true);
}
void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {
try {
switch (mCallType) {
case CALL_TYPE_NO_ARG:
mMethod.invoke(target);
break;
case CALL_TYPE_PROVIDER:
mMethod.invoke(target, source);
break;
case CALL_TYPE_PROVIDER_WITH_EVENT:
mMethod.invoke(target, source, event);
break;
}
} catch (InvocationTargetException e) {
throw new RuntimeException("Failed to call observer method", e.getCause());
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
...
}
MethodReference類中有兩個變量，一個是callType，它表明調用方法的類型，另外一個是Method，它表明方法，並最終經過invoke對方法進行反射，經過反射對事件的對應方法進行調用。
- 1. Android Jetpack 之 Lifecycle
- 2. Android Jetpack架構組件之 Lifecycle（源碼篇）
- 3. Android Jetpack 架構組件之 Lifecycle （一）起源
- 4. Android Jetpack 架構組件之 Lifecycle (二) 使用
- 5. Android 架構組件——Lifecycle
- 6. Android 架構組件（一）——Lifecycle
- 7. Android架構組件-Lifecycle
- 8. Android Jetpack架構組件
- 9. Android 官方架構組件之 Lifecycle
- 10. Android 架構組件之---LifeCycle 詳解
- 更多相關文章...
- • Docker 架構 - Docker教程
- • ASP AdRotator 組件 - ASP 教程
- • 互聯網組織的未來：剖析GitHub員工的任性之源
- • IntelliJ IDEA安裝代碼格式化插件
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 字節跳動21屆秋招運營兩輪面試經驗分享
- 2. Java 3 年，25K 多嗎？
- 3. mysql安裝部署
- 4. web前端開發中父鏈和子鏈方式實現通信
- 5. 3.1.6 spark體系之分佈式計算-scala編程-scala中trait特性
- 6. dataframe2
- 7. ThinkFree在線
- 8. 在線畫圖
- 9. devtools熱部署
- 10. 編譯和鏈接
- 1. Android Jetpack 之 Lifecycle
- 2. Android Jetpack架構組件之 Lifecycle（源碼篇）
- 3. Android Jetpack 架構組件之 Lifecycle （一）起源
- 4. Android Jetpack 架構組件之 Lifecycle (二) 使用
- 5. Android 架構組件——Lifecycle
- 6. Android 架構組件（一）——Lifecycle
- 7. Android架構組件-Lifecycle
- 8. Android Jetpack架構組件
- 9. Android 官方架構組件之 Lifecycle
- 10. Android 架構組件之---LifeCycle 詳解