Android Jetpack之Lifecycles + LiveData探索

最新推荐文章于 2024-04-10 01:12:38 发布
最新推荐文章于 2024-04-10 01:12:38 发布
阅读量428 收藏
点赞数
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/youxitongyongming/article/details/86560639
版权

目录

总览

  实现一种可感知生命周期的观察者模式。在Activity或者Fragment中的生命周期回调函数中去发起事件，通知观察者。官方给出的最佳实践方案即LiveData。

类图关系

  分为3个模块，Lifecycle、LifecycleOwner、LifecycleObserver：
Lifecycle类图
  先做一个全局的分析。LifecycleOwner即生命周期的持有者，系统中的实现就是Fragment和SupporActivityComponentActivity ，它们都持有一个LifecycleRegister对象，会在各个生命周期函数中去调用LifecycleRegister的相应Api发起生命周期变化的事件Lifecycle.Event，随即计算出下一步的状态Lifecycle.State。

public enum Event {
        /**
         * Constant for onCreate event of the {@link LifecycleOwner}.
         */
        ON_CREATE,
        /**
         * Constant for onStart event of the {@link LifecycleOwner}.
         */
        ON_START,
        /**
         * Constant for onResume event of the {@link LifecycleOwner}.
         */
        ON_RESUME,
        /**
         * Constant for onPause event of the {@link LifecycleOwner}.
         */
        ON_PAUSE,
        /**
         * Constant for onStop event of the {@link LifecycleOwner}.
         */
        ON_STOP,
        /**
         * Constant for onDestroy event of the {@link LifecycleOwner}.
         */
        ON_DESTROY,
        /**
         * An {@link Event Event} constant that can be used to match all events.
         */
        ON_ANY
    }

   /**
     * Lifecycle states. You can consider the states as the nodes in a graph and
     * {@link Event}s as the edges between these nodes.
     */
    @SuppressWarnings("WeakerAccess")
    public enum State {
        /**
         * Destroyed state for a LifecycleOwner. After this event, this Lifecycle will not dispatch
         * any more events. For instance, for an {@link android.app.Activity}, this state is reached
         * <b>right before</b> Activity's {@link android.app.Activity#onDestroy() onDestroy} call.
         */
        DESTROYED,

        /**
         * Initialized state for a LifecycleOwner. For an {@link android.app.Activity}, this is
         * the state when it is constructed but has not received
         * {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} yet.
         */
        INITIALIZED,

        /**
         * Created state for a LifecycleOwner. For an {@link android.app.Activity}, this state
         * is reached in two cases:
         * <ul>
         *     <li>after {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} call;
         *     <li><b>right before</b> {@link android.app.Activity#onStop() onStop} call.
         * </ul>
         */
        CREATED,

        /**
         * Started state for a LifecycleOwner. For an {@link android.app.Activity}, this state
         * is reached in two cases:
         * <ul>
         *     <li>after {@link android.app.Activity#onStart() onStart} call;
         *     <li><b>right before</b> {@link android.app.Activity#onPause() onPause} call.
         * </ul>
         */
        STARTED,

        /**
         * Resumed state for a LifecycleOwner. For an {@link android.app.Activity}, this state
         * is reached after {@link android.app.Activity#onResume() onResume} is called.
         */
        RESUMED;

        /**
         * Compares if this State is greater or equal to the given {@code state}.
         *
         * @param state State to compare with
         * @return true if this State is greater or equal to the given {@code state}
         */
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }

  下边贴一张Goolge官方的图，把event比作边，state比作点。这样在生命周期发生变化时发出对应的事件，然后再根据当前的状态确定下一个变化的状态。
lifecycle-states
  LifecycleRegistry中持有所有的LifecycleObserver对象，当收到生命周期变化的事件后就会尝试通知所有的LifecycleObserver，最终会回调LifecycleObserver.onStateChanged(LifecycleOwner source, Lifecycle.Event event)函数。

生命周期事件的分发

  1. ComponentActivity中进行分发
protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mSavedStateRegistryController.performRestore(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
        if (mContentLayoutId != 0) {
            setContentView(mContentLayoutId);
        }
    }

  在onCreate方法中，调用了ReportFragment.injectIfNeededIn(this), 生命周期事件的分发就是通过这个ReportFragment来进行代理的。injectIfNeededIn方法很简单就是向Activity中添加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();
        }
    }

  接下来看ReportFragment到底是如何分发生命周期事件的

public class ReportFragment extends Fragment {
@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 LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }
}

  我们可以看到在各个生命周期函数中都调用了dispatch方法发起对应生命周期的事件。而dispatch方法也很简单，最终回调了LifecycleRegistry的handleLifecycleEvent方法。

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        //根据事件去计算下一个状态
        State next = getStateAfter(event);
        moveToState(next);
}
//这个方法对照着上边那张生命周期变化的图就可以很好理解
static State getStateAfter(Event event) {
        switch (event) {
            case ON_CREATE:
            case ON_STOP:
                return CREATED;
            case ON_START:
            case ON_PAUSE:
                return STARTED;
            case ON_RESUME:
                return RESUMED;
            case ON_DESTROY:
                return DESTROYED;
            case ON_ANY:
                break;
        }
        throw new IllegalArgumentException("Unexpected event value " + event);
}


private void moveToState(State next) {
        if (mState == next) {
            return;
        }
        //更新状态
        mState = next;
        mHandlingEvent = true;
        //同步LifeCycleRegistry中的Observer的状态
        sync();
        mHandlingEvent = false;
}

  关键代码sync()。

private void sync() {
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        while (!isSynced()) {
            //当前LifeCycleRegistry的状态小于最早添加的observer状态，就进行后向遍历
            //由于状态State是一个枚举变量，所以在前边定义的状态就“小于”后边定义的状态
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
            }
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            //当前LifeCycleRegistry的状态大于最晚添加的observer状态，就进行前向遍历
            if (newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        
}

  前向遍历和后向遍历逻辑差不多，这里只分析一个。forwardPass 每次只能更新一个状态，不能跳跃的进行变化。
比如当前LifecycleRegistry的state为RESUMED，observer的state为INITIALIZED，那么变换的过程只能是INITIALIZED -> CREATED -> STARTED -> RESUMED。
最终经过3次变化才能和LifecycleRegistry状态保持一致。LiveData中对状态变化还做了额外的处理，保证了在上诉过程中最多通知用户一次，这在后边会进行分析。



private void forwardPass(LifecycleOwner lifecycleOwner) {
        //保留核心代码
        Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
                mObserverMap.iteratorWithAdditions();
        while (ascendingIterator.hasNext()) {
            Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) < 0) {
                observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
            }
        }
}

void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            //通知LiveData中管理的observer，最后会回调用户自己添加的observer.onchanged
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
}

//用于计算从当前状态变换到后一个状态需要的事件
private static Event upEvent(State state) {
        switch (state) {
            case INITIALIZED:
            case DESTROYED:
                return ON_CREATE;
            case CREATED:
                return ON_START;
            case STARTED:
                return ON_RESUME;
            case RESUMED:
                throw new IllegalArgumentException();
        }
        throw new IllegalArgumentException("Unexpected state value " + state);
}

  用一个流程图来总结生命周期事件的传递流程：
生命周期事件传递
  这里补充分析一下LiveData是怎么在生命周期状态变换中保证最多一次通知的。对于LiveData内部的LifecycleBoundObserver来说，它只有两种状态：激活（mActive = true）或者非激活（mActive = false），系统默认的实现是只有LifecycleOwner处于STARTED或者RESUMED两个状态时mActive才为true，了解这个原理后对照下边的源码就很容易理解为什么能保证最多一次通知了：

void activeStateChanged(boolean newActive) {
	if (newActive == mActive) {
		return;
	}
	mActive = newActive;
	boolean wasInactive = LiveData.this.mActiveCount == 0;
	LiveData.this.mActiveCount += mActive ? 1 : -1;
	if (wasInactive && mActive) {
		onActive();
	}
	if (LiveData.this.mActiveCount == 0 && !mActive) {
		onInactive();
	}
	if (mActive) {
		dispatchingValue(this);
	}
}

  关键就是第一个if语句的判断，只有激活状态改变才会执行后续的逻辑。举个例子：
