Android中Lifecycle的作用是什么

Android中Lifecycle的作用是什么？相信很多沒(méi)有經(jīng)驗(yàn)的人對(duì)此束手無(wú)策，為此本文總結(jié)了問(wèn)題出現(xiàn)的原因和解決方法，通過(guò)這篇文章希望你能解決這個(gè)問(wèn)題。

 Lifecycle的簡(jiǎn)單介紹

Lifecycle的介紹，我們還是拿Google的官方文檔作為參考吧。

Lifecycle主要解決的是業(yè)務(wù)和Activity/Fragment生命周期相關(guān)的問(wèn)題。例如：我們?cè)趏nResume()/onStart()中請(qǐng)求定位，在onPause()/onStop()中停止定位。那么我們一般的做法：

class MyLocationListener {
  public MyLocationListener(Context context, Callback callback) {
    // ...
  }

  void start() {
    // connect to system location service
  }

  void stop() {
    // disconnect from system location service
  }
}

class MyActivity extends AppCompatActivity {
  private MyLocationListener myLocationListener;

  @Override
  public void onCreate(...) {
    myLocationListener = new MyLocationListener(this, (location) -> {
      // update UI
    });
  }

  @Override
  public void onStart() {
    super.onStart();
    myLocationListener.start();
    // manage other components that need to respond
    // to the activity lifecycle
  }

  @Override
  public void onStop() {
    super.onStop();
    myLocationListener.stop();
    // manage other components that need to respond
    // to the activity lifecycle
  }
}

上面的代碼雖然看起來(lái)還可以，但在真實(shí)的應(yīng)用程序中，可能會(huì)有很多的方法都需要根據(jù)當(dāng)前Activity/Fragment的生命周期來(lái)進(jìn)行不同的操作。因此其生命周期方法中可能會(huì)被放置大量代碼，例如onStart()和 onStop()中，這使得它們難以維護(hù)。因此Lifecycle應(yīng)運(yùn)而生！

3. Lifecycle的使用

Lifecycle已經(jīng)發(fā)布了release版，所以其中的一些默認(rèn)支持已經(jīng)包含到了support-v7:26.1.0以及更高。

添加依賴：

implementation "android.arch.lifecycle:extensions:1.1.1"
annotationProcessor "android.arch.lifecycle:compiler:1.1.1"

使用方式1：實(shí)現(xiàn)LifecycleObserver接口，使用@OnLifecycleEvent注解，通過(guò)編譯時(shí)注解生成代碼：

public class MyLifecycleObserver implements LifecycleObserver {

  private static final String TAG = MyLifecycleObserver.class.getSimpleName();

  @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
  public void start(LifecycleOwner lifecycleOwner) {
    Lifecycle.State currentState = lifecycleOwner.getLifecycle().getCurrentState();
    Log.d(TAG, "start: " + currentState);
  }

  @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
  public void stop(LifecycleOwner lifecycleOwner) {
    Log.d(TAG, "stop: " + lifecycleOwner.getLifecycle().getCurrentState());
  }
}

APT生成的代碼

 使用方式2：實(shí)現(xiàn)GenericLifecycleObserver接口，實(shí)現(xiàn)其onStateChanged方法：

public class MyLifecycleObserver implements GenericLifecycleObserver {

  private static final String TAG = MyLifecycleObserver.class.getSimpleName();

  @Override
  public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
    Log.d(TAG, event.name());
  }
}

創(chuàng)建完成后，我們需要將其添加：

public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    getLifecycle().addObserver(new MyLifecycleObserver());
  }
}

結(jié)果圖：

方法1

方法2

4. 源碼分析

1.Lifecycle的獲取

根據(jù)源碼追蹤我們可以看到Lifecycle是在SupportActivity中：

private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
public Lifecycle getLifecycle() {
  return mLifecycleRegistry;
}

這里還有個(gè)挺重要的代碼：

SupportActivity.java

protected void onCreate(@Nullable Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  ReportFragment.injectIfNeededIn(this);
}

ReportFragment.java

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

這里在Activity中添加了一個(gè)Fragment，至于作用，留到后面在講。

2.addObserver

addObserver方法的話，還是簡(jiǎn)單來(lái)看吧：

LifecycleRegistry.java

@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);
  ......
  // 對(duì)狀態(tài)的修正，這里會(huì)對(duì)已經(jīng)過(guò)去的狀態(tài)進(jìn)行分發(fā)。也就是說(shuō)如果添加observer時(shí)狀態(tài)已經(jīng)改變，那么也會(huì)被通知到！
}

// 有狀態(tài)的Observer
static class ObserverWithState {
  State mState;
  GenericLifecycleObserver mLifecycleObserver;

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

  void dispatchEvent(LifecycleOwner owner, Event event) {
    State newState = getStateAfter(event);
    mState = min(mState, newState);
    mLifecycleObserver.onStateChanged(owner, event);
    mState = newState;
  }
}

我們將實(shí)現(xiàn)的接口通過(guò)裝飾者（我認(rèn)為是這樣）模式轉(zhuǎn)成ObserverWithState對(duì)象，并將該對(duì)象添加到mObserverMap中。
 在ObserverWithState的構(gòu)造方法中，有對(duì)我們傳入的LifecycleObserver進(jìn)行包裝：

Lifecycling.java

