CrackMe.apk
Download file
package androidx.transition;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.TimeInterpolator;
import android.content.Context;
import android.content.res.TypedArray;
import android.content.res.XmlResourceParser;
import android.graphics.Path;
import android.graphics.Rect;
import android.util.AttributeSet;
import android.util.SparseArray;
import android.util.SparseIntArray;
import android.view.InflateException;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.AnimationUtils;
import android.widget.ListView;
import androidx.collection.ArrayMap;
import androidx.collection.LongSparseArray;
import androidx.collection.SimpleArrayMap;
import androidx.core.content.res.TypedArrayUtils;
import androidx.core.view.ViewCompat;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;
public abstract class Transition implements Cloneable {
static final boolean DBG = false;
private static final int[] DEFAULT_MATCH_ORDER = {2, 1, 3, 4};
private static final String LOG_TAG = "Transition";
private static final int MATCH_FIRST = 1;
public static final int MATCH_ID = 3;
private static final String MATCH_ID_STR = "id";
public static final int MATCH_INSTANCE = 1;
private static final String MATCH_INSTANCE_STR = "instance";
public static final int MATCH_ITEM_ID = 4;
private static final String MATCH_ITEM_ID_STR = "itemId";
private static final int MATCH_LAST = 4;
public static final int MATCH_NAME = 2;
private static final String MATCH_NAME_STR = "name";
private static final PathMotion STRAIGHT_PATH_MOTION = new PathMotion() {
public Path getPath(float f, float f2, float f3, float f4) {
Path path = new Path();
path.moveTo(f, f2);
path.lineTo(f3, f4);
return path;
}
};
private static ThreadLocal<ArrayMap<Animator, AnimationInfo>> sRunningAnimators = new ThreadLocal<>();
private ArrayList<Animator> mAnimators = new ArrayList<>();
boolean mCanRemoveViews = false;
ArrayList<Animator> mCurrentAnimators = new ArrayList<>();
long mDuration = -1;
private TransitionValuesMaps mEndValues = new TransitionValuesMaps();
private ArrayList<TransitionValues> mEndValuesList;
private boolean mEnded = false;
private EpicenterCallback mEpicenterCallback;
private TimeInterpolator mInterpolator = null;
private ArrayList<TransitionListener> mListeners = null;
private int[] mMatchOrder = DEFAULT_MATCH_ORDER;
private String mName = getClass().getName();
private ArrayMap<String, String> mNameOverrides;
private int mNumInstances = 0;
TransitionSet mParent = null;
private PathMotion mPathMotion = STRAIGHT_PATH_MOTION;
private boolean mPaused = false;
TransitionPropagation mPropagation;
private ViewGroup mSceneRoot = null;
private long mStartDelay = -1;
private TransitionValuesMaps mStartValues = new TransitionValuesMaps();
private ArrayList<TransitionValues> mStartValuesList;
private ArrayList<View> mTargetChildExcludes = null;
private ArrayList<View> mTargetExcludes = null;
private ArrayList<Integer> mTargetIdChildExcludes = null;
private ArrayList<Integer> mTargetIdExcludes = null;
ArrayList<Integer> mTargetIds = new ArrayList<>();
private ArrayList<String> mTargetNameExcludes = null;
private ArrayList<String> mTargetNames = null;
private ArrayList<Class<?>> mTargetTypeChildExcludes = null;
private ArrayList<Class<?>> mTargetTypeExcludes = null;
private ArrayList<Class<?>> mTargetTypes = null;
ArrayList<View> mTargets = new ArrayList<>();
public static abstract class EpicenterCallback {
public abstract Rect onGetEpicenter(Transition transition);
}
@Retention(RetentionPolicy.SOURCE)
public @interface MatchOrder {
}
public interface TransitionListener {
void onTransitionCancel(Transition transition);
void onTransitionEnd(Transition transition);
void onTransitionPause(Transition transition);
void onTransitionResume(Transition transition);
void onTransitionStart(Transition transition);
}
private static boolean isValidMatch(int i) {
return i >= 1 && i <= 4;
}
public abstract void captureEndValues(TransitionValues transitionValues);
public abstract void captureStartValues(TransitionValues transitionValues);
public Animator createAnimator(ViewGroup viewGroup, TransitionValues transitionValues, TransitionValues transitionValues2) {
return null;
}
public String[] getTransitionProperties() {
return null;
}
public Transition() {
}
public Transition(Context context, AttributeSet attributeSet) {
TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, Styleable.TRANSITION);
XmlResourceParser xmlResourceParser = (XmlResourceParser) attributeSet;
long namedInt = (long) TypedArrayUtils.getNamedInt(obtainStyledAttributes, xmlResourceParser, "duration", 1, -1);
if (namedInt >= 0) {
setDuration(namedInt);
}
long namedInt2 = (long) TypedArrayUtils.getNamedInt(obtainStyledAttributes, xmlResourceParser, "startDelay", 2, -1);
if (namedInt2 > 0) {
setStartDelay(namedInt2);
}
int namedResourceId = TypedArrayUtils.getNamedResourceId(obtainStyledAttributes, xmlResourceParser, "interpolator", 0, 0);
if (namedResourceId > 0) {
setInterpolator(AnimationUtils.loadInterpolator(context, namedResourceId));
}
String namedString = TypedArrayUtils.getNamedString(obtainStyledAttributes, xmlResourceParser, "matchOrder", 3);
if (namedString != null) {
setMatchOrder(parseMatchOrder(namedString));
}
obtainStyledAttributes.recycle();
}
private static int[] parseMatchOrder(String str) {
StringTokenizer stringTokenizer = new StringTokenizer(str, ",");
int[] iArr = new int[stringTokenizer.countTokens()];
int i = 0;
while (stringTokenizer.hasMoreTokens()) {
String trim = stringTokenizer.nextToken().trim();
if ("id".equalsIgnoreCase(trim)) {
iArr[i] = 3;
} else if (MATCH_INSTANCE_STR.equalsIgnoreCase(trim)) {
iArr[i] = 1;
} else if ("name".equalsIgnoreCase(trim)) {
iArr[i] = 2;
} else if (MATCH_ITEM_ID_STR.equalsIgnoreCase(trim)) {
iArr[i] = 4;
} else if (trim.isEmpty()) {
int[] iArr2 = new int[(iArr.length - 1)];
System.arraycopy(iArr, 0, iArr2, 0, i);
i--;
iArr = iArr2;
} else {
throw new InflateException("Unknown match type in matchOrder: '" + trim + "'");
}
i++;
}
return iArr;
}
public Transition setDuration(long j) {
this.mDuration = j;
return this;
}
public long getDuration() {
return this.mDuration;
}
public Transition setStartDelay(long j) {
this.mStartDelay = j;
return this;
}
public long getStartDelay() {
return this.mStartDelay;
}
public Transition setInterpolator(TimeInterpolator timeInterpolator) {
this.mInterpolator = timeInterpolator;
return this;
}
public TimeInterpolator getInterpolator() {
return this.mInterpolator;
}
public void setMatchOrder(int... iArr) {
if (iArr == null || iArr.length == 0) {
this.mMatchOrder = DEFAULT_MATCH_ORDER;
return;
}
int i = 0;
while (i < iArr.length) {
if (!isValidMatch(iArr[i])) {
throw new IllegalArgumentException("matches contains invalid value");
} else if (!alreadyContains(iArr, i)) {
i++;
} else {
throw new IllegalArgumentException("matches contains a duplicate value");
}
}
this.mMatchOrder = (int[]) iArr.clone();
}
private static boolean alreadyContains(int[] iArr, int i) {
int i2 = iArr[i];
for (int i3 = 0; i3 < i; i3++) {
if (iArr[i3] == i2) {
return true;
}
}
return false;
}
private void matchInstances(ArrayMap<View, TransitionValues> arrayMap, ArrayMap<View, TransitionValues> arrayMap2) {
TransitionValues remove;
for (int size = arrayMap.size() - 1; size >= 0; size--) {
View keyAt = arrayMap.keyAt(size);
if (keyAt != null && isValidTarget(keyAt) && (remove = arrayMap2.remove(keyAt)) != null && isValidTarget(remove.view)) {
this.mStartValuesList.add(arrayMap.removeAt(size));
this.mEndValuesList.add(remove);
}
}
}
private void matchItemIds(ArrayMap<View, TransitionValues> arrayMap, ArrayMap<View, TransitionValues> arrayMap2, LongSparseArray<View> longSparseArray, LongSparseArray<View> longSparseArray2) {
View view;
int size = longSparseArray.size();
for (int i = 0; i < size; i++) {
View valueAt = longSparseArray.valueAt(i);
if (valueAt != null && isValidTarget(valueAt) && (view = longSparseArray2.get(longSparseArray.keyAt(i))) != null && isValidTarget(view)) {
TransitionValues transitionValues = arrayMap.get(valueAt);
TransitionValues transitionValues2 = arrayMap2.get(view);
if (!(transitionValues == null || transitionValues2 == null)) {
this.mStartValuesList.add(transitionValues);
this.mEndValuesList.add(transitionValues2);
arrayMap.remove(valueAt);
arrayMap2.remove(view);
}
}
}
}
private void matchIds(ArrayMap<View, TransitionValues> arrayMap, ArrayMap<View, TransitionValues> arrayMap2, SparseArray<View> sparseArray, SparseArray<View> sparseArray2) {
View view;
int size = sparseArray.size();
for (int i = 0; i < size; i++) {
View valueAt = sparseArray.valueAt(i);
if (valueAt != null && isValidTarget(valueAt) && (view = sparseArray2.get(sparseArray.keyAt(i))) != null && isValidTarget(view)) {
TransitionValues transitionValues = arrayMap.get(valueAt);
TransitionValues transitionValues2 = arrayMap2.get(view);
if (!(transitionValues == null || transitionValues2 == null)) {
this.mStartValuesList.add(transitionValues);
this.mEndValuesList.add(transitionValues2);
arrayMap.remove(valueAt);
arrayMap2.remove(view);
}
}
}
}
private void matchNames(ArrayMap<View, TransitionValues> arrayMap, ArrayMap<View, TransitionValues> arrayMap2, ArrayMap<String, View> arrayMap3, ArrayMap<String, View> arrayMap4) {
View view;
int size = arrayMap3.size();
for (int i = 0; i < size; i++) {
View valueAt = arrayMap3.valueAt(i);
if (valueAt != null && isValidTarget(valueAt) && (view = arrayMap4.get(arrayMap3.keyAt(i))) != null && isValidTarget(view)) {
TransitionValues transitionValues = arrayMap.get(valueAt);
TransitionValues transitionValues2 = arrayMap2.get(view);
if (!(transitionValues == null || transitionValues2 == null)) {
this.mStartValuesList.add(transitionValues);
this.mEndValuesList.add(transitionValues2);
arrayMap.remove(valueAt);
arrayMap2.remove(view);
}
}
}
}
private void addUnmatched(ArrayMap<View, TransitionValues> arrayMap, ArrayMap<View, TransitionValues> arrayMap2) {
for (int i = 0; i < arrayMap.size(); i++) {
TransitionValues valueAt = arrayMap.valueAt(i);
if (isValidTarget(valueAt.view)) {
this.mStartValuesList.add(valueAt);
this.mEndValuesList.add((Object) null);
}
}
for (int i2 = 0; i2 < arrayMap2.size(); i2++) {
TransitionValues valueAt2 = arrayMap2.valueAt(i2);
if (isValidTarget(valueAt2.view)) {
this.mEndValuesList.add(valueAt2);
this.mStartValuesList.add((Object) null);
}
}
}
private void matchStartAndEnd(TransitionValuesMaps transitionValuesMaps, TransitionValuesMaps transitionValuesMaps2) {
ArrayMap arrayMap = new ArrayMap((SimpleArrayMap) transitionValuesMaps.mViewValues);
ArrayMap arrayMap2 = new ArrayMap((SimpleArrayMap) transitionValuesMaps2.mViewValues);
int i = 0;
while (true) {
int[] iArr = this.mMatchOrder;
if (i < iArr.length) {
int i2 = iArr[i];
if (i2 == 1) {
matchInstances(arrayMap, arrayMap2);
} else if (i2 == 2) {
matchNames(arrayMap, arrayMap2, transitionValuesMaps.mNameValues, transitionValuesMaps2.mNameValues);
} else if (i2 == 3) {
matchIds(arrayMap, arrayMap2, transitionValuesMaps.mIdValues, transitionValuesMaps2.mIdValues);
} else if (i2 == 4) {
matchItemIds(arrayMap, arrayMap2, transitionValuesMaps.mItemIdValues, transitionValuesMaps2.mItemIdValues);
}
i++;
} else {
addUnmatched(arrayMap, arrayMap2);
return;
}
}
}
/* access modifiers changed from: protected */
public void createAnimators(ViewGroup viewGroup, TransitionValuesMaps transitionValuesMaps, TransitionValuesMaps transitionValuesMaps2, ArrayList<TransitionValues> arrayList, ArrayList<TransitionValues> arrayList2) {
int i;
int i2;
Animator createAnimator;
View view;
Animator animator;
TransitionValues transitionValues;
TransitionValues transitionValues2;
Animator animator2;
ViewGroup viewGroup2 = viewGroup;
ArrayMap<Animator, AnimationInfo> runningAnimators = getRunningAnimators();
SparseIntArray sparseIntArray = new SparseIntArray();
int size = arrayList.size();
long j = Long.MAX_VALUE;
int i3 = 0;
while (i3 < size) {
TransitionValues transitionValues3 = arrayList.get(i3);
TransitionValues transitionValues4 = arrayList2.get(i3);
if (transitionValues3 != null && !transitionValues3.mTargetedTransitions.contains(this)) {
transitionValues3 = null;
}
if (transitionValues4 != null && !transitionValues4.mTargetedTransitions.contains(this)) {
transitionValues4 = null;
}
if (!(transitionValues3 == null && transitionValues4 == null)) {
if ((transitionValues3 == null || transitionValues4 == null || isTransitionRequired(transitionValues3, transitionValues4)) && (createAnimator = createAnimator(viewGroup2, transitionValues3, transitionValues4)) != null) {
if (transitionValues4 != null) {
view = transitionValues4.view;
String[] transitionProperties = getTransitionProperties();
if (transitionProperties != null && transitionProperties.length > 0) {
transitionValues2 = new TransitionValues(view);
Animator animator3 = createAnimator;
i2 = size;
TransitionValues transitionValues5 = transitionValuesMaps2.mViewValues.get(view);
if (transitionValues5 != null) {
int i4 = 0;
while (i4 < transitionProperties.length) {
transitionValues2.values.put(transitionProperties[i4], transitionValues5.values.get(transitionProperties[i4]));
i4++;
ArrayList<TransitionValues> arrayList3 = arrayList2;
i3 = i3;
transitionValues5 = transitionValues5;
}
}
i = i3;
int size2 = runningAnimators.size();
int i5 = 0;
while (true) {
if (i5 >= size2) {
animator2 = animator3;
break;
}
AnimationInfo animationInfo = runningAnimators.get(runningAnimators.keyAt(i5));
if (animationInfo.mValues != null && animationInfo.mView == view && animationInfo.mName.equals(getName()) && animationInfo.mValues.equals(transitionValues2)) {
animator2 = null;
break;
}
i5++;
}
} else {
i2 = size;
i = i3;
animator2 = createAnimator;
transitionValues2 = null;
}
animator = animator2;
transitionValues = transitionValues2;
} else {
i2 = size;
i = i3;
view = transitionValues3.view;
animator = createAnimator;
transitionValues = null;
}
if (animator != null) {
TransitionPropagation transitionPropagation = this.mPropagation;
if (transitionPropagation != null) {
long startDelay = transitionPropagation.getStartDelay(viewGroup2, this, transitionValues3, transitionValues4);
sparseIntArray.put(this.mAnimators.size(), (int) startDelay);
j = Math.min(startDelay, j);
}
runningAnimators.put(animator, new AnimationInfo(view, getName(), this, ViewUtils.getWindowId(viewGroup), transitionValues));
this.mAnimators.add(animator);
j = j;
}
i3 = i + 1;
size = i2;
}
}
i2 = size;
i = i3;
i3 = i + 1;
size = i2;
}
if (sparseIntArray.size() != 0) {
for (int i6 = 0; i6 < sparseIntArray.size(); i6++) {
Animator animator4 = this.mAnimators.get(sparseIntArray.keyAt(i6));
animator4.setStartDelay((((long) sparseIntArray.valueAt(i6)) - j) + animator4.getStartDelay());
}
}
}
/* access modifiers changed from: package-private */
public boolean isValidTarget(View view) {
ArrayList<Class<?>> arrayList;
ArrayList<String> arrayList2;
int id = view.getId();
ArrayList<Integer> arrayList3 = this.mTargetIdExcludes;
if (arrayList3 != null && arrayList3.contains(Integer.valueOf(id))) {
return false;
}
ArrayList<View> arrayList4 = this.mTargetExcludes;
if (arrayList4 != null && arrayList4.contains(view)) {
return false;
}
ArrayList<Class<?>> arrayList5 = this.mTargetTypeExcludes;
if (arrayList5 != null) {
int size = arrayList5.size();
for (int i = 0; i < size; i++) {
if (this.mTargetTypeExcludes.get(i).isInstance(view)) {
return false;
}
}
}
if (this.mTargetNameExcludes != null && ViewCompat.getTransitionName(view) != null && this.mTargetNameExcludes.contains(ViewCompat.getTransitionName(view))) {
return false;
}
if ((this.mTargetIds.size() == 0 && this.mTargets.size() == 0 && (((arrayList = this.mTargetTypes) == null || arrayList.isEmpty()) && ((arrayList2 = this.mTargetNames) == null || arrayList2.isEmpty()))) || this.mTargetIds.contains(Integer.valueOf(id)) || this.mTargets.contains(view)) {
return true;
}
ArrayList<String> arrayList6 = this.mTargetNames;
if (arrayList6 != null && arrayList6.contains(ViewCompat.getTransitionName(view))) {
return true;
}
if (this.mTargetTypes != null) {
for (int i2 = 0; i2 < this.mTargetTypes.size(); i2++) {
if (this.mTargetTypes.get(i2).isInstance(view)) {
return true;
}
}
}
return false;
}
private static ArrayMap<Animator, AnimationInfo> getRunningAnimators() {
ArrayMap<Animator, AnimationInfo> arrayMap = sRunningAnimators.get();
if (arrayMap != null) {
return arrayMap;
}
ArrayMap<Animator, AnimationInfo> arrayMap2 = new ArrayMap<>();
sRunningAnimators.set(arrayMap2);
return arrayMap2;
}
/* access modifiers changed from: protected */
public void runAnimators() {
start();
ArrayMap<Animator, AnimationInfo> runningAnimators = getRunningAnimators();
Iterator<Animator> it = this.mAnimators.iterator();
while (it.hasNext()) {
Animator next = it.next();
if (runningAnimators.containsKey(next)) {
start();
runAnimator(next, runningAnimators);
}
}
this.mAnimators.clear();
end();
}
private void runAnimator(Animator animator, final ArrayMap<Animator, AnimationInfo> arrayMap) {
if (animator != null) {
animator.addListener(new AnimatorListenerAdapter() {
public void onAnimationStart(Animator animator) {
Transition.this.mCurrentAnimators.add(animator);
}
public void onAnimationEnd(Animator animator) {
arrayMap.remove(animator);
Transition.this.mCurrentAnimators.remove(animator);
}
});
animate(animator);
}
}
public Transition addTarget(View view) {
this.mTargets.add(view);
return this;
}
public Transition addTarget(int i) {
if (i != 0) {
this.mTargetIds.add(Integer.valueOf(i));
}
return this;
}
public Transition addTarget(String str) {
if (this.mTargetNames == null) {
this.mTargetNames = new ArrayList<>();
}
this.mTargetNames.add(str);
return this;
}
public Transition addTarget(Class<?> cls) {
if (this.mTargetTypes == null) {
this.mTargetTypes = new ArrayList<>();
}
this.mTargetTypes.add(cls);
return this;
}
public Transition removeTarget(View view) {
this.mTargets.remove(view);
return this;
}
public Transition removeTarget(int i) {
if (i != 0) {
this.mTargetIds.remove(Integer.valueOf(i));
}
return this;
}
public Transition removeTarget(String str) {
ArrayList<String> arrayList = this.mTargetNames;
if (arrayList != null) {
arrayList.remove(str);
}
return this;
}
public Transition removeTarget(Class<?> cls) {
ArrayList<Class<?>> arrayList = this.mTargetTypes;
if (arrayList != null) {
arrayList.remove(cls);
}
return this;
}
private static <T> ArrayList<T> excludeObject(ArrayList<T> arrayList, T t, boolean z) {
if (t == null) {
return arrayList;
}
if (z) {
return ArrayListManager.add(arrayList, t);
}
return ArrayListManager.remove(arrayList, t);
}
public Transition excludeTarget(View view, boolean z) {
this.mTargetExcludes = excludeView(this.mTargetExcludes, view, z);
return this;
}
public Transition excludeTarget(int i, boolean z) {
this.mTargetIdExcludes = excludeId(this.mTargetIdExcludes, i, z);
return this;
}
public Transition excludeTarget(String str, boolean z) {
this.mTargetNameExcludes = excludeObject(this.mTargetNameExcludes, str, z);
return this;
}
public Transition excludeChildren(View view, boolean z) {
this.mTargetChildExcludes = excludeView(this.mTargetChildExcludes, view, z);
return this;
}
public Transition excludeChildren(int i, boolean z) {
this.mTargetIdChildExcludes = excludeId(this.mTargetIdChildExcludes, i, z);
return this;
}
private ArrayList<Integer> excludeId(ArrayList<Integer> arrayList, int i, boolean z) {
if (i <= 0) {
return arrayList;
}
if (z) {
return ArrayListManager.add(arrayList, Integer.valueOf(i));
}
return ArrayListManager.remove(arrayList, Integer.valueOf(i));
}
private ArrayList<View> excludeView(ArrayList<View> arrayList, View view, boolean z) {
if (view == null) {
return arrayList;
}
if (z) {
return ArrayListManager.add(arrayList, view);
}
return ArrayListManager.remove(arrayList, view);
}
public Transition excludeTarget(Class<?> cls, boolean z) {
this.mTargetTypeExcludes = excludeType(this.mTargetTypeExcludes, cls, z);
return this;
}
public Transition excludeChildren(Class<?> cls, boolean z) {
this.mTargetTypeChildExcludes = excludeType(this.mTargetTypeChildExcludes, cls, z);
return this;
}
private ArrayList<Class<?>> excludeType(ArrayList<Class<?>> arrayList, Class<?> cls, boolean z) {
if (cls == null) {
return arrayList;
}
if (z) {
return ArrayListManager.add(arrayList, cls);
}
return ArrayListManager.remove(arrayList, cls);
}
public List<Integer> getTargetIds() {
return this.mTargetIds;
}
public List<View> getTargets() {
return this.mTargets;
}
public List<String> getTargetNames() {
return this.mTargetNames;
}
public List<Class<?>> getTargetTypes() {
return this.mTargetTypes;
}
/* access modifiers changed from: package-private */
public void captureValues(ViewGroup viewGroup, boolean z) {
ArrayMap<String, String> arrayMap;
ArrayList<String> arrayList;
ArrayList<Class<?>> arrayList2;
clearValues(z);
if ((this.mTargetIds.size() > 0 || this.mTargets.size() > 0) && (((arrayList = this.mTargetNames) == null || arrayList.isEmpty()) && ((arrayList2 = this.mTargetTypes) == null || arrayList2.isEmpty()))) {
for (int i = 0; i < this.mTargetIds.size(); i++) {
View findViewById = viewGroup.findViewById(this.mTargetIds.get(i).intValue());
if (findViewById != null) {
TransitionValues transitionValues = new TransitionValues(findViewById);
if (z) {
captureStartValues(transitionValues);
} else {
captureEndValues(transitionValues);
}
transitionValues.mTargetedTransitions.add(this);
capturePropagationValues(transitionValues);
if (z) {
addViewValues(this.mStartValues, findViewById, transitionValues);
} else {
addViewValues(this.mEndValues, findViewById, transitionValues);
}
}
}
for (int i2 = 0; i2 < this.mTargets.size(); i2++) {
View view = this.mTargets.get(i2);
TransitionValues transitionValues2 = new TransitionValues(view);
if (z) {
captureStartValues(transitionValues2);
} else {
captureEndValues(transitionValues2);
}
transitionValues2.mTargetedTransitions.add(this);
capturePropagationValues(transitionValues2);
if (z) {
addViewValues(this.mStartValues, view, transitionValues2);
} else {
addViewValues(this.mEndValues, view, transitionValues2);
}
}
} else {
captureHierarchy(viewGroup, z);
}
if (!z && (arrayMap = this.mNameOverrides) != null) {
int size = arrayMap.size();
ArrayList arrayList3 = new ArrayList(size);
for (int i3 = 0; i3 < size; i3++) {
arrayList3.add(this.mStartValues.mNameValues.remove(this.mNameOverrides.keyAt(i3)));
}
for (int i4 = 0; i4 < size; i4++) {
View view2 = (View) arrayList3.get(i4);
if (view2 != null) {
this.mStartValues.mNameValues.put(this.mNameOverrides.valueAt(i4), view2);
}
}
}
}
private static void addViewValues(TransitionValuesMaps transitionValuesMaps, View view, TransitionValues transitionValues) {
transitionValuesMaps.mViewValues.put(view, transitionValues);
int id = view.getId();
if (id >= 0) {
if (transitionValuesMaps.mIdValues.indexOfKey(id) >= 0) {
transitionValuesMaps.mIdValues.put(id, (Object) null);
} else {
transitionValuesMaps.mIdValues.put(id, view);
}
}
String transitionName = ViewCompat.getTransitionName(view);
if (transitionName != null) {
if (transitionValuesMaps.mNameValues.containsKey(transitionName)) {
transitionValuesMaps.mNameValues.put(transitionName, null);
} else {
transitionValuesMaps.mNameValues.put(transitionName, view);
}
}
if (view.getParent() instanceof ListView) {
ListView listView = (ListView) view.getParent();
if (listView.getAdapter().hasStableIds()) {
long itemIdAtPosition = listView.getItemIdAtPosition(listView.getPositionForView(view));
if (transitionValuesMaps.mItemIdValues.indexOfKey(itemIdAtPosition) >= 0) {
View view2 = transitionValuesMaps.mItemIdValues.get(itemIdAtPosition);
if (view2 != null) {
ViewCompat.setHasTransientState(view2, false);
transitionValuesMaps.mItemIdValues.put(itemIdAtPosition, null);
return;
}
return;
}
ViewCompat.setHasTransientState(view, true);
transitionValuesMaps.mItemIdValues.put(itemIdAtPosition, view);
}
}
}
/* access modifiers changed from: package-private */
public void clearValues(boolean z) {
if (z) {
this.mStartValues.mViewValues.clear();
this.mStartValues.mIdValues.clear();
this.mStartValues.mItemIdValues.clear();
return;
}
this.mEndValues.mViewValues.clear();
this.mEndValues.mIdValues.clear();
this.mEndValues.mItemIdValues.clear();
}
private void captureHierarchy(View view, boolean z) {
if (view != null) {
int id = view.getId();
ArrayList<Integer> arrayList = this.mTargetIdExcludes;
if (arrayList == null || !arrayList.contains(Integer.valueOf(id))) {
ArrayList<View> arrayList2 = this.mTargetExcludes;
if (arrayList2 == null || !arrayList2.contains(view)) {
ArrayList<Class<?>> arrayList3 = this.mTargetTypeExcludes;
if (arrayList3 != null) {
int size = arrayList3.size();
int i = 0;
while (i < size) {
if (!this.mTargetTypeExcludes.get(i).isInstance(view)) {
i++;
} else {
return;
}
}
}
if (view.getParent() instanceof ViewGroup) {
TransitionValues transitionValues = new TransitionValues(view);
if (z) {
captureStartValues(transitionValues);
} else {
captureEndValues(transitionValues);
}
transitionValues.mTargetedTransitions.add(this);
capturePropagationValues(transitionValues);
if (z) {
addViewValues(this.mStartValues, view, transitionValues);
} else {
addViewValues(this.mEndValues, view, transitionValues);
}
}
if (view instanceof ViewGroup) {
ArrayList<Integer> arrayList4 = this.mTargetIdChildExcludes;
if (arrayList4 == null || !arrayList4.contains(Integer.valueOf(id))) {
ArrayList<View> arrayList5 = this.mTargetChildExcludes;
if (arrayList5 == null || !arrayList5.contains(view)) {
ArrayList<Class<?>> arrayList6 = this.mTargetTypeChildExcludes;
if (arrayList6 != null) {
int size2 = arrayList6.size();
int i2 = 0;
while (i2 < size2) {
if (!this.mTargetTypeChildExcludes.get(i2).isInstance(view)) {
i2++;
} else {
return;
}
}
}
ViewGroup viewGroup = (ViewGroup) view;
for (int i3 = 0; i3 < viewGroup.getChildCount(); i3++) {
captureHierarchy(viewGroup.getChildAt(i3), z);
}
}
}
}
}
}
}
}
public TransitionValues getTransitionValues(View view, boolean z) {
TransitionSet transitionSet = this.mParent;
if (transitionSet != null) {
return transitionSet.getTransitionValues(view, z);
}
return (z ? this.mStartValues : this.mEndValues).mViewValues.get(view);
}
/* access modifiers changed from: package-private */
public TransitionValues getMatchedTransitionValues(View view, boolean z) {
TransitionSet transitionSet = this.mParent;
if (transitionSet != null) {
return transitionSet.getMatchedTransitionValues(view, z);
}
ArrayList<TransitionValues> arrayList = z ? this.mStartValuesList : this.mEndValuesList;
if (arrayList == null) {
return null;
}
int size = arrayList.size();
int i = -1;
int i2 = 0;
while (true) {
if (i2 >= size) {
break;
}
TransitionValues transitionValues = arrayList.get(i2);
if (transitionValues == null) {
return null;
}
if (transitionValues.view == view) {
i = i2;
break;
}
i2++;
}
if (i < 0) {
return null;
}
return (z ? this.mEndValuesList : this.mStartValuesList).get(i);
}
public void pause(View view) {
if (!this.mEnded) {
ArrayMap<Animator, AnimationInfo> runningAnimators = getRunningAnimators();
int size = runningAnimators.size();
WindowIdImpl windowId = ViewUtils.getWindowId(view);
for (int i = size - 1; i >= 0; i--) {
AnimationInfo valueAt = runningAnimators.valueAt(i);
if (valueAt.mView != null && windowId.equals(valueAt.mWindowId)) {
AnimatorUtils.pause(runningAnimators.keyAt(i));
}
}
ArrayList<TransitionListener> arrayList = this.mListeners;
if (arrayList != null && arrayList.size() > 0) {
ArrayList arrayList2 = (ArrayList) this.mListeners.clone();
int size2 = arrayList2.size();
for (int i2 = 0; i2 < size2; i2++) {
((TransitionListener) arrayList2.get(i2)).onTransitionPause(this);
}
}
this.mPaused = true;
}
}
public void resume(View view) {
if (this.mPaused) {
if (!this.mEnded) {
ArrayMap<Animator, AnimationInfo> runningAnimators = getRunningAnimators();
int size = runningAnimators.size();
WindowIdImpl windowId = ViewUtils.getWindowId(view);
for (int i = size - 1; i >= 0; i--) {
AnimationInfo valueAt = runningAnimators.valueAt(i);
if (valueAt.mView != null && windowId.equals(valueAt.mWindowId)) {
AnimatorUtils.resume(runningAnimators.keyAt(i));
}
}
ArrayList<TransitionListener> arrayList = this.mListeners;
if (arrayList != null && arrayList.size() > 0) {
ArrayList arrayList2 = (ArrayList) this.mListeners.clone();
int size2 = arrayList2.size();
for (int i2 = 0; i2 < size2; i2++) {
((TransitionListener) arrayList2.get(i2)).onTransitionResume(this);
}
}
}
this.mPaused = false;
}
}
/* access modifiers changed from: package-private */
public void playTransition(ViewGroup viewGroup) {
AnimationInfo animationInfo;
this.mStartValuesList = new ArrayList<>();
this.mEndValuesList = new ArrayList<>();
matchStartAndEnd(this.mStartValues, this.mEndValues);
ArrayMap<Animator, AnimationInfo> runningAnimators = getRunningAnimators();
int size = runningAnimators.size();
WindowIdImpl windowId = ViewUtils.getWindowId(viewGroup);
for (int i = size - 1; i >= 0; i--) {
Animator keyAt = runningAnimators.keyAt(i);
if (!(keyAt == null || (animationInfo = runningAnimators.get(keyAt)) == null || animationInfo.mView == null || !windowId.equals(animationInfo.mWindowId))) {
TransitionValues transitionValues = animationInfo.mValues;
View view = animationInfo.mView;
TransitionValues transitionValues2 = getTransitionValues(view, true);
TransitionValues matchedTransitionValues = getMatchedTransitionValues(view, true);
if (transitionValues2 == null && matchedTransitionValues == null) {
matchedTransitionValues = this.mEndValues.mViewValues.get(view);
}
if (!(transitionValues2 == null && matchedTransitionValues == null) && animationInfo.mTransition.isTransitionRequired(transitionValues, matchedTransitionValues)) {
if (keyAt.isRunning() || keyAt.isStarted()) {
keyAt.cancel();
} else {
runningAnimators.remove(keyAt);
}
}
}
}
createAnimators(viewGroup, this.mStartValues, this.mEndValues, this.mStartValuesList, this.mEndValuesList);
runAnimators();
}
public boolean isTransitionRequired(TransitionValues transitionValues, TransitionValues transitionValues2) {
if (transitionValues == null || transitionValues2 == null) {
return false;
}
String[] transitionProperties = getTransitionProperties();
if (transitionProperties != null) {
int length = transitionProperties.length;
int i = 0;
while (i < length) {
if (!isValueChanged(transitionValues, transitionValues2, transitionProperties[i])) {
i++;
}
}
return false;
}
for (String isValueChanged : transitionValues.values.keySet()) {
if (isValueChanged(transitionValues, transitionValues2, isValueChanged)) {
}
}
return false;
return true;
}
private static boolean isValueChanged(TransitionValues transitionValues, TransitionValues transitionValues2, String str) {
Object obj = transitionValues.values.get(str);
Object obj2 = transitionValues2.values.get(str);
if (obj == null && obj2 == null) {
return false;
}
if (obj == null || obj2 == null) {
return true;
}
return true ^ obj.equals(obj2);
}
/* access modifiers changed from: protected */
public void animate(Animator animator) {
if (animator == null) {
end();
return;
}
if (getDuration() >= 0) {
animator.setDuration(getDuration());
}
if (getStartDelay() >= 0) {
animator.setStartDelay(getStartDelay() + animator.getStartDelay());
}
if (getInterpolator() != null) {
animator.setInterpolator(getInterpolator());
}
animator.addListener(new AnimatorListenerAdapter() {
public void onAnimationEnd(Animator animator) {
Transition.this.end();
animator.removeListener(this);
}
});
animator.start();
}
/* access modifiers changed from: protected */
public void start() {
if (this.mNumInstances == 0) {
ArrayList<TransitionListener> arrayList = this.mListeners;
if (arrayList != null && arrayList.size() > 0) {
ArrayList arrayList2 = (ArrayList) this.mListeners.clone();
int size = arrayList2.size();
for (int i = 0; i < size; i++) {
((TransitionListener) arrayList2.get(i)).onTransitionStart(this);
}
}
this.mEnded = false;
}
this.mNumInstances++;
}
/* access modifiers changed from: protected */
public void end() {
int i = this.mNumInstances - 1;
this.mNumInstances = i;
if (i == 0) {
ArrayList<TransitionListener> arrayList = this.mListeners;
if (arrayList != null && arrayList.size() > 0) {
ArrayList arrayList2 = (ArrayList) this.mListeners.clone();
int size = arrayList2.size();
for (int i2 = 0; i2 < size; i2++) {
((TransitionListener) arrayList2.get(i2)).onTransitionEnd(this);
}
}
for (int i3 = 0; i3 < this.mStartValues.mItemIdValues.size(); i3++) {
View valueAt = this.mStartValues.mItemIdValues.valueAt(i3);
if (valueAt != null) {
ViewCompat.setHasTransientState(valueAt, false);
}
}
for (int i4 = 0; i4 < this.mEndValues.mItemIdValues.size(); i4++) {
View valueAt2 = this.mEndValues.mItemIdValues.valueAt(i4);
if (valueAt2 != null) {
ViewCompat.setHasTransientState(valueAt2, false);
}
}
this.mEnded = true;
}
}
/* access modifiers changed from: package-private */
public void forceToEnd(ViewGroup viewGroup) {
ArrayMap<Animator, AnimationInfo> runningAnimators = getRunningAnimators();
int size = runningAnimators.size();
if (viewGroup != null && size != 0) {
WindowIdImpl windowId = ViewUtils.getWindowId(viewGroup);
ArrayMap arrayMap = new ArrayMap((SimpleArrayMap) runningAnimators);
runningAnimators.clear();
for (int i = size - 1; i >= 0; i--) {
AnimationInfo animationInfo = (AnimationInfo) arrayMap.valueAt(i);
if (!(animationInfo.mView == null || windowId == null || !windowId.equals(animationInfo.mWindowId))) {
((Animator) arrayMap.keyAt(i)).end();
}
}
}
}
/* access modifiers changed from: protected */
public void cancel() {
for (int size = this.mCurrentAnimators.size() - 1; size >= 0; size--) {
this.mCurrentAnimators.get(size).cancel();
}
ArrayList<TransitionListener> arrayList = this.mListeners;
if (arrayList != null && arrayList.size() > 0) {
ArrayList arrayList2 = (ArrayList) this.mListeners.clone();
int size2 = arrayList2.size();
for (int i = 0; i < size2; i++) {
((TransitionListener) arrayList2.get(i)).onTransitionCancel(this);
}
}
}
public Transition addListener(TransitionListener transitionListener) {
if (this.mListeners == null) {
this.mListeners = new ArrayList<>();
}
this.mListeners.add(transitionListener);
return this;
}
public Transition removeListener(TransitionListener transitionListener) {
ArrayList<TransitionListener> arrayList = this.mListeners;
if (arrayList == null) {
return this;
}
arrayList.remove(transitionListener);
if (this.mListeners.size() == 0) {
this.mListeners = null;
}
return this;
}
public void setPathMotion(PathMotion pathMotion) {
if (pathMotion == null) {
this.mPathMotion = STRAIGHT_PATH_MOTION;
} else {
this.mPathMotion = pathMotion;
}
}
public PathMotion getPathMotion() {
return this.mPathMotion;
}
public void setEpicenterCallback(EpicenterCallback epicenterCallback) {
this.mEpicenterCallback = epicenterCallback;
}
public EpicenterCallback getEpicenterCallback() {
return this.mEpicenterCallback;
}
public Rect getEpicenter() {
EpicenterCallback epicenterCallback = this.mEpicenterCallback;
if (epicenterCallback == null) {
return null;
}
return epicenterCallback.onGetEpicenter(this);
}
public void setPropagation(TransitionPropagation transitionPropagation) {
this.mPropagation = transitionPropagation;
}
public TransitionPropagation getPropagation() {
return this.mPropagation;
}
/* access modifiers changed from: package-private */
public void capturePropagationValues(TransitionValues transitionValues) {
String[] propagationProperties;
if (this.mPropagation != null && !transitionValues.values.isEmpty() && (propagationProperties = this.mPropagation.getPropagationProperties()) != null) {
boolean z = false;
int i = 0;
while (true) {
if (i >= propagationProperties.length) {
z = true;
break;
} else if (!transitionValues.values.containsKey(propagationProperties[i])) {
break;
} else {
i++;
}
}
if (!z) {
this.mPropagation.captureValues(transitionValues);
}
}
}
/* access modifiers changed from: package-private */
public Transition setSceneRoot(ViewGroup viewGroup) {
this.mSceneRoot = viewGroup;
return this;
}
/* access modifiers changed from: package-private */
public void setCanRemoveViews(boolean z) {
this.mCanRemoveViews = z;
}
public String toString() {
return toString("");
}
public Transition clone() {
try {
Transition transition = (Transition) super.clone();
transition.mAnimators = new ArrayList<>();
transition.mStartValues = new TransitionValuesMaps();
transition.mEndValues = new TransitionValuesMaps();
transition.mStartValuesList = null;
transition.mEndValuesList = null;
return transition;
} catch (CloneNotSupportedException unused) {
return null;
}
}
public String getName() {
return this.mName;
}
/* access modifiers changed from: package-private */
public String toString(String str) {
String str2 = str + getClass().getSimpleName() + "@" + Integer.toHexString(hashCode()) + ": ";
if (this.mDuration != -1) {
str2 = str2 + "dur(" + this.mDuration + ") ";
}
if (this.mStartDelay != -1) {
str2 = str2 + "dly(" + this.mStartDelay + ") ";
}
if (this.mInterpolator != null) {
str2 = str2 + "interp(" + this.mInterpolator + ") ";
}
if (this.mTargetIds.size() <= 0 && this.mTargets.size() <= 0) {
return str2;
}
String str3 = str2 + "tgts(";
if (this.mTargetIds.size() > 0) {
for (int i = 0; i < this.mTargetIds.size(); i++) {
if (i > 0) {
str3 = str3 + ", ";
}
str3 = str3 + this.mTargetIds.get(i);
}
}
if (this.mTargets.size() > 0) {
for (int i2 = 0; i2 < this.mTargets.size(); i2++) {
if (i2 > 0) {
str3 = str3 + ", ";
}
str3 = str3 + this.mTargets.get(i2);
}
}
return str3 + ")";
}
private static class AnimationInfo {
String mName;
Transition mTransition;
TransitionValues mValues;
View mView;
WindowIdImpl mWindowId;
AnimationInfo(View view, String str, Transition transition, WindowIdImpl windowIdImpl, TransitionValues transitionValues) {
this.mView = view;
this.mName = str;
this.mValues = transitionValues;
this.mWindowId = windowIdImpl;
this.mTransition = transition;
}
}
private static class ArrayListManager {
private ArrayListManager() {
}
static <T> ArrayList<T> add(ArrayList<T> arrayList, T t) {
if (arrayList == null) {
arrayList = new ArrayList<>();
}
if (!arrayList.contains(t)) {
arrayList.add(t);
}
return arrayList;
}
static <T> ArrayList<T> remove(ArrayList<T> arrayList, T t) {
if (arrayList == null) {
return arrayList;
}
arrayList.remove(t);
if (arrayList.isEmpty()) {
return null;
}
return arrayList;
}
}
}
Download file