LifecycleOwner从CREATED —ON_START—> STARTED —ON_RESUME—> RESUMED，经历了两次状态的改变，但对于LifecycleBoundObserver来说就变化了一次，CREATED —ON_START—> STARTED时，从mActive = false -> mActive = true，后续STARTED —ON_RESUME—> RESUMED对于LifecycleBoundObserver来说都处于激活状态，所以就不会再执行后续逻辑进行通知了。
2. Fragment中的分发
  大致流程和上边一样，主要看分发的入口，直接在自己的生命周期函数中进行回调

void performCreate(Bundle savedInstanceState) {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
void performStart() {
        if (mView != null) {
            mViewLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
        }
}

如何观察生命周期变化

  • 方式1（官方推荐）：通过注解进行监听
public class MyActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getLifecycle().addObserver(new LifecycleObserver() {
            @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
            public void onResume() {
                Log.d("lifecycle", "event ->" + Lifecycle.Event.ON_RESUME);
            }

            @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
            public void onPause() {
                Log.d("lifecycle", "event ->" + Lifecycle.Event.ON_PAUSE);
            }
        });
    }
}
  • 方式2（随着androidx库的推进，该类有可能废弃）：通过实现LifecycleEventObserver接口来监听
public class Activity2 extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getLifecycle().addObserver(
            (LifecycleEventObserver) (source, event) -> Log.d("lifecycle" ,"event ->" + event)
        );
    }
}
  • 方式3：通过LiveData来间接进行观察，生命周期的变化会被LiveData内部进行观察，不会直接回调给用户。LiveData只会把”可见“状态下的事件变化回调给用户。基于此实现，LiveData才能够只在Activity/Fragment处于可见状态时通知用户去刷新数据。

LiveData使用及原理分析

添加观察者

class NameActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val liveData = MutableLiveData<String>()
        // Create the observer which updates the UI.
        val nameObserver = Observer<String> { newName ->
            // Update the UI, in this case, a TextView.
            mNameTextView.text = newName
        }
        // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
        liveData.observe(this, nameObserver)
    }
}

  关键代码liveData.observe(this, nameObserver)，跟进一下源码：

private SafeIterableMap<Observer<T>, ObserverWrapper> mObservers =
            new SafeIterableMap<>();
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
    if (owner.getLifecycle().getCurrentState() == DESTROYED) {
        // ignore
        return;
    }
    LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
    ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
    //同一个observer只能绑定一个lifecycleOwner
    if (existing != null && !existing.isAttachedTo(owner)) {
        throw new IllegalArgumentException("Cannot add the same observer"
                + " with different lifecycles");
    }
    if (existing != null) {
        return;
    }
    owner.getLifecycle().addObserver(wrapper);
}

  对用户传入的 Observer<T> 封装为其内部的一个类 LifecycleBoundObserver 并保存于内部的一个 map中，随后调用LifecycleRegistry的addObserver(wrapper) 方法进行观察者的添加。Observer<T>是暴露给用户使用的，该接口非常简单：

public interface Observer<T> {
    void onChanged(@Nullable T t);
}

  Observer<T>会被封装到LifecycleBoundObserver对象中去，这一层封装持有了三个比较重要的属性：

  • LifecycleOwner mOwner //生命周期的持有者，需要通过它来判断当前的状态，来决定是否通知用户
  • Observer<? super T> mObserver //外部传入的观察者，通过它来对用户进行回调
  • boolean mActive //记录当前是否处于激活状态
  • int mLastVersion //初始值为-1，通过它和LiveData内部的mLastVersion进行对比，来决定是否要通知用户。该变量使得LiveData默认具有粘性事件的特性。

  LifecycleBoundObserver源码如下：