@NonNull
static GenericLifecycleObserver getCallback(Object object) {
  // 這里應(yīng)該算第三種實(shí)現(xiàn)方式，然而FullLifecycleObserver不是public，所以不能使用
  if (object instanceof FullLifecycleObserver) {
    return new FullLifecycleObserverAdapter((FullLifecycleObserver) object);
  }
  // 我們的第一種方式
  if (object instanceof GenericLifecycleObserver) {
    return (GenericLifecycleObserver) object;
  }
  // 通過(guò)注解生成的
  final Class<?> klass = object.getClass();
  // 將生成的MyLifecycleObserver_LifecycleAdapter放到Map中
  int type = getObserverConstructorType(klass);
  if (type == GENERATED_CALLBACK) {
    List<Constructor<? extends GeneratedAdapter>> constructors =
        sClassToAdapters.get(klass);
    if (constructors.size() == 1) {
      GeneratedAdapter generatedAdapter = createGeneratedAdapter(
          constructors.get(0), object);
      return new SingleGeneratedAdapterObserver(generatedAdapter);
    }
    GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
    for (int i = 0; i < constructors.size(); i++) {
      adapters[i] = createGeneratedAdapter(constructors.get(i), object);
    }
    return new CompositeGeneratedAdaptersObserver(adapters);
  }
  return new ReflectiveGenericLifecycleObserver(object);
}

根據(jù)我們傳入的對(duì)象進(jìn)行解析，最終返回結(jié)果為：GenericLifecycleObserver或者GenericLifecycleObserver的實(shí)現(xiàn)類(lèi)。附獲取生成MyLifecycleObserver_LifecycleAdapter代碼：

// 通過(guò)名稱獲取
public static String getAdapterName(String className) {
  return className.replace(".", "_") + "_LifecycleAdapter";
}

最終通過(guò)Class.forName方式獲得Class。

3.事件分發(fā)

Lifecycle的事件分發(fā)在ObserverWithState類(lèi)中：

// 事件分發(fā)
void dispatchEvent(LifecycleOwner owner, Event event) {
  State newState = getStateAfter(event);
  mState = min(mState, newState);
  mLifecycleObserver.onStateChanged(owner, event);
  mState = newState;
}

看下哪里調(diào)用了dispatchEvent方法：

調(diào)用

 我們看這個(gè)方法，其中一個(gè)在addObserver中調(diào)用，另外的兩個(gè)都會(huì)通過(guò)sync()方法調(diào)用：

// 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) {
    Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn't try dispatch "
        + "new events from it.");
    return;
  }
  // 最新的狀態(tài)和當(dāng)前狀態(tài)不一致，則需要進(jìn)行狀態(tài)修改
  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(lifecycleOwner);
    }
    Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
    if (!mNewEventOccurred && newest != null
        && mState.compareTo(newest.getValue().mState) > 0) {
      forwardPass(lifecycleOwner);
    }
  }
  mNewEventOccurred = false;
}
// 是否狀態(tài)同步的
private boolean isSynced() {
  if (mObserverMap.size() == 0) {
    return true;
  }
  // 最新的和最后添加的Observer狀態(tài)一致，并且當(dāng)前的狀態(tài)和最新?tīng)顟B(tài)一致，則已經(jīng)同步了
  State eldestObserverState = mObserverMap.eldest().getValue().mState;
  State newestObserverState = mObserverMap.newest().getValue().mState;
  return eldestObserverState == newestObserverState && mState == newestObserverState;
}

這里的同步方法用于同步當(dāng)前Observer的狀態(tài)，如果最新的和最老的Observer的狀態(tài)不一致或者當(dāng)前的狀態(tài)和最新的狀態(tài)不一致時(shí)，那么需要進(jìn)行狀態(tài)同步。同步包括了向前同步和向后同步。

調(diào)用sync()方法一共就兩處，一處在addObserver方法，另一處是moveToState方法，而調(diào)用moveToState方法也有兩處：

@SuppressWarnings("WeakerAccess")
@MainThread
public void markState(@NonNull State state) {
  moveToState(state);
}

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
  State next = getStateAfter(event);
  moveToState(next);
}

handleLifecycleEvent方法有很多處調(diào)用：

handleLifecycleEvent調(diào)用

 看圖的話，就可以知道Fragment在不同的生命周期調(diào)用了handleLifecycleEvent方法，隨便看一個(gè)吧：

ON_CREATE

還記得上面說(shuō)的ReportFragment嗎？這里也出現(xiàn)了，我們看下ReportFragment到底做什么的：

// 調(diào)用Activity的
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);
    }
  }
}

// 生命周期
@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;
}

可以看到，ReportFragment只是作為一個(gè)中間層，通過(guò)它來(lái)分發(fā)各種事件！

由于篇幅原因（已經(jīng)啰嗦了很多了），這里就不寫(xiě)LifecycleDispatcher和ProcessLifecycleOwner了，這兩個(gè)通過(guò)自定義的內(nèi)容提供者ProcessLifecycleOwnerInitializer進(jìn)行初始化，并且通過(guò)registerActivityLifecycleCallbacks和registerFragmentLifecycleCallbacks注冊(cè)統(tǒng)一的觀察回調(diào)。

看完上述內(nèi)容，你們掌握Android中Lifecycle的作用是什么的方法了嗎？如果還想學(xué)到更多技能或想了解更多相關(guān)內(nèi)容，歡迎關(guān)注億速云行業(yè)資訊頻道，感謝各位的閱讀！