608 lines
25 KiB
Java
608 lines
25 KiB
Java
package androidx.fragment.app;
|
|
|
|
import android.util.Log;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import androidx.annotation.CallSuper;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.core.os.CancellationSignal;
|
|
import androidx.core.view.ViewCompat;
|
|
import androidx.fragment.R;
|
|
import c.d.b.a.a;
|
|
import java.util.ArrayList;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
public abstract class SpecialEffectsController {
|
|
private final ViewGroup mContainer;
|
|
public boolean mIsContainerPostponed = false;
|
|
public boolean mOperationDirectionIsPop = false;
|
|
public final ArrayList<Operation> mPendingOperations = new ArrayList<>();
|
|
public final ArrayList<Operation> mRunningOperations = new ArrayList<>();
|
|
|
|
/* renamed from: androidx.fragment.app.SpecialEffectsController$1 reason: invalid class name */
|
|
public class AnonymousClass1 implements Runnable {
|
|
public final /* synthetic */ FragmentStateManagerOperation val$operation;
|
|
|
|
public AnonymousClass1(FragmentStateManagerOperation fragmentStateManagerOperation) {
|
|
this.val$operation = fragmentStateManagerOperation;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
if (SpecialEffectsController.this.mPendingOperations.contains(this.val$operation)) {
|
|
this.val$operation.getFinalState().applyState(this.val$operation.getFragment().mView);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.fragment.app.SpecialEffectsController$2 reason: invalid class name */
|
|
public class AnonymousClass2 implements Runnable {
|
|
public final /* synthetic */ FragmentStateManagerOperation val$operation;
|
|
|
|
public AnonymousClass2(FragmentStateManagerOperation fragmentStateManagerOperation) {
|
|
this.val$operation = fragmentStateManagerOperation;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
SpecialEffectsController.this.mPendingOperations.remove(this.val$operation);
|
|
SpecialEffectsController.this.mRunningOperations.remove(this.val$operation);
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.fragment.app.SpecialEffectsController$3 reason: invalid class name */
|
|
public static /* synthetic */ class AnonymousClass3 {
|
|
public static final /* synthetic */ int[] $SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$LifecycleImpact;
|
|
public static final /* synthetic */ int[] $SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$State;
|
|
|
|
static {
|
|
Operation.LifecycleImpact.values();
|
|
int[] iArr = new int[3];
|
|
$SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$LifecycleImpact = iArr;
|
|
try {
|
|
iArr[Operation.LifecycleImpact.ADDING.ordinal()] = 1;
|
|
} catch (NoSuchFieldError unused) {
|
|
}
|
|
try {
|
|
$SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$LifecycleImpact[Operation.LifecycleImpact.REMOVING.ordinal()] = 2;
|
|
} catch (NoSuchFieldError unused2) {
|
|
}
|
|
try {
|
|
$SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$LifecycleImpact[Operation.LifecycleImpact.NONE.ordinal()] = 3;
|
|
} catch (NoSuchFieldError unused3) {
|
|
}
|
|
Operation.State.values();
|
|
int[] iArr2 = new int[4];
|
|
$SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$State = iArr2;
|
|
try {
|
|
iArr2[Operation.State.REMOVED.ordinal()] = 1;
|
|
} catch (NoSuchFieldError unused4) {
|
|
}
|
|
try {
|
|
$SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$State[Operation.State.VISIBLE.ordinal()] = 2;
|
|
} catch (NoSuchFieldError unused5) {
|
|
}
|
|
try {
|
|
$SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$State[Operation.State.GONE.ordinal()] = 3;
|
|
} catch (NoSuchFieldError unused6) {
|
|
}
|
|
try {
|
|
$SwitchMap$androidx$fragment$app$SpecialEffectsController$Operation$State[Operation.State.INVISIBLE.ordinal()] = 4;
|
|
} catch (NoSuchFieldError unused7) {
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class FragmentStateManagerOperation extends Operation {
|
|
@NonNull
|
|
private final FragmentStateManager mFragmentStateManager;
|
|
|
|
public FragmentStateManagerOperation(@NonNull Operation.State state, @NonNull Operation.LifecycleImpact lifecycleImpact, @NonNull FragmentStateManager fragmentStateManager, @NonNull CancellationSignal cancellationSignal) {
|
|
super(state, lifecycleImpact, fragmentStateManager.getFragment(), cancellationSignal);
|
|
this.mFragmentStateManager = fragmentStateManager;
|
|
}
|
|
|
|
@Override // androidx.fragment.app.SpecialEffectsController.Operation
|
|
public void complete() {
|
|
super.complete();
|
|
this.mFragmentStateManager.moveToExpectedState();
|
|
}
|
|
|
|
@Override // androidx.fragment.app.SpecialEffectsController.Operation
|
|
public void onStart() {
|
|
Fragment fragment = this.mFragmentStateManager.getFragment();
|
|
View findFocus = fragment.mView.findFocus();
|
|
if (findFocus != null) {
|
|
fragment.setFocusedView(findFocus);
|
|
if (FragmentManager.isLoggingEnabled(2)) {
|
|
Log.v("FragmentManager", "requestFocus: Saved focused view " + findFocus + " for Fragment " + fragment);
|
|
}
|
|
}
|
|
if (getLifecycleImpact() == Operation.LifecycleImpact.ADDING) {
|
|
View requireView = getFragment().requireView();
|
|
if (requireView.getParent() == null) {
|
|
this.mFragmentStateManager.addViewToContainer();
|
|
requireView.setAlpha(0.0f);
|
|
}
|
|
if (requireView.getAlpha() == 0.0f && requireView.getVisibility() == 0) {
|
|
requireView.setVisibility(4);
|
|
}
|
|
requireView.setAlpha(fragment.getPostOnViewCreatedAlpha());
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class Operation {
|
|
@NonNull
|
|
private final List<Runnable> mCompletionListeners = new ArrayList();
|
|
@NonNull
|
|
private State mFinalState;
|
|
@NonNull
|
|
private final Fragment mFragment;
|
|
private boolean mIsCanceled = false;
|
|
private boolean mIsComplete = false;
|
|
@NonNull
|
|
private LifecycleImpact mLifecycleImpact;
|
|
@NonNull
|
|
private final HashSet<CancellationSignal> mSpecialEffectsSignals = new HashSet<>();
|
|
|
|
/* renamed from: androidx.fragment.app.SpecialEffectsController$Operation$1 reason: invalid class name */
|
|
public class AnonymousClass1 implements CancellationSignal.OnCancelListener {
|
|
public AnonymousClass1() {
|
|
}
|
|
|
|
@Override // androidx.core.os.CancellationSignal.OnCancelListener
|
|
public void onCancel() {
|
|
Operation.this.cancel();
|
|
}
|
|
}
|
|
|
|
public enum LifecycleImpact {
|
|
NONE,
|
|
ADDING,
|
|
REMOVING
|
|
}
|
|
|
|
public enum State {
|
|
REMOVED,
|
|
VISIBLE,
|
|
GONE,
|
|
INVISIBLE;
|
|
|
|
@NonNull
|
|
public static State from(int i) {
|
|
if (i == 0) {
|
|
return VISIBLE;
|
|
}
|
|
if (i == 4) {
|
|
return INVISIBLE;
|
|
}
|
|
if (i == 8) {
|
|
return GONE;
|
|
}
|
|
throw new IllegalArgumentException(a.k("Unknown visibility ", i));
|
|
}
|
|
|
|
@NonNull
|
|
public static State from(@NonNull View view) {
|
|
return (view.getAlpha() == 0.0f && view.getVisibility() == 0) ? INVISIBLE : from(view.getVisibility());
|
|
}
|
|
|
|
public void applyState(@NonNull View view) {
|
|
int ordinal = ordinal();
|
|
if (ordinal == 0) {
|
|
ViewGroup viewGroup = (ViewGroup) view.getParent();
|
|
if (viewGroup != null) {
|
|
if (FragmentManager.isLoggingEnabled(2)) {
|
|
Log.v("FragmentManager", "SpecialEffectsController: Removing view " + view + " from container " + viewGroup);
|
|
}
|
|
viewGroup.removeView(view);
|
|
}
|
|
} else if (ordinal == 1) {
|
|
if (FragmentManager.isLoggingEnabled(2)) {
|
|
Log.v("FragmentManager", "SpecialEffectsController: Setting view " + view + " to VISIBLE");
|
|
}
|
|
view.setVisibility(0);
|
|
} else if (ordinal == 2) {
|
|
if (FragmentManager.isLoggingEnabled(2)) {
|
|
Log.v("FragmentManager", "SpecialEffectsController: Setting view " + view + " to GONE");
|
|
}
|
|
view.setVisibility(8);
|
|
} else if (ordinal == 3) {
|
|
if (FragmentManager.isLoggingEnabled(2)) {
|
|
Log.v("FragmentManager", "SpecialEffectsController: Setting view " + view + " to INVISIBLE");
|
|
}
|
|
view.setVisibility(4);
|
|
}
|
|
}
|
|
}
|
|
|
|
public Operation(@NonNull State state, @NonNull LifecycleImpact lifecycleImpact, @NonNull Fragment fragment, @NonNull CancellationSignal cancellationSignal) {
|
|
this.mFinalState = state;
|
|
this.mLifecycleImpact = lifecycleImpact;
|
|
this.mFragment = fragment;
|
|
cancellationSignal.setOnCancelListener(new AnonymousClass1());
|
|
}
|
|
|
|
public final void addCompletionListener(@NonNull Runnable runnable) {
|
|
this.mCompletionListeners.add(runnable);
|
|
}
|
|
|
|
public final void cancel() {
|
|
if (!isCanceled()) {
|
|
this.mIsCanceled = true;
|
|
if (this.mSpecialEffectsSignals.isEmpty()) {
|
|
complete();
|
|
return;
|
|
}
|
|
Iterator it = new ArrayList(this.mSpecialEffectsSignals).iterator();
|
|
while (it.hasNext()) {
|
|
((CancellationSignal) it.next()).cancel();
|
|
}
|
|
}
|
|
}
|
|
|
|
@CallSuper
|
|
public void complete() {
|
|
if (!this.mIsComplete) {
|
|
if (FragmentManager.isLoggingEnabled(2)) {
|
|
Log.v("FragmentManager", "SpecialEffectsController: " + this + " has called complete.");
|
|
}
|
|
this.mIsComplete = true;
|
|
for (Runnable runnable : this.mCompletionListeners) {
|
|
runnable.run();
|
|
}
|
|
}
|
|
}
|
|
|
|
public final void completeSpecialEffect(@NonNull CancellationSignal cancellationSignal) {
|
|
if (this.mSpecialEffectsSignals.remove(cancellationSignal) && this.mSpecialEffectsSignals.isEmpty()) {
|
|
complete();
|
|
}
|
|
}
|
|
|
|
@NonNull
|
|
public State getFinalState() {
|
|
return this.mFinalState;
|
|
}
|
|
|
|
@NonNull
|
|
public final Fragment getFragment() {
|
|
return this.mFragment;
|
|
}
|
|
|
|
@NonNull
|
|
public LifecycleImpact getLifecycleImpact() {
|
|
return this.mLifecycleImpact;
|
|
}
|
|
|
|
public final boolean isCanceled() {
|
|
return this.mIsCanceled;
|
|
}
|
|
|
|
public final boolean isComplete() {
|
|
return this.mIsComplete;
|
|
}
|
|
|
|
public final void markStartedSpecialEffect(@NonNull CancellationSignal cancellationSignal) {
|
|
onStart();
|
|
this.mSpecialEffectsSignals.add(cancellationSignal);
|
|
}
|
|
|
|
public final void mergeWith(@NonNull State state, @NonNull LifecycleImpact lifecycleImpact) {
|
|
int ordinal = lifecycleImpact.ordinal();
|
|
if (ordinal != 0) {
|
|
if (ordinal != 1) {
|
|
if (ordinal == 2) {
|
|
if (FragmentManager.isLoggingEnabled(2)) {
|
|
StringBuilder L = a.L("SpecialEffectsController: For fragment ");
|
|
L.append(this.mFragment);
|
|
L.append(" mFinalState = ");
|
|
L.append(this.mFinalState);
|
|
L.append(" -> REMOVED. mLifecycleImpact = ");
|
|
L.append(this.mLifecycleImpact);
|
|
L.append(" to REMOVING.");
|
|
Log.v("FragmentManager", L.toString());
|
|
}
|
|
this.mFinalState = State.REMOVED;
|
|
this.mLifecycleImpact = LifecycleImpact.REMOVING;
|
|
}
|
|
} else if (this.mFinalState == State.REMOVED) {
|
|
if (FragmentManager.isLoggingEnabled(2)) {
|
|
StringBuilder L2 = a.L("SpecialEffectsController: For fragment ");
|
|
L2.append(this.mFragment);
|
|
L2.append(" mFinalState = REMOVED -> VISIBLE. mLifecycleImpact = ");
|
|
L2.append(this.mLifecycleImpact);
|
|
L2.append(" to ADDING.");
|
|
Log.v("FragmentManager", L2.toString());
|
|
}
|
|
this.mFinalState = State.VISIBLE;
|
|
this.mLifecycleImpact = LifecycleImpact.ADDING;
|
|
}
|
|
} else if (this.mFinalState != State.REMOVED) {
|
|
if (FragmentManager.isLoggingEnabled(2)) {
|
|
StringBuilder L3 = a.L("SpecialEffectsController: For fragment ");
|
|
L3.append(this.mFragment);
|
|
L3.append(" mFinalState = ");
|
|
L3.append(this.mFinalState);
|
|
L3.append(" -> ");
|
|
L3.append(state);
|
|
L3.append(". ");
|
|
Log.v("FragmentManager", L3.toString());
|
|
}
|
|
this.mFinalState = state;
|
|
}
|
|
}
|
|
|
|
public void onStart() {
|
|
}
|
|
|
|
@NonNull
|
|
public String toString() {
|
|
StringBuilder P = a.P("Operation ", "{");
|
|
P.append(Integer.toHexString(System.identityHashCode(this)));
|
|
P.append("} ");
|
|
P.append("{");
|
|
P.append("mFinalState = ");
|
|
P.append(this.mFinalState);
|
|
P.append("} ");
|
|
P.append("{");
|
|
P.append("mLifecycleImpact = ");
|
|
P.append(this.mLifecycleImpact);
|
|
P.append("} ");
|
|
P.append("{");
|
|
P.append("mFragment = ");
|
|
P.append(this.mFragment);
|
|
P.append("}");
|
|
return P.toString();
|
|
}
|
|
}
|
|
|
|
public SpecialEffectsController(@NonNull ViewGroup viewGroup) {
|
|
this.mContainer = viewGroup;
|
|
}
|
|
|
|
private void enqueue(@NonNull Operation.State state, @NonNull Operation.LifecycleImpact lifecycleImpact, @NonNull FragmentStateManager fragmentStateManager) {
|
|
synchronized (this.mPendingOperations) {
|
|
CancellationSignal cancellationSignal = new CancellationSignal();
|
|
Operation findPendingOperation = findPendingOperation(fragmentStateManager.getFragment());
|
|
if (findPendingOperation != null) {
|
|
findPendingOperation.mergeWith(state, lifecycleImpact);
|
|
return;
|
|
}
|
|
FragmentStateManagerOperation fragmentStateManagerOperation = new FragmentStateManagerOperation(state, lifecycleImpact, fragmentStateManager, cancellationSignal);
|
|
this.mPendingOperations.add(fragmentStateManagerOperation);
|
|
fragmentStateManagerOperation.addCompletionListener(new AnonymousClass1(fragmentStateManagerOperation));
|
|
fragmentStateManagerOperation.addCompletionListener(new AnonymousClass2(fragmentStateManagerOperation));
|
|
}
|
|
}
|
|
|
|
@Nullable
|
|
private Operation findPendingOperation(@NonNull Fragment fragment) {
|
|
Iterator<Operation> it = this.mPendingOperations.iterator();
|
|
while (it.hasNext()) {
|
|
Operation next = it.next();
|
|
if (next.getFragment().equals(fragment) && !next.isCanceled()) {
|
|
return next;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Nullable
|
|
private Operation findRunningOperation(@NonNull Fragment fragment) {
|
|
Iterator<Operation> it = this.mRunningOperations.iterator();
|
|
while (it.hasNext()) {
|
|
Operation next = it.next();
|
|
if (next.getFragment().equals(fragment) && !next.isCanceled()) {
|
|
return next;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@NonNull
|
|
public static SpecialEffectsController getOrCreateController(@NonNull ViewGroup viewGroup, @NonNull FragmentManager fragmentManager) {
|
|
return getOrCreateController(viewGroup, fragmentManager.getSpecialEffectsControllerFactory());
|
|
}
|
|
|
|
@NonNull
|
|
public static SpecialEffectsController getOrCreateController(@NonNull ViewGroup viewGroup, @NonNull SpecialEffectsControllerFactory specialEffectsControllerFactory) {
|
|
int i = R.id.special_effects_controller_view_tag;
|
|
Object tag = viewGroup.getTag(i);
|
|
if (tag instanceof SpecialEffectsController) {
|
|
return (SpecialEffectsController) tag;
|
|
}
|
|
SpecialEffectsController createController = specialEffectsControllerFactory.createController(viewGroup);
|
|
viewGroup.setTag(i, createController);
|
|
return createController;
|
|
}
|
|
|
|
private void updateFinalState() {
|
|
Iterator<Operation> it = this.mPendingOperations.iterator();
|
|
while (it.hasNext()) {
|
|
Operation next = it.next();
|
|
if (next.getLifecycleImpact() == Operation.LifecycleImpact.ADDING) {
|
|
next.mergeWith(Operation.State.from(next.getFragment().requireView().getVisibility()), Operation.LifecycleImpact.NONE);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void enqueueAdd(@NonNull Operation.State state, @NonNull FragmentStateManager fragmentStateManager) {
|
|
if (FragmentManager.isLoggingEnabled(2)) {
|
|
StringBuilder L = a.L("SpecialEffectsController: Enqueuing add operation for fragment ");
|
|
L.append(fragmentStateManager.getFragment());
|
|
Log.v("FragmentManager", L.toString());
|
|
}
|
|
enqueue(state, Operation.LifecycleImpact.ADDING, fragmentStateManager);
|
|
}
|
|
|
|
public void enqueueHide(@NonNull FragmentStateManager fragmentStateManager) {
|
|
if (FragmentManager.isLoggingEnabled(2)) {
|
|
StringBuilder L = a.L("SpecialEffectsController: Enqueuing hide operation for fragment ");
|
|
L.append(fragmentStateManager.getFragment());
|
|
Log.v("FragmentManager", L.toString());
|
|
}
|
|
enqueue(Operation.State.GONE, Operation.LifecycleImpact.NONE, fragmentStateManager);
|
|
}
|
|
|
|
public void enqueueRemove(@NonNull FragmentStateManager fragmentStateManager) {
|
|
if (FragmentManager.isLoggingEnabled(2)) {
|
|
StringBuilder L = a.L("SpecialEffectsController: Enqueuing remove operation for fragment ");
|
|
L.append(fragmentStateManager.getFragment());
|
|
Log.v("FragmentManager", L.toString());
|
|
}
|
|
enqueue(Operation.State.REMOVED, Operation.LifecycleImpact.REMOVING, fragmentStateManager);
|
|
}
|
|
|
|
public void enqueueShow(@NonNull FragmentStateManager fragmentStateManager) {
|
|
if (FragmentManager.isLoggingEnabled(2)) {
|
|
StringBuilder L = a.L("SpecialEffectsController: Enqueuing show operation for fragment ");
|
|
L.append(fragmentStateManager.getFragment());
|
|
Log.v("FragmentManager", L.toString());
|
|
}
|
|
enqueue(Operation.State.VISIBLE, Operation.LifecycleImpact.NONE, fragmentStateManager);
|
|
}
|
|
|
|
public abstract void executeOperations(@NonNull List<Operation> list, boolean z2);
|
|
|
|
public void executePendingOperations() {
|
|
if (!this.mIsContainerPostponed) {
|
|
if (!ViewCompat.isAttachedToWindow(this.mContainer)) {
|
|
forceCompleteAllOperations();
|
|
this.mOperationDirectionIsPop = false;
|
|
return;
|
|
}
|
|
synchronized (this.mPendingOperations) {
|
|
if (!this.mPendingOperations.isEmpty()) {
|
|
ArrayList arrayList = new ArrayList(this.mRunningOperations);
|
|
this.mRunningOperations.clear();
|
|
Iterator it = arrayList.iterator();
|
|
while (it.hasNext()) {
|
|
Operation operation = (Operation) it.next();
|
|
if (FragmentManager.isLoggingEnabled(2)) {
|
|
Log.v("FragmentManager", "SpecialEffectsController: Cancelling operation " + operation);
|
|
}
|
|
operation.cancel();
|
|
if (!operation.isComplete()) {
|
|
this.mRunningOperations.add(operation);
|
|
}
|
|
}
|
|
updateFinalState();
|
|
ArrayList arrayList2 = new ArrayList(this.mPendingOperations);
|
|
this.mPendingOperations.clear();
|
|
this.mRunningOperations.addAll(arrayList2);
|
|
Iterator it2 = arrayList2.iterator();
|
|
while (it2.hasNext()) {
|
|
((Operation) it2.next()).onStart();
|
|
}
|
|
executeOperations(arrayList2, this.mOperationDirectionIsPop);
|
|
this.mOperationDirectionIsPop = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void forceCompleteAllOperations() {
|
|
String str;
|
|
String str2;
|
|
boolean isAttachedToWindow = ViewCompat.isAttachedToWindow(this.mContainer);
|
|
synchronized (this.mPendingOperations) {
|
|
updateFinalState();
|
|
Iterator<Operation> it = this.mPendingOperations.iterator();
|
|
while (it.hasNext()) {
|
|
it.next().onStart();
|
|
}
|
|
Iterator it2 = new ArrayList(this.mRunningOperations).iterator();
|
|
while (it2.hasNext()) {
|
|
Operation operation = (Operation) it2.next();
|
|
if (FragmentManager.isLoggingEnabled(2)) {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("SpecialEffectsController: ");
|
|
if (isAttachedToWindow) {
|
|
str2 = "";
|
|
} else {
|
|
str2 = "Container " + this.mContainer + " is not attached to window. ";
|
|
}
|
|
sb.append(str2);
|
|
sb.append("Cancelling running operation ");
|
|
sb.append(operation);
|
|
Log.v("FragmentManager", sb.toString());
|
|
}
|
|
operation.cancel();
|
|
}
|
|
Iterator it3 = new ArrayList(this.mPendingOperations).iterator();
|
|
while (it3.hasNext()) {
|
|
Operation operation2 = (Operation) it3.next();
|
|
if (FragmentManager.isLoggingEnabled(2)) {
|
|
StringBuilder sb2 = new StringBuilder();
|
|
sb2.append("SpecialEffectsController: ");
|
|
if (isAttachedToWindow) {
|
|
str = "";
|
|
} else {
|
|
str = "Container " + this.mContainer + " is not attached to window. ";
|
|
}
|
|
sb2.append(str);
|
|
sb2.append("Cancelling pending operation ");
|
|
sb2.append(operation2);
|
|
Log.v("FragmentManager", sb2.toString());
|
|
}
|
|
operation2.cancel();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void forcePostponedExecutePendingOperations() {
|
|
if (this.mIsContainerPostponed) {
|
|
this.mIsContainerPostponed = false;
|
|
executePendingOperations();
|
|
}
|
|
}
|
|
|
|
@Nullable
|
|
public Operation.LifecycleImpact getAwaitingCompletionLifecycleImpact(@NonNull FragmentStateManager fragmentStateManager) {
|
|
Operation findPendingOperation = findPendingOperation(fragmentStateManager.getFragment());
|
|
if (findPendingOperation != null) {
|
|
return findPendingOperation.getLifecycleImpact();
|
|
}
|
|
Operation findRunningOperation = findRunningOperation(fragmentStateManager.getFragment());
|
|
if (findRunningOperation != null) {
|
|
return findRunningOperation.getLifecycleImpact();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@NonNull
|
|
public ViewGroup getContainer() {
|
|
return this.mContainer;
|
|
}
|
|
|
|
public void markPostponedState() {
|
|
synchronized (this.mPendingOperations) {
|
|
updateFinalState();
|
|
this.mIsContainerPostponed = false;
|
|
int size = this.mPendingOperations.size() - 1;
|
|
while (true) {
|
|
if (size < 0) {
|
|
break;
|
|
}
|
|
Operation operation = this.mPendingOperations.get(size);
|
|
Operation.State from = Operation.State.from(operation.getFragment().mView);
|
|
Operation.State finalState = operation.getFinalState();
|
|
Operation.State state = Operation.State.VISIBLE;
|
|
if (finalState == state && from != state) {
|
|
this.mIsContainerPostponed = operation.getFragment().isPostponed();
|
|
break;
|
|
}
|
|
size--;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void updateOperationDirection(boolean z2) {
|
|
this.mOperationDirectionIsPop = z2;
|
|
}
|
|
}
|