class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
	  @NonNull final LifecycleOwner mOwner;
	
	  LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<T> observer) {
	      super(observer);
	      mOwner = owner;
	  }
	  //实现GenericLifecycleObserver
	  @Override
	  public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
	      if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
	          removeObserver(mObserver);
	          return;
	      }
	      activeStateChanged(shouldBeActive());
	  }
	  //据此来决定是否通知用户
	  @Override
	  boolean shouldBeActive() {
	      return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
	  }
	  
	  @Override
	  boolean isAttachedTo(LifecycleOwner owner) {
	      return mOwner == owner;
	  }
	
	  @Override
	  void detachObserver() {
	      mOwner.getLifecycle().removeObserver(this);
	  }
}

  上边分析过，生命周期的变化，最终会回调 GenericLifecycleObserver.onStateChanged() 去通知观察者，由代码可知LivaData中事件的处理由 activeStateChanged() 函数来实现。这里先不看它的实现，后边调用到的时候再进行分析。
  回到关键代码的调用owner.getLifecycle().addObserver(wrapper)。getLifecycle()就是返回了LifecycleRegistry对象，看一下它的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);
        //省略掉事件分发的逻辑，后边分析
    }

  这里又出现了一个 ObserverWithState类 ，又对传入的observe再做了一次封装！下边给出一张图，帮助大家分析：
Observer封装
  蓝色区域是暴露给用户的观察者observer1，它只有一个onChanged回调函数。黄色区域是LiveData中的一个类，在调用LiveData.addObserver(observer1)时，对observer1进行了一个封装->observer2：LifecycleBoundObserver，主要是实现了生命周期事件的回调函数onStateChanged()。红色区域是LifecycleRegistry中的一个类，在调用LifecycleRegistry.addObserver(observer2)时，对observer2进行了封装->observer3:ObserverWithState，主要包含了状态变量State，还有事件的分发函数dispatchEvent()，看一下ObserverWithState的源码：

static class ObserverWithState {
     //初始状态为 INITIALIZED
     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;
     }
}

  这个dispatchEvent函数是不是很眼熟，没错，就是生命周期变化后会回调的。
  弄明白了这几层Observer的关系之后，回到LifecycleRegistry.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);
     //一般情况下，对于刚添加进来的observer，targetState都为当前LifecycleRegistry的State
     State targetState = calculateTargetState(observer);
  
     while (statefulObserver.mState.compareTo(targetState) < 0) {
         pushParentState(statefulObserver.mState);
         statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
         popParentState();
         // mState / subling may have been changed recalculate
         targetState = calculateTargetState(observer);
     }
 }

  首先对Observer又进行了一层封装，然后添加到内部的一个map中。随后计算一个targetState，一般情况下，对于刚添加进来的observer，targetState都为当前LifecycleRegistry的State。也就是说，对刚添加的observer，如果它的状态”小于“当前LifecycleOwner的状态，那么就会进行状态的更新，以保持状态的一致性。具体的通知，关键的代码就是while循环当中的statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState))，上边分析过这个方法，其内部还是调用了GenericLifecycleObserver.onStateChanged()，这是一个接口方法，上边有提到在LiveData中的实现如下：

public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
      if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
           removeObserver(mObserver);
           return;
      }
      activeStateChanged(shouldBeActive());
}

boolean shouldBeActive() {
    return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}

void activeStateChanged(boolean newActive) {
      if (newActive == mActive) {
          return;
      }
      // owner
      mActive = newActive;
      boolean wasInactive = LiveData.this.mActiveCount == 0;
      LiveData.this.mActiveCount += mActive ? 1 : -1;
      if (wasInactive && mActive) {
          //当active状态的观察者数量从0变为1时（从无到有）
          onActive();
      }
      if (LiveData.this.mActiveCount == 0 && !mActive) {
          //当active状态的观察者数量从1变为0（从有变无，这里的无是指
          //observer is not active）
          onInactive();
      }
      if (mActive) {
          dispatchingValue(this);
      }
  }

  onActive()和onInactive()默认实现为空方法，可以通过继承LiveData去重写它们。这里的关键代码是dispatchingValue(this)，请记住这个this（注意这里的是指LiveData.LifecycleBoundObserver）。下面贴出dispatchingValue(this)：

