LiveData的定义
LiveData是一个可观察数据的持有者, 但是不像普通的可观察数据, LiveData绑定了生命周期，例如Activity, Fragment的生命周期。有点抽象, 还是先了解一下关键的类。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
public interface Observer<T> {
void onChanged(@Nullable T t);
}
public abstract class LiveData<T> {
public void observe(LifecycleOwner owner, Observer<T> observer)
public void observeForever(Observer<T> observer)
public void removeObserver(Observer<T> observer)
public void removeObservers(final LifecycleOwner owner)
public boolean hasObservers()
public boolean hasActiveObservers()
}
public class MutableLiveData<T> extends LiveData<T> {
public void postValue(T value)
public void setValue(T value)
}
|
介绍完了主要的类，下面举个例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
liveData.observe(this, new Observer<User>() {
@Override
public void onChanged(@Nullable User user) {
}
});
liveData = new MutableLiveData<User>()
liveData.postValue(user)
|
下面还是看看LiveData源码去了解一下原理
工作原理
这里以observe(LifecycleOwner owner, Observer observer) 和 postValue之间数据的通讯为例分析。下面看LiveData.observe源码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
return;
}
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
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);
}
|
接着看LifecycleBoundObserver和ObserverWrapper片段:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
| class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
@NonNull final LifecycleOwner mOwner;
@Override
boolean shouldBeActive() {
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
removeObserver(mObserver);
return;
}
activeStateChanged(shouldBeActive());
}
}
private abstract class ObserverWrapper {
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);
}
}
}
private void considerNotify(ObserverWrapper observer) {
if (!observer.mActive) {
return;
}
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false);
return;
}
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
observer.mObserver.onChanged((T) mData);
调用onChanged分发改变的数据
}
|
接着看postValue方法是是如果把值传到onChanged里：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
|
protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
postTask = mPendingData == NOT_SET;
mPendingData = value;
}
if (!postTask) {
return;
}
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}
private final Runnable mPostValueRunnable = new Runnable() {
@Override
public void run() {
Object newValue;
synchronized (mDataLock) {
newValue = mPendingData;
mPendingData = NOT_SET;
}
setValue((T) newValue);
}
};
@MainThread
protected void setValue(T value) {
assertMainThread("setValue");
mVersion++;
mData = value;
dispatchingValue(null);
}
private void dispatchingValue(@Nullable ObserverWrapper initiator) {
...
for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
}
}
|
LiveData优点
- UI和数据保持一致：遵循观察者模式，生命周期状态更改时，LiveData会通知Observer对象
- 避免内存泄漏：观察者绑定到Lifecycle对象，并在其相关生命周期走向Destroy后自行清理
- 不会因stop而崩溃：处于非活动状态，不会接收到LiveData事件，如Activity变为不可见
- 自动感知生命周期：LiveData自动管理在观察时意识到相关的生命周期状态变化。
- 数据始终保持最新：生命周期变为非活动状态再次变为活动状态时接收最新数据。 例如，Activity不可见变为可见时立即接收最新数据
- 解决Configuration changes问题：当屏幕旋转或者回收时，重新创建Activity或Fragment，可以即时收到数据变更
- 共享资源：使用单例扩展LiveData，就可在app中共享它
