CrackMe.apk
Download file
package androidx.lifecycle;
import androidx.arch.core.executor.ArchTaskExecutor;
import androidx.arch.core.internal.FastSafeIterableMap;
import androidx.arch.core.internal.SafeIterableMap;
import androidx.lifecycle.Lifecycle;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map;
public class LifecycleRegistry extends Lifecycle {
private int mAddingObserverCounter;
private final boolean mEnforceMainThread;
private boolean mHandlingEvent;
private final WeakReference<LifecycleOwner> mLifecycleOwner;
private boolean mNewEventOccurred;
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap;
private ArrayList<Lifecycle.State> mParentStates;
private Lifecycle.State mState;
public LifecycleRegistry(LifecycleOwner lifecycleOwner) {
this(lifecycleOwner, true);
}
private LifecycleRegistry(LifecycleOwner lifecycleOwner, boolean z) {
this.mObserverMap = new FastSafeIterableMap<>();
this.mAddingObserverCounter = 0;
this.mHandlingEvent = false;
this.mNewEventOccurred = false;
this.mParentStates = new ArrayList<>();
this.mLifecycleOwner = new WeakReference<>(lifecycleOwner);
this.mState = Lifecycle.State.INITIALIZED;
this.mEnforceMainThread = z;
}
@Deprecated
public void markState(Lifecycle.State state) {
enforceMainThreadIfNeeded("markState");
setCurrentState(state);
}
public void setCurrentState(Lifecycle.State state) {
enforceMainThreadIfNeeded("setCurrentState");
moveToState(state);
}
public void handleLifecycleEvent(Lifecycle.Event event) {
enforceMainThreadIfNeeded("handleLifecycleEvent");
moveToState(event.getTargetState());
}
private void moveToState(Lifecycle.State state) {
if (this.mState != state) {
this.mState = state;
if (this.mHandlingEvent || this.mAddingObserverCounter != 0) {
this.mNewEventOccurred = true;
return;
}
this.mHandlingEvent = true;
sync();
this.mHandlingEvent = false;
}
}
private boolean isSynced() {
if (this.mObserverMap.size() == 0) {
return true;
}
Lifecycle.State state = this.mObserverMap.eldest().getValue().mState;
Lifecycle.State state2 = this.mObserverMap.newest().getValue().mState;
if (state == state2 && this.mState == state2) {
return true;
}
return false;
}
private Lifecycle.State calculateTargetState(LifecycleObserver lifecycleObserver) {
Map.Entry<LifecycleObserver, ObserverWithState> ceil = this.mObserverMap.ceil(lifecycleObserver);
Lifecycle.State state = null;
Lifecycle.State state2 = ceil != null ? ceil.getValue().mState : null;
if (!this.mParentStates.isEmpty()) {
ArrayList<Lifecycle.State> arrayList = this.mParentStates;
state = arrayList.get(arrayList.size() - 1);
}
return min(min(this.mState, state2), state);
}
public void addObserver(LifecycleObserver lifecycleObserver) {
LifecycleOwner lifecycleOwner;
enforceMainThreadIfNeeded("addObserver");
ObserverWithState observerWithState = new ObserverWithState(lifecycleObserver, this.mState == Lifecycle.State.DESTROYED ? Lifecycle.State.DESTROYED : Lifecycle.State.INITIALIZED);
if (this.mObserverMap.putIfAbsent(lifecycleObserver, observerWithState) == null && (lifecycleOwner = (LifecycleOwner) this.mLifecycleOwner.get()) != null) {
boolean z = this.mAddingObserverCounter != 0 || this.mHandlingEvent;
Lifecycle.State calculateTargetState = calculateTargetState(lifecycleObserver);
this.mAddingObserverCounter++;
while (observerWithState.mState.compareTo(calculateTargetState) < 0 && this.mObserverMap.contains(lifecycleObserver)) {
pushParentState(observerWithState.mState);
Lifecycle.Event upFrom = Lifecycle.Event.upFrom(observerWithState.mState);
if (upFrom != null) {
observerWithState.dispatchEvent(lifecycleOwner, upFrom);
popParentState();
calculateTargetState = calculateTargetState(lifecycleObserver);
} else {
throw new IllegalStateException("no event up from " + observerWithState.mState);
}
}
if (!z) {
sync();
}
this.mAddingObserverCounter--;
}
}
private void popParentState() {
ArrayList<Lifecycle.State> arrayList = this.mParentStates;
arrayList.remove(arrayList.size() - 1);
}
private void pushParentState(Lifecycle.State state) {
this.mParentStates.add(state);
}
public void removeObserver(LifecycleObserver lifecycleObserver) {
enforceMainThreadIfNeeded("removeObserver");
this.mObserverMap.remove(lifecycleObserver);
}
public int getObserverCount() {
enforceMainThreadIfNeeded("getObserverCount");
return this.mObserverMap.size();
}
public Lifecycle.State getCurrentState() {
return this.mState;
}
private void forwardPass(LifecycleOwner lifecycleOwner) {
SafeIterableMap<K, V>.IteratorWithAdditions iteratorWithAdditions = this.mObserverMap.iteratorWithAdditions();
while (iteratorWithAdditions.hasNext() && !this.mNewEventOccurred) {
Map.Entry entry = (Map.Entry) iteratorWithAdditions.next();
ObserverWithState observerWithState = (ObserverWithState) entry.getValue();
while (observerWithState.mState.compareTo(this.mState) < 0 && !this.mNewEventOccurred && this.mObserverMap.contains((LifecycleObserver) entry.getKey())) {
pushParentState(observerWithState.mState);
Lifecycle.Event upFrom = Lifecycle.Event.upFrom(observerWithState.mState);
if (upFrom != null) {
observerWithState.dispatchEvent(lifecycleOwner, upFrom);
popParentState();
} else {
throw new IllegalStateException("no event up from " + observerWithState.mState);
}
}
}
}
private void backwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator = this.mObserverMap.descendingIterator();
while (descendingIterator.hasNext() && !this.mNewEventOccurred) {
Map.Entry next = descendingIterator.next();
ObserverWithState observerWithState = (ObserverWithState) next.getValue();
while (observerWithState.mState.compareTo(this.mState) > 0 && !this.mNewEventOccurred && this.mObserverMap.contains((LifecycleObserver) next.getKey())) {
Lifecycle.Event downFrom = Lifecycle.Event.downFrom(observerWithState.mState);
if (downFrom != null) {
pushParentState(downFrom.getTargetState());
observerWithState.dispatchEvent(lifecycleOwner, downFrom);
popParentState();
} else {
throw new IllegalStateException("no event down from " + observerWithState.mState);
}
}
}
}
private void sync() {
LifecycleOwner lifecycleOwner = (LifecycleOwner) this.mLifecycleOwner.get();
if (lifecycleOwner != null) {
while (!isSynced()) {
this.mNewEventOccurred = false;
if (this.mState.compareTo(this.mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
Map.Entry<LifecycleObserver, ObserverWithState> newest = this.mObserverMap.newest();
if (!this.mNewEventOccurred && newest != null && this.mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
this.mNewEventOccurred = false;
return;
}
throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is alreadygarbage collected. It is too late to change lifecycle state.");
}
private void enforceMainThreadIfNeeded(String str) {
if (this.mEnforceMainThread && !ArchTaskExecutor.getInstance().isMainThread()) {
throw new IllegalStateException("Method " + str + " must be called on the main thread");
}
}
public static LifecycleRegistry createUnsafe(LifecycleOwner lifecycleOwner) {
return new LifecycleRegistry(lifecycleOwner, false);
}
static Lifecycle.State min(Lifecycle.State state, Lifecycle.State state2) {
return (state2 == null || state2.compareTo(state) >= 0) ? state : state2;
}
static class ObserverWithState {
LifecycleEventObserver mLifecycleObserver;
Lifecycle.State mState;
ObserverWithState(LifecycleObserver lifecycleObserver, Lifecycle.State state) {
this.mLifecycleObserver = Lifecycling.lifecycleEventObserver(lifecycleObserver);
this.mState = state;
}
/* access modifiers changed from: package-private */
public void dispatchEvent(LifecycleOwner lifecycleOwner, Lifecycle.Event event) {
Lifecycle.State targetState = event.getTargetState();
this.mState = LifecycleRegistry.min(this.mState, targetState);
this.mLifecycleObserver.onStateChanged(lifecycleOwner, event);
this.mState = targetState;
}
}
}
Download file