private void dispatchingValue(@Nullable ObserverWrapper initiator) {
    if (mDispatchingValue) {
        mDispatchInvalidated = true;
        return;
    }
    mDispatchingValue = true;
    do {
        mDispatchInvalidated = false;
        if (initiator != null) {
            considerNotify(initiator);
            initiator = null;
        } else {
            for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =
                    mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                considerNotify(iterator.next().getValue());
                if (mDispatchInvalidated) {
                    break;
                }
            }
        }
    } while (mDispatchInvalidated);
    mDispatchingValue = false;
}

  关键代码就是considerNotify()。initator如果不为空，就只通知当前这一个ObserverWrapper 。如果为空，那么就会遍历所有的ObserverWrapper ，依次进行通知。具体dispatchingValue的调用情况，这里给大家总结了三种情形：

  • 用户调用LiveData.observe()时。在添加观察者的时候，一般情况会调用ObserverWithState.dispatchEvent(LifecycleOwner owner, Event event)最后调用LiveData.dispatchingValue(this)进行通知。
  • LifecycleOwner的生命周期发生变化时。此时会发起对应的EventObserverWithState.dispatchEvent(LifecycleOwner owner, Event event)，然后调用LiveData.dispatchingValue(this)，通知当前的Observer。（注意上下文，这里的dispatchingValue是LiveData里的函数，但是当生命周期发生变化时，在LifecycleRegistry内部还是会遍历所有的Observer去通知它们，需要和下边第3中情况区分开）
  • 用户手动调用LiveData.setValue()/LiveData.postValue()，此时会调用dispatchingValue(null)，通知所有的Observer。
      最后来看看considerNotify()函数的源码：
private void considerNotify(ObserverWrapper observer) {
     if (!observer.mActive) {
         return;
     }
     if (observer.mLastVersion >= mVersion) {
         return;
     }
     observer.mLastVersion = mVersion;
     //noinspection unchecked
     observer.mObserver.onChanged((T) mData);
 }

  这里有两个关键的判断逻辑

  • 判断是否处于激活状态
  • observer.mLastVersion = mVersion //mVersion是LiveData内部的变量，初始值为-1，每次调用setValue或者postValue时该变量会加1
    只有当处于激活状态且有数据发送过，最后才会调用observer.mObserver.onChanged((T) mData)去通知用户。
    下边给出LiveData添加观察者的流程图：
    在这里插入图片描述

发送数据

  LiveData发送数据就相对简单很对，系统提供了两个方法

  • 主线程调用：setValue(T value)
@MainThread
    protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;
        mData = value;
        dispatchingValue(null);
}

  这里dispatchingValue传入的是null，那么就会遍历LiveData中所有的observer进行通知

  • 子线程调用：postValue(T value)
protected void postValue(T value) {
        boolean postTask;
        synchronized (mDataLock) {
            postTask = mPendingData == NOT_SET;
            mPendingData = value;
        }
        if (!postTask) {
            return;
        }
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}

  首先把mPendingData设置为待改变了量value，随后ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable)通过handler发送一个Message到主线程的MessageQueue中，mPostValueRunnable实现了具体的更新操作：

private final Runnable mPostValueRunnable = new Runnable() {
        @Override
        public void run() {
            Object newValue;
            synchronized (mDataLock) {
                newValue = mPendingData;
                mPendingData = NOT_SET;
            }
            //noinspection unchecked
            setValue((T) newValue);
        }
};

  可以看到，最后还是调用了setValue((T) newValue)方法。由于采用了同步操作，如果多次调用postValue，那么mPendingData只会记录最后一次设置的值，而且主线程的MessageQueue中最多只会存在一个刷新数据的消息（持有mPostValueRunnable的Message）

总结

  LiveData能够观察两类事件：

  • 生命周期事件
  • 数据改变事件

  而用户真正关心的是数据改变事件，通过LiveData的内部逻辑帮我们简化了复杂的判断逻辑。
