1. Используйте
Структура жизненного цикла используется для восприятия компонентов для выполнения операций в ответ на изменения в состоянии жизненного цикла другого компонента (например, Activity и Fragment). Эти компоненты помогают создавать код, который легче организовать, а зачастую и легче, а также легче поддерживать.
Например:
если вам нужно выполнить некоторую обработку в жизненном цикле Activity или Fragment:
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
presenter.onCreate()
}
override fun onStart(){
super.onStart()
presenter.onStart()
}
...
override fun onDestroy(){
super.onDestroy()
presenter.onDestroy()
}
Этот метод записи должен вызывать соответствующий метод ведущего в соответствующей функции жизненного цикла Activity или Fragment. Этот метод записи относительно тяжелый, недостаточно легкий и не разделяет ведущего и Activity. Появление жизненного цикла решает эту проблему. проблема.
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
lifecycle.addObserver(Presenter())
}
}
class Presenter():LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreate(){
println("presenter oncreate")
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun onStart(){
println("presenter onstart")
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onResumse(){
println("presenter on resume")
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
fun onPause(){
println("presenter on pause")
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun onStop(){
println("presenter on stop")
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun onDestroy(){
println("presenter on destroy")
}
Таким образом, отношение между Presenter и Activity изменяется с отношения ассоциации на отношение зависимости, что снижает взаимосвязь. В то же время Presenter теперь также можно использовать для восприятия соответствующего жизненного цикла Activity, не вызывая Метод презентатора в функции жизненного цикла действия.
2. Анализ
2.1 Режим наблюдателя
По именам интерфейсов и методов вы можете обнаружить, что весь жизненный цикл на самом деле является шаблоном наблюдателя. Ниже представлена диаграмма классов UML шаблона наблюдателя.
Итак, как выглядит duiyingLifecycle? Ниже приведена диаграмма классов UML для жизненного цикла, нарисованная мной.
Наши настраиваемые действия унаследованы от SupportActivity. Вы можете обнаружить, что SupportActivity реализует интерфейс LifecycleOwner и содержит объект LifecycleRegistry, который реализует жизненный цикл. Этот объект можно рассматривать как наблюдателя. и LifecycleRegistr в шаблоне объединяют несколько LifecycleObserver и уведомляют LifecycleObserver о необходимости выполнения соответствующих вызовов методов при изменении жизненного цикла.
2.2 Восприятие жизненного цикла
Жизненный цикл - это основа для понимания жизненного цикла, так как же он воспринимает жизненный цикл Activity? Посмотрите на метод SupportActivity onCretae
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
}
Здесь сначала вызовите метод ReportFragment.injectIfNeededIn (this), посмотрите на этот метод
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();
}
}
Очень просто - добавить ReportFragment к текущему Activity. Посмотрите на функцию жизненного цикла ReportFragment.
@Override
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;
}
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);
}
}
}
Вы обнаружите, что вызывается метод отправки, и метод отправки определяет, реализует ли Activity интерфейс LifecycleOwner. Если интерфейс реализован, он вызовет handleLifecycleEvent из LifecycleRegister, чтобы статус жизненного цикла был уведомлен каждый LifecycleObserver от LifecycleRegistry для его вызова.Соответствует методу Lifecycle.Event. Этот метод восприятия жизненного цикла Activity через Fragment фактически отражен в Glide. Это восприятие жизненного цикла Activity, но как насчет фрагмента? Взгляните на исходный код фрагмента, и вы обнаружите, что фрагмент также реализует интерфейс LifecycleOwner и также связан с объектом LifecycleRegistry.
void performCreate(Bundle savedInstanceState) {
if (this.mChildFragmentManager != null) {
this.mChildFragmentManager.noteStateNotSaved();
}
this.mState = 1;
this.mCalled = false;
this.onCreate(savedInstanceState);
this.mIsCreated = true;
if (!this.mCalled) {
throw new SuperNotCalledException("Fragment " + this + " did not call through to super.onCreate()");
} else {
this.mLifecycleRegistry.handleLifecycleEvent(Event.ON_CREATE);
}
}
Обратите внимание, что mLifecycleRegistry.handleLifecycleEvent вызывается в его performCreate, а также в методах performStart и performResume аналогичным образом. Фактически, здесь есть интересное явление: метод dispatch (Lifecycle.Event.ON_CREATE) в ReportFragment вызывается в onActivityCreated, а отправка события Lifecycle.Event.ON_CREATE фрагмента вызывается в performCreate. Если вы добавляете фрагмент к методу onCreate Activity, и этот фрагмент также добавляет мониторинг LifecycleObserver, то кто будет слушать первым?
Например:
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
lifecycle.addObserver(Presenter())
supportFragmentManager.beginTransaction().replace(R.id.container,MainFragment()).commit()
}
}
class Presenter:LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreate(){
println("presenter oncreate")
}
class MainFragment:Fragment() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
lifecycle.addObserver(FragmentPresenter())
}
}
class FragmentPresenter:LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreate(){
println("presenter fragment oncreate")
}
}
Запустите программу, и вы обнаружите, что результат печати - presenter oncreate, а затем presenter фрагмент oncreate.
Это очень сбивает с толку. Мы знаем, что жизненный цикл фрагмента onCreate предшествует onActivityCreated. Почему вы не выполнили сначала метод onCreate FragmentPresenter ? Причина на самом деле фиксация. Это асинхронно. Когда объект фрагмента отправлен, он будет вызван в то время, поэтому MainFragment еще не добавлен, но ReportFragment вызывает метод manager.executePendingTransactions (), который выполнит существующий все сразу, поэтому этот ReportFragment был добавлен в FragmentManager, поэтому жизненный цикл не соответствует ситуации, если вы также добавите manager.executePendingTransactions () после фиксации MainFragment в MainActivity, вы обнаружите, что результат печати обратный.
2.3 Анализ жизненного цикла
В центре внимания LifecycleRegister, сначала посмотрите на метод 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) {
// it is null we should be destroyed. Fallback quickly
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();
// mState / subling may have been changed recalculate
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
// we do sync only on the top level.
sync();
}
mAddingObserverCounter--;
}
Здесь вы обнаружите, что ObserverWithState создается и помещается в FastSafeIterableMap.Этот класс
представляет собой настраиваемый список для сохранения наблюдателей и обработки удаления / добавления во время обхода.
Наблюдатель 1 и Наблюдатель 2 в любой момент: если добавление_order (наблюдатель1) <добавление_ордера (наблюдатель2), то состояние (наблюдатель1)> = состояние (наблюдатель2)
Затем посмотрите на метод handleLifecycleEvent
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}
Во-первых, соответствующее состояние будет получено в соответствии с входящим событием. Конкретные отношения между объектами показаны
на рисунке ниже. В методе moveToState будет вызываться метод синхронизации.
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;
}
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;
}
Здесь вы можете видеть, что если состояние ObserverWithState меньше текущего состояния, то вызывается метод forwardPass. Если он больше текущего состояния, то вызывается метод backwardPass. Состояние по умолчанию для ObserverWithState определяется в addObserver метод.
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
Тогда посмотрите на метод forwardPass
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();
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
popParentState();
}
}
}
Здесь вызывается метод dispatchEvent ObserverWithState, взгляните на этот метод
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
Правда выяснилась, и, наконец, вызвали mLifecycleObserver.onStateChanged (владелец, событие); в то же время я обновил свое состояние, как этот mLifecycleObserver получил его, и что конкретно он сделал, я не буду говорить это конкретно, вы можете войти и взглянуть, если вам интересно. Вызывающий метод в этой статье будет генерировать объект ReflectiveGenericLifecycleObserver, который будет содержать объект Method метода, аннотированный с помощью @OnLifecycleEvent, объявленного в Presenter, а затем, наконец, вызовет его.
Добро пожаловать, чтобы подписаться на мою официальную учетную запись