ADD week 5
This commit is contained in:
318
02-Easy5/E5/sources/androidx/lifecycle/LiveData.java
Normal file
318
02-Easy5/E5/sources/androidx/lifecycle/LiveData.java
Normal file
@@ -0,0 +1,318 @@
|
||||
package androidx.lifecycle;
|
||||
|
||||
import androidx.arch.core.executor.ArchTaskExecutor;
|
||||
import androidx.arch.core.internal.SafeIterableMap;
|
||||
import androidx.lifecycle.Lifecycle;
|
||||
import java.util.Iterator;
|
||||
import java.util.Map;
|
||||
|
||||
/* loaded from: classes.dex */
|
||||
public abstract class LiveData<T> {
|
||||
static final Object NOT_SET = new Object();
|
||||
static final int START_VERSION = -1;
|
||||
int mActiveCount;
|
||||
private boolean mChangingActiveState;
|
||||
private volatile Object mData;
|
||||
final Object mDataLock;
|
||||
private boolean mDispatchInvalidated;
|
||||
private boolean mDispatchingValue;
|
||||
private SafeIterableMap<Observer<? super T>, LiveData<T>.ObserverWrapper> mObservers;
|
||||
volatile Object mPendingData;
|
||||
private final Runnable mPostValueRunnable;
|
||||
private int mVersion;
|
||||
|
||||
public T getValue() {
|
||||
T t = (T) this.mData;
|
||||
if (t != NOT_SET) {
|
||||
return t;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
int getVersion() {
|
||||
return this.mVersion;
|
||||
}
|
||||
|
||||
public boolean hasActiveObservers() {
|
||||
return this.mActiveCount > 0;
|
||||
}
|
||||
|
||||
public boolean isInitialized() {
|
||||
return this.mData != NOT_SET;
|
||||
}
|
||||
|
||||
protected void onActive() {
|
||||
}
|
||||
|
||||
protected void onInactive() {
|
||||
}
|
||||
|
||||
public LiveData(T t) {
|
||||
this.mDataLock = new Object();
|
||||
this.mObservers = new SafeIterableMap<>();
|
||||
this.mActiveCount = 0;
|
||||
this.mPendingData = NOT_SET;
|
||||
this.mPostValueRunnable = new Runnable() { // from class: androidx.lifecycle.LiveData.1
|
||||
/* JADX WARN: Multi-variable type inference failed */
|
||||
@Override // java.lang.Runnable
|
||||
public void run() {
|
||||
Object obj;
|
||||
synchronized (LiveData.this.mDataLock) {
|
||||
obj = LiveData.this.mPendingData;
|
||||
LiveData.this.mPendingData = LiveData.NOT_SET;
|
||||
}
|
||||
LiveData.this.setValue(obj);
|
||||
}
|
||||
};
|
||||
this.mData = t;
|
||||
this.mVersion = 0;
|
||||
}
|
||||
|
||||
public LiveData() {
|
||||
this.mDataLock = new Object();
|
||||
this.mObservers = new SafeIterableMap<>();
|
||||
this.mActiveCount = 0;
|
||||
Object obj = NOT_SET;
|
||||
this.mPendingData = obj;
|
||||
this.mPostValueRunnable = new Runnable() { // from class: androidx.lifecycle.LiveData.1
|
||||
/* JADX WARN: Multi-variable type inference failed */
|
||||
@Override // java.lang.Runnable
|
||||
public void run() {
|
||||
Object obj2;
|
||||
synchronized (LiveData.this.mDataLock) {
|
||||
obj2 = LiveData.this.mPendingData;
|
||||
LiveData.this.mPendingData = LiveData.NOT_SET;
|
||||
}
|
||||
LiveData.this.setValue(obj2);
|
||||
}
|
||||
};
|
||||
this.mData = obj;
|
||||
this.mVersion = -1;
|
||||
}
|
||||
|
||||
private void considerNotify(LiveData<T>.ObserverWrapper observerWrapper) {
|
||||
if (observerWrapper.mActive) {
|
||||
if (!observerWrapper.shouldBeActive()) {
|
||||
observerWrapper.activeStateChanged(false);
|
||||
return;
|
||||
}
|
||||
int i = observerWrapper.mLastVersion;
|
||||
int i2 = this.mVersion;
|
||||
if (i >= i2) {
|
||||
return;
|
||||
}
|
||||
observerWrapper.mLastVersion = i2;
|
||||
observerWrapper.mObserver.onChanged((Object) this.mData);
|
||||
}
|
||||
}
|
||||
|
||||
void dispatchingValue(LiveData<T>.ObserverWrapper observerWrapper) {
|
||||
if (this.mDispatchingValue) {
|
||||
this.mDispatchInvalidated = true;
|
||||
return;
|
||||
}
|
||||
this.mDispatchingValue = true;
|
||||
do {
|
||||
this.mDispatchInvalidated = false;
|
||||
if (observerWrapper != null) {
|
||||
considerNotify(observerWrapper);
|
||||
observerWrapper = null;
|
||||
} else {
|
||||
SafeIterableMap<Observer<? super T>, LiveData<T>.ObserverWrapper>.IteratorWithAdditions iteratorWithAdditions = this.mObservers.iteratorWithAdditions();
|
||||
while (iteratorWithAdditions.hasNext()) {
|
||||
considerNotify((ObserverWrapper) iteratorWithAdditions.next().getValue());
|
||||
if (this.mDispatchInvalidated) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} while (this.mDispatchInvalidated);
|
||||
this.mDispatchingValue = false;
|
||||
}
|
||||
|
||||
public void observe(LifecycleOwner lifecycleOwner, Observer<? super T> observer) {
|
||||
assertMainThread("observe");
|
||||
if (lifecycleOwner.getLifecycle().getCurrentState() == Lifecycle.State.DESTROYED) {
|
||||
return;
|
||||
}
|
||||
LifecycleBoundObserver lifecycleBoundObserver = new LifecycleBoundObserver(lifecycleOwner, observer);
|
||||
LiveData<T>.ObserverWrapper putIfAbsent = this.mObservers.putIfAbsent(observer, lifecycleBoundObserver);
|
||||
if (putIfAbsent != null && !putIfAbsent.isAttachedTo(lifecycleOwner)) {
|
||||
throw new IllegalArgumentException("Cannot add the same observer with different lifecycles");
|
||||
}
|
||||
if (putIfAbsent != null) {
|
||||
return;
|
||||
}
|
||||
lifecycleOwner.getLifecycle().addObserver(lifecycleBoundObserver);
|
||||
}
|
||||
|
||||
public void observeForever(Observer<? super T> observer) {
|
||||
assertMainThread("observeForever");
|
||||
AlwaysActiveObserver alwaysActiveObserver = new AlwaysActiveObserver(observer);
|
||||
LiveData<T>.ObserverWrapper putIfAbsent = this.mObservers.putIfAbsent(observer, alwaysActiveObserver);
|
||||
if (putIfAbsent instanceof LifecycleBoundObserver) {
|
||||
throw new IllegalArgumentException("Cannot add the same observer with different lifecycles");
|
||||
}
|
||||
if (putIfAbsent != null) {
|
||||
return;
|
||||
}
|
||||
alwaysActiveObserver.activeStateChanged(true);
|
||||
}
|
||||
|
||||
public void removeObserver(Observer<? super T> observer) {
|
||||
assertMainThread("removeObserver");
|
||||
LiveData<T>.ObserverWrapper remove = this.mObservers.remove(observer);
|
||||
if (remove == null) {
|
||||
return;
|
||||
}
|
||||
remove.detachObserver();
|
||||
remove.activeStateChanged(false);
|
||||
}
|
||||
|
||||
public void removeObservers(LifecycleOwner lifecycleOwner) {
|
||||
assertMainThread("removeObservers");
|
||||
Iterator<Map.Entry<Observer<? super T>, LiveData<T>.ObserverWrapper>> it = this.mObservers.iterator();
|
||||
while (it.hasNext()) {
|
||||
Map.Entry<Observer<? super T>, LiveData<T>.ObserverWrapper> next = it.next();
|
||||
if (next.getValue().isAttachedTo(lifecycleOwner)) {
|
||||
removeObserver(next.getKey());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected void postValue(T t) {
|
||||
boolean z;
|
||||
synchronized (this.mDataLock) {
|
||||
z = this.mPendingData == NOT_SET;
|
||||
this.mPendingData = t;
|
||||
}
|
||||
if (z) {
|
||||
ArchTaskExecutor.getInstance().postToMainThread(this.mPostValueRunnable);
|
||||
}
|
||||
}
|
||||
|
||||
protected void setValue(T t) {
|
||||
assertMainThread("setValue");
|
||||
this.mVersion++;
|
||||
this.mData = t;
|
||||
dispatchingValue(null);
|
||||
}
|
||||
|
||||
public boolean hasObservers() {
|
||||
return this.mObservers.size() > 0;
|
||||
}
|
||||
|
||||
void changeActiveCounter(int i) {
|
||||
int i2 = this.mActiveCount;
|
||||
this.mActiveCount = i + i2;
|
||||
if (this.mChangingActiveState) {
|
||||
return;
|
||||
}
|
||||
this.mChangingActiveState = true;
|
||||
while (true) {
|
||||
try {
|
||||
int i3 = this.mActiveCount;
|
||||
if (i2 == i3) {
|
||||
return;
|
||||
}
|
||||
boolean z = i2 == 0 && i3 > 0;
|
||||
boolean z2 = i2 > 0 && i3 == 0;
|
||||
if (z) {
|
||||
onActive();
|
||||
} else if (z2) {
|
||||
onInactive();
|
||||
}
|
||||
i2 = i3;
|
||||
} finally {
|
||||
this.mChangingActiveState = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class LifecycleBoundObserver extends LiveData<T>.ObserverWrapper implements LifecycleEventObserver {
|
||||
final LifecycleOwner mOwner;
|
||||
|
||||
@Override // androidx.lifecycle.LiveData.ObserverWrapper
|
||||
boolean isAttachedTo(LifecycleOwner lifecycleOwner) {
|
||||
return this.mOwner == lifecycleOwner;
|
||||
}
|
||||
|
||||
LifecycleBoundObserver(LifecycleOwner lifecycleOwner, Observer<? super T> observer) {
|
||||
super(observer);
|
||||
this.mOwner = lifecycleOwner;
|
||||
}
|
||||
|
||||
@Override // androidx.lifecycle.LiveData.ObserverWrapper
|
||||
boolean shouldBeActive() {
|
||||
return this.mOwner.getLifecycle().getCurrentState().isAtLeast(Lifecycle.State.STARTED);
|
||||
}
|
||||
|
||||
@Override // androidx.lifecycle.LifecycleEventObserver
|
||||
public void onStateChanged(LifecycleOwner lifecycleOwner, Lifecycle.Event event) {
|
||||
Lifecycle.State currentState = this.mOwner.getLifecycle().getCurrentState();
|
||||
if (currentState == Lifecycle.State.DESTROYED) {
|
||||
LiveData.this.removeObserver(this.mObserver);
|
||||
return;
|
||||
}
|
||||
Lifecycle.State state = null;
|
||||
while (state != currentState) {
|
||||
activeStateChanged(shouldBeActive());
|
||||
state = currentState;
|
||||
currentState = this.mOwner.getLifecycle().getCurrentState();
|
||||
}
|
||||
}
|
||||
|
||||
@Override // androidx.lifecycle.LiveData.ObserverWrapper
|
||||
void detachObserver() {
|
||||
this.mOwner.getLifecycle().removeObserver(this);
|
||||
}
|
||||
}
|
||||
|
||||
private abstract class ObserverWrapper {
|
||||
boolean mActive;
|
||||
int mLastVersion = -1;
|
||||
final Observer<? super T> mObserver;
|
||||
|
||||
void detachObserver() {
|
||||
}
|
||||
|
||||
boolean isAttachedTo(LifecycleOwner lifecycleOwner) {
|
||||
return false;
|
||||
}
|
||||
|
||||
abstract boolean shouldBeActive();
|
||||
|
||||
ObserverWrapper(Observer<? super T> observer) {
|
||||
this.mObserver = observer;
|
||||
}
|
||||
|
||||
void activeStateChanged(boolean z) {
|
||||
if (z == this.mActive) {
|
||||
return;
|
||||
}
|
||||
this.mActive = z;
|
||||
LiveData.this.changeActiveCounter(z ? 1 : -1);
|
||||
if (this.mActive) {
|
||||
LiveData.this.dispatchingValue(this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class AlwaysActiveObserver extends LiveData<T>.ObserverWrapper {
|
||||
@Override // androidx.lifecycle.LiveData.ObserverWrapper
|
||||
boolean shouldBeActive() {
|
||||
return true;
|
||||
}
|
||||
|
||||
AlwaysActiveObserver(Observer<? super T> observer) {
|
||||
super(observer);
|
||||
}
|
||||
}
|
||||
|
||||
static void assertMainThread(String str) {
|
||||
if (ArchTaskExecutor.getInstance().isMainThread()) {
|
||||
return;
|
||||
}
|
||||
throw new IllegalStateException("Cannot invoke " + str + " on a background thread");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user