在这里插入图片描述
  到此，Lifecycle和LiveData整个流程就分析完了，如有理解不当的地方，欢迎大家一起交流学习！

EnjoyCodingEnjoyLife
关注
专栏目录
Android jetpack 之 LiveData
xujian197的博客
04-11 165
首先,LiveData是什么 LiveData是一种可以被观察的数据存储器类,它可以感知其他组件(比如Activity,Fragment)的生命周期,并只更新处于活跃状态的组件. 当我们的应用组件处于 STARTED 或 RESUMED 状态,LiveData则会认为该组件处于活跃状态 开始使用LiveData,LiveData一般搭配ViewModel一起使用 首先我们会创建一个ViewModel,在ViewModel里面在创建LiveData,并提供getter方法进行访问. class Name
Android_Jetpack:LiveData原理及使用ViewModel+ LiveData实现Fragment间的通信
nanquan11的博客
11-22 1095
说实话，一开始接触LiveData的概念，是通过郭神的《第一行代码(第三版)》，但是一股脑的各种概念铺天盖地而来，导致的后果就是面对LiveData莫名地有种恐惧，所以这也是我开始专门研究Jetpack的一个初衷（题外话，在小公司写传统业务代码，真的是可以用10年前的技术吃一辈子，严重脱节）。 一、LiveData原理 说回LiveData，可以将LiveData理解为一个数据的容器，它将数据包装起来，使数据成为被观察者，当该数据发生变化时，观察者能够获得通知。由于在LiveData内部默认已经实现好了观察
Android Jetpack组件之Lifecycles库详解
weixin_33994429的博客
01-15 161
Android Jetpack 组件是库的集合，这些库是为了协同工作而构建的，不过也可以单独采用，接下来会一一详细地学习这些库, 下面源码版本是com.android.support:appcompat-v7:28.0.0, 以及库android.arch.lifecycle:extensions:1.1.1 Lifecycles库是拿来干什么的 这个库从系统框架层去管理具有生命周期的组件，例如a...
Android Jetpack 之 LiveData
明年今日zhich
11-25 305
概述 LiveData 是一个持有数据的类，它持有的数据是可以被观察者订阅的，当数据被修改时就会通知观察者。观察者可以是 Activity、Fragment、Service 等。 LiveData 能够感知观察者的生命周期，只有当观察者处于激活状态（STARTED、RESUMED）才会接收到数据更新的通知，在未激活时会自动解注册观察者，以减少内存泄漏。 使用 LiveData 保存数据时，由于数...
安卓新架构Room与Lifecycles，LiveData
zrjliming的博客
02-20 214
Room  Lifecycles   生命周期管理（Lifecycles）获取ui的生命周期状态   ViewModel 将视图的数据和逻辑从具有生命周期特性的实体（如 Activity 和 Fragment）中剥离开来。直到关联的 Activity 或 Fragment 完全销毁时，ViewModel 才会随之消失，也就是说，即使在旋转屏幕导致 Fragment 被重新创建等事件中 Vi...
Android(Kotlin)Jetpack组件之Lifecycles使用与API
蓝渊智海的博客
12-26 415
Android_Kotlin_Jetpack组件之Lifecycles使用与APILifecycles概述Lifecycles使用依赖库LifecycleObserver与Activity的绑定及交互   该文章作为学习总结与API查询，如有错误欢迎各位大佬指正，对您有帮助的还望点赞支持下哟(* ^ ▽ ^ *)   欢迎大家聊聊理解，互相探讨，同时我也会将经典的问题更新到文章中，方便学习。 Lifecycles概述   Lifecycles的作用: 用于让任何一个类都可以接收到Activity的生命周
【Android Jetpack高手日志】LiveData 从入门到精通
最新发布
2401_84132298的博客
04-10 867
如果非要用一句话来总结，LiveData是在Lifecycle的帮助下，实现了生命周期管理的一致性，将数据变更的通知控制在生命周期活跃状态 STARTED、RESUMED（注意这是Lifecycle 中的 State）时进行通知，该通知成为数据的唯一可信来源，也就是视图获取数据的唯一入口。文末Jetpack Compose是谷歌在2019Google i/o大会上发布的新的库，是用于构建原生Android UI的现代工具包。
AACHulk::fire::fire::fire:AACHulk是以Google的ViewModel+DataBinding+LiveData+Lifecycles框架为基础， 结合Okhttp+Retrofit+BaseRecyclerViewAdapterHelper+SmartRefreshLayout+ARouter打造的一款快速MVVM开发框架
05-04
AACHulk是以Google的ViewModel+LiveData框架为基础， 结合Okhttp+Retrofit+BaseRecyclerViewAdapterHelper+SmartRefreshLayout+ARouter打造的一款快速开发框架， 开发语言是Kotlin，再结合进行开发， 避免一些繁琐的...
Android JetPack学习笔记之LiveData
马克福睿斯
04-02 999
Android JetPack学习笔记之LiveData前言LiveDataLiveData源码分析 前言 Jetpack 是 Android 软件组件的集合，使您可以更轻松地开发出色的 Android 应用。这些组件可帮助您遵循最佳做法、让您摆脱编写样板代码的工作并简化复杂任务，以便您将精力集中放在所需的代码上。 最近有空边学习边把学习笔记做了。巩固知识，输入输出，强化学习，如有不对望指出，感谢...
Android开发 - kotlin + jetpack + mvvm
06-30
一 快速入门kotlin（上...1. Lifecycles 2. LiveData 五 快速入门jetpack（中） 3. ViewModel 4. DataBinding 六 快速入门jetpack（下） 5. Room 6. WorkManager 七 搭建MVVM项目架构（上） 八 搭建MVVM项目架构（下）
Android架构——LifeCycle和LiveData原理学习总结
xiaobaaidaba123的专栏
02-20 4508
本文是楼主学习LifeCycle和LiveData原理的一些总结，本文不会长篇分析源码，而是利用类图和总结性的文字归纳原理。由于Livedata和LifeCycle有紧密联系，所以本文先总结LifeCycle原理，再总结LifeData原理。 本文LifeCycle基于版本androidx.lifecycle:lifecycle-runtime:2.1.0， LiveData基于版本androidx.lifecycle:lifecycle-livedata-core:2.0.0 本文内容结构 一、简单
Android--Jetpack--LiveData
袁震的博客
12-04 931
穷则独善其身，达则兼善天下
android Jetpack 之 LiveData
u014749572的博客
01-08 367
1.MutableLiveData.java LiveData的实现类。可以对Data进行设置。 postValue(T value):对调用的线程没有要求，调用后会直接对mPendingData进行设置。然后会向主线程的Handler发送一个Runnable。 好处： 1.在异步线程对数据进行修改 2.主线程没有执行mPostValueRunnable之前，异步线程能够多次听过po...
安卓jetpack:LiveData
A125679880的博客
07-07 769
LiveData 是 Android 架构组件中的一个类，用于在数据发生改变时通知观察者更新。它具有以下特点和功能：1. 数据观察：LiveData 允许其他组件（如 Activity、Fragment 或 Service）观察数据的变化。当数据发生变化时，相关观察者将收到通知，并可以执行相应的操作。2. 生命周期感知：LiveData 可以感知相关组件的生命周期状态，只有当组件处于活跃状态时，LiveData 才会通知观察者进行更新。这可以防止资源浪费和内存泄漏。
【Android Jetpack】LiveData
梦否
04-27 1720
文章目录1. 前言1.1 关于观察者模式2. LiveData 的优势2.1 案例一：计时器效果2.1.1 实现方式一：ViewModel+LiveData2.1.2 实现方式二：configChange 1. 前言 官网地址：https://developer.android.google.cn/topic/libraries/architecture/livedata 其实在使用ViewModel和LifeCycle的时候，我们已经看见了LiveData这个组件。在这篇博客中将继续来了解这个组件。其特点
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值