1779 lines
73 KiB
Java
1779 lines
73 KiB
Java
package androidx.constraintlayout.motion.widget;
|
|
|
|
import android.content.Context;
|
|
import android.content.res.TypedArray;
|
|
import android.content.res.XmlResourceParser;
|
|
import android.graphics.RectF;
|
|
import android.util.AttributeSet;
|
|
import android.util.Log;
|
|
import android.util.SparseArray;
|
|
import android.util.SparseIntArray;
|
|
import android.util.TypedValue;
|
|
import android.util.Xml;
|
|
import android.view.MotionEvent;
|
|
import android.view.View;
|
|
import android.view.animation.AccelerateDecelerateInterpolator;
|
|
import android.view.animation.AccelerateInterpolator;
|
|
import android.view.animation.AnimationUtils;
|
|
import android.view.animation.AnticipateInterpolator;
|
|
import android.view.animation.BounceInterpolator;
|
|
import android.view.animation.DecelerateInterpolator;
|
|
import android.view.animation.Interpolator;
|
|
import android.view.animation.OvershootInterpolator;
|
|
import androidx.constraintlayout.core.motion.utils.Easing;
|
|
import androidx.constraintlayout.core.motion.utils.TypedValues;
|
|
import androidx.constraintlayout.motion.widget.MotionLayout;
|
|
import androidx.constraintlayout.widget.ConstraintSet;
|
|
import androidx.constraintlayout.widget.R;
|
|
import androidx.constraintlayout.widget.StateSet;
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import org.xmlpull.v1.XmlPullParser;
|
|
import org.xmlpull.v1.XmlPullParserException;
|
|
|
|
/* loaded from: classes.dex */
|
|
public class MotionScene {
|
|
static final int ANTICIPATE = 6;
|
|
static final int BOUNCE = 4;
|
|
private static final String CONSTRAINTSET_TAG = "ConstraintSet";
|
|
private static final boolean DEBUG = false;
|
|
static final int EASE_IN = 1;
|
|
static final int EASE_IN_OUT = 0;
|
|
static final int EASE_OUT = 2;
|
|
private static final String INCLUDE_TAG = "include";
|
|
private static final String INCLUDE_TAG_UC = "Include";
|
|
private static final int INTERPOLATOR_REFERENCE_ID = -2;
|
|
private static final String KEYFRAMESET_TAG = "KeyFrameSet";
|
|
public static final int LAYOUT_CALL_MEASURE = 2;
|
|
public static final int LAYOUT_HONOR_REQUEST = 1;
|
|
public static final int LAYOUT_IGNORE_REQUEST = 0;
|
|
static final int LINEAR = 3;
|
|
private static final int MIN_DURATION = 8;
|
|
private static final String MOTIONSCENE_TAG = "MotionScene";
|
|
private static final String ONCLICK_TAG = "OnClick";
|
|
private static final String ONSWIPE_TAG = "OnSwipe";
|
|
static final int OVERSHOOT = 5;
|
|
private static final int SPLINE_STRING = -1;
|
|
private static final String STATESET_TAG = "StateSet";
|
|
private static final String TAG = "MotionScene";
|
|
static final int TRANSITION_BACKWARD = 0;
|
|
static final int TRANSITION_FORWARD = 1;
|
|
private static final String TRANSITION_TAG = "Transition";
|
|
public static final int UNSET = -1;
|
|
private static final String VIEW_TRANSITION = "ViewTransition";
|
|
private MotionEvent mLastTouchDown;
|
|
float mLastTouchX;
|
|
float mLastTouchY;
|
|
private final MotionLayout mMotionLayout;
|
|
private boolean mRtl;
|
|
private MotionLayout.MotionTracker mVelocityTracker;
|
|
final ViewTransitionController mViewTransitionController;
|
|
StateSet mStateSet = null;
|
|
Transition mCurrentTransition = null;
|
|
private boolean mDisableAutoTransition = false;
|
|
private ArrayList<Transition> mTransitionList = new ArrayList<>();
|
|
private Transition mDefaultTransition = null;
|
|
private ArrayList<Transition> mAbstractTransitionList = new ArrayList<>();
|
|
private SparseArray<ConstraintSet> mConstraintSetMap = new SparseArray<>();
|
|
private HashMap<String, Integer> mConstraintSetIdMap = new HashMap<>();
|
|
private SparseIntArray mDeriveMap = new SparseIntArray();
|
|
private boolean DEBUG_DESKTOP = false;
|
|
private int mDefaultDuration = 400;
|
|
private int mLayoutDuringTransition = 0;
|
|
private boolean mIgnoreTouch = false;
|
|
private boolean mMotionOutsideRegion = false;
|
|
|
|
private boolean isProcessingTouch() {
|
|
return this.mVelocityTracker != null;
|
|
}
|
|
|
|
public void disableAutoTransition(boolean disable) {
|
|
this.mDisableAutoTransition = disable;
|
|
}
|
|
|
|
public ArrayList<Transition> getDefinedTransitions() {
|
|
return this.mTransitionList;
|
|
}
|
|
|
|
public float getPathPercent(View view, int position) {
|
|
return 0.0f;
|
|
}
|
|
|
|
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
|
|
}
|
|
|
|
/* JADX WARN: Code restructure failed: missing block: B:7:0x0013, code lost:
|
|
|
|
if (r2 != (-1)) goto L13;
|
|
*/
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
void setTransition(int r7, int r8) {
|
|
/*
|
|
r6 = this;
|
|
androidx.constraintlayout.widget.StateSet r0 = r6.mStateSet
|
|
r1 = -1
|
|
if (r0 == 0) goto L16
|
|
int r0 = r0.stateGetConstraintID(r7, r1, r1)
|
|
if (r0 == r1) goto Lc
|
|
goto Ld
|
|
Lc:
|
|
r0 = r7
|
|
Ld:
|
|
androidx.constraintlayout.widget.StateSet r2 = r6.mStateSet
|
|
int r2 = r2.stateGetConstraintID(r8, r1, r1)
|
|
if (r2 == r1) goto L17
|
|
goto L18
|
|
L16:
|
|
r0 = r7
|
|
L17:
|
|
r2 = r8
|
|
L18:
|
|
androidx.constraintlayout.motion.widget.MotionScene$Transition r3 = r6.mCurrentTransition
|
|
if (r3 == 0) goto L2b
|
|
int r3 = androidx.constraintlayout.motion.widget.MotionScene.Transition.access$000(r3)
|
|
if (r3 != r8) goto L2b
|
|
androidx.constraintlayout.motion.widget.MotionScene$Transition r3 = r6.mCurrentTransition
|
|
int r3 = androidx.constraintlayout.motion.widget.MotionScene.Transition.access$100(r3)
|
|
if (r3 != r7) goto L2b
|
|
return
|
|
L2b:
|
|
java.util.ArrayList<androidx.constraintlayout.motion.widget.MotionScene$Transition> r3 = r6.mTransitionList
|
|
java.util.Iterator r3 = r3.iterator()
|
|
L31:
|
|
boolean r4 = r3.hasNext()
|
|
if (r4 == 0) goto L6b
|
|
java.lang.Object r4 = r3.next()
|
|
androidx.constraintlayout.motion.widget.MotionScene$Transition r4 = (androidx.constraintlayout.motion.widget.MotionScene.Transition) r4
|
|
int r5 = androidx.constraintlayout.motion.widget.MotionScene.Transition.access$000(r4)
|
|
if (r5 != r2) goto L49
|
|
int r5 = androidx.constraintlayout.motion.widget.MotionScene.Transition.access$100(r4)
|
|
if (r5 == r0) goto L55
|
|
L49:
|
|
int r5 = androidx.constraintlayout.motion.widget.MotionScene.Transition.access$000(r4)
|
|
if (r5 != r8) goto L31
|
|
int r5 = androidx.constraintlayout.motion.widget.MotionScene.Transition.access$100(r4)
|
|
if (r5 != r7) goto L31
|
|
L55:
|
|
r6.mCurrentTransition = r4
|
|
if (r4 == 0) goto L6a
|
|
androidx.constraintlayout.motion.widget.TouchResponse r7 = androidx.constraintlayout.motion.widget.MotionScene.Transition.access$200(r4)
|
|
if (r7 == 0) goto L6a
|
|
androidx.constraintlayout.motion.widget.MotionScene$Transition r7 = r6.mCurrentTransition
|
|
androidx.constraintlayout.motion.widget.TouchResponse r7 = androidx.constraintlayout.motion.widget.MotionScene.Transition.access$200(r7)
|
|
boolean r8 = r6.mRtl
|
|
r7.setRTL(r8)
|
|
L6a:
|
|
return
|
|
L6b:
|
|
androidx.constraintlayout.motion.widget.MotionScene$Transition r7 = r6.mDefaultTransition
|
|
java.util.ArrayList<androidx.constraintlayout.motion.widget.MotionScene$Transition> r3 = r6.mAbstractTransitionList
|
|
java.util.Iterator r3 = r3.iterator()
|
|
L73:
|
|
boolean r4 = r3.hasNext()
|
|
if (r4 == 0) goto L87
|
|
java.lang.Object r4 = r3.next()
|
|
androidx.constraintlayout.motion.widget.MotionScene$Transition r4 = (androidx.constraintlayout.motion.widget.MotionScene.Transition) r4
|
|
int r5 = androidx.constraintlayout.motion.widget.MotionScene.Transition.access$000(r4)
|
|
if (r5 != r8) goto L73
|
|
r7 = r4
|
|
goto L73
|
|
L87:
|
|
androidx.constraintlayout.motion.widget.MotionScene$Transition r8 = new androidx.constraintlayout.motion.widget.MotionScene$Transition
|
|
r8.<init>(r6, r7)
|
|
androidx.constraintlayout.motion.widget.MotionScene.Transition.access$102(r8, r0)
|
|
androidx.constraintlayout.motion.widget.MotionScene.Transition.access$002(r8, r2)
|
|
if (r0 == r1) goto L99
|
|
java.util.ArrayList<androidx.constraintlayout.motion.widget.MotionScene$Transition> r7 = r6.mTransitionList
|
|
r7.add(r8)
|
|
L99:
|
|
r6.mCurrentTransition = r8
|
|
return
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.constraintlayout.motion.widget.MotionScene.setTransition(int, int):void");
|
|
}
|
|
|
|
public void addTransition(Transition transition) {
|
|
int index = getIndex(transition);
|
|
if (index == -1) {
|
|
this.mTransitionList.add(transition);
|
|
} else {
|
|
this.mTransitionList.set(index, transition);
|
|
}
|
|
}
|
|
|
|
public void removeTransition(Transition transition) {
|
|
int index = getIndex(transition);
|
|
if (index != -1) {
|
|
this.mTransitionList.remove(index);
|
|
}
|
|
}
|
|
|
|
private int getIndex(Transition transition) {
|
|
int i = transition.mId;
|
|
if (i == -1) {
|
|
throw new IllegalArgumentException("The transition must have an id");
|
|
}
|
|
for (int i2 = 0; i2 < this.mTransitionList.size(); i2++) {
|
|
if (this.mTransitionList.get(i2).mId == i) {
|
|
return i2;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public boolean validateLayout(MotionLayout layout) {
|
|
return layout == this.mMotionLayout && layout.mScene == this;
|
|
}
|
|
|
|
public void setTransition(Transition transition) {
|
|
this.mCurrentTransition = transition;
|
|
if (transition == null || transition.mTouchResponse == null) {
|
|
return;
|
|
}
|
|
this.mCurrentTransition.mTouchResponse.setRTL(this.mRtl);
|
|
}
|
|
|
|
private int getRealID(int stateId) {
|
|
int stateGetConstraintID;
|
|
StateSet stateSet = this.mStateSet;
|
|
return (stateSet == null || (stateGetConstraintID = stateSet.stateGetConstraintID(stateId, -1, -1)) == -1) ? stateId : stateGetConstraintID;
|
|
}
|
|
|
|
public List<Transition> getTransitionsWithState(int stateId) {
|
|
int realID = getRealID(stateId);
|
|
ArrayList arrayList = new ArrayList();
|
|
Iterator<Transition> it = this.mTransitionList.iterator();
|
|
while (it.hasNext()) {
|
|
Transition next = it.next();
|
|
if (next.mConstraintSetStart == realID || next.mConstraintSetEnd == realID) {
|
|
arrayList.add(next);
|
|
}
|
|
}
|
|
return arrayList;
|
|
}
|
|
|
|
public void addOnClickListeners(MotionLayout motionLayout, int currentState) {
|
|
Iterator<Transition> it = this.mTransitionList.iterator();
|
|
while (it.hasNext()) {
|
|
Transition next = it.next();
|
|
if (next.mOnClicks.size() > 0) {
|
|
Iterator it2 = next.mOnClicks.iterator();
|
|
while (it2.hasNext()) {
|
|
((Transition.TransitionOnClick) it2.next()).removeOnClickListeners(motionLayout);
|
|
}
|
|
}
|
|
}
|
|
Iterator<Transition> it3 = this.mAbstractTransitionList.iterator();
|
|
while (it3.hasNext()) {
|
|
Transition next2 = it3.next();
|
|
if (next2.mOnClicks.size() > 0) {
|
|
Iterator it4 = next2.mOnClicks.iterator();
|
|
while (it4.hasNext()) {
|
|
((Transition.TransitionOnClick) it4.next()).removeOnClickListeners(motionLayout);
|
|
}
|
|
}
|
|
}
|
|
Iterator<Transition> it5 = this.mTransitionList.iterator();
|
|
while (it5.hasNext()) {
|
|
Transition next3 = it5.next();
|
|
if (next3.mOnClicks.size() > 0) {
|
|
Iterator it6 = next3.mOnClicks.iterator();
|
|
while (it6.hasNext()) {
|
|
((Transition.TransitionOnClick) it6.next()).addOnClickListeners(motionLayout, currentState, next3);
|
|
}
|
|
}
|
|
}
|
|
Iterator<Transition> it7 = this.mAbstractTransitionList.iterator();
|
|
while (it7.hasNext()) {
|
|
Transition next4 = it7.next();
|
|
if (next4.mOnClicks.size() > 0) {
|
|
Iterator it8 = next4.mOnClicks.iterator();
|
|
while (it8.hasNext()) {
|
|
((Transition.TransitionOnClick) it8.next()).addOnClickListeners(motionLayout, currentState, next4);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public Transition bestTransitionFor(int currentState, float dx, float dy, MotionEvent lastTouchDown) {
|
|
if (currentState == -1) {
|
|
return this.mCurrentTransition;
|
|
}
|
|
List<Transition> transitionsWithState = getTransitionsWithState(currentState);
|
|
RectF rectF = new RectF();
|
|
float f = 0.0f;
|
|
Transition transition = null;
|
|
for (Transition transition2 : transitionsWithState) {
|
|
if (!transition2.mDisable && transition2.mTouchResponse != null) {
|
|
transition2.mTouchResponse.setRTL(this.mRtl);
|
|
RectF touchRegion = transition2.mTouchResponse.getTouchRegion(this.mMotionLayout, rectF);
|
|
if (touchRegion == null || lastTouchDown == null || touchRegion.contains(lastTouchDown.getX(), lastTouchDown.getY())) {
|
|
RectF limitBoundsTo = transition2.mTouchResponse.getLimitBoundsTo(this.mMotionLayout, rectF);
|
|
if (limitBoundsTo == null || lastTouchDown == null || limitBoundsTo.contains(lastTouchDown.getX(), lastTouchDown.getY())) {
|
|
float dot = transition2.mTouchResponse.dot(dx, dy);
|
|
if (transition2.mTouchResponse.mIsRotateMode && lastTouchDown != null) {
|
|
dot = ((float) (Math.atan2(dy + r10, dx + r9) - Math.atan2(lastTouchDown.getX() - transition2.mTouchResponse.mRotateCenterX, lastTouchDown.getY() - transition2.mTouchResponse.mRotateCenterY))) * 10.0f;
|
|
}
|
|
float f2 = dot * (transition2.mConstraintSetEnd == currentState ? -1.0f : 1.1f);
|
|
if (f2 > f) {
|
|
transition = transition2;
|
|
f = f2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return transition;
|
|
}
|
|
|
|
public Transition getTransitionById(int id) {
|
|
Iterator<Transition> it = this.mTransitionList.iterator();
|
|
while (it.hasNext()) {
|
|
Transition next = it.next();
|
|
if (next.mId == id) {
|
|
return next;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public int[] getConstraintSetIds() {
|
|
int size = this.mConstraintSetMap.size();
|
|
int[] iArr = new int[size];
|
|
for (int i = 0; i < size; i++) {
|
|
iArr[i] = this.mConstraintSetMap.keyAt(i);
|
|
}
|
|
return iArr;
|
|
}
|
|
|
|
boolean autoTransition(MotionLayout motionLayout, int currentState) {
|
|
Transition transition;
|
|
if (isProcessingTouch() || this.mDisableAutoTransition) {
|
|
return false;
|
|
}
|
|
Iterator<Transition> it = this.mTransitionList.iterator();
|
|
while (it.hasNext()) {
|
|
Transition next = it.next();
|
|
if (next.mAutoTransition != 0 && ((transition = this.mCurrentTransition) != next || !transition.isTransitionFlag(2))) {
|
|
if (currentState == next.mConstraintSetStart && (next.mAutoTransition == 4 || next.mAutoTransition == 2)) {
|
|
motionLayout.setState(MotionLayout.TransitionState.FINISHED);
|
|
motionLayout.setTransition(next);
|
|
if (next.mAutoTransition == 4) {
|
|
motionLayout.transitionToEnd();
|
|
motionLayout.setState(MotionLayout.TransitionState.SETUP);
|
|
motionLayout.setState(MotionLayout.TransitionState.MOVING);
|
|
} else {
|
|
motionLayout.setProgress(1.0f);
|
|
motionLayout.evaluate(true);
|
|
motionLayout.setState(MotionLayout.TransitionState.SETUP);
|
|
motionLayout.setState(MotionLayout.TransitionState.MOVING);
|
|
motionLayout.setState(MotionLayout.TransitionState.FINISHED);
|
|
motionLayout.onNewStateAttachHandlers();
|
|
}
|
|
return true;
|
|
}
|
|
if (currentState == next.mConstraintSetEnd && (next.mAutoTransition == 3 || next.mAutoTransition == 1)) {
|
|
motionLayout.setState(MotionLayout.TransitionState.FINISHED);
|
|
motionLayout.setTransition(next);
|
|
if (next.mAutoTransition == 3) {
|
|
motionLayout.transitionToStart();
|
|
motionLayout.setState(MotionLayout.TransitionState.SETUP);
|
|
motionLayout.setState(MotionLayout.TransitionState.MOVING);
|
|
} else {
|
|
motionLayout.setProgress(0.0f);
|
|
motionLayout.evaluate(true);
|
|
motionLayout.setState(MotionLayout.TransitionState.SETUP);
|
|
motionLayout.setState(MotionLayout.TransitionState.MOVING);
|
|
motionLayout.setState(MotionLayout.TransitionState.FINISHED);
|
|
motionLayout.onNewStateAttachHandlers();
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void setRtl(boolean rtl) {
|
|
this.mRtl = rtl;
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null || transition.mTouchResponse == null) {
|
|
return;
|
|
}
|
|
this.mCurrentTransition.mTouchResponse.setRTL(this.mRtl);
|
|
}
|
|
|
|
public void viewTransition(int id, View... view) {
|
|
this.mViewTransitionController.viewTransition(id, view);
|
|
}
|
|
|
|
public void enableViewTransition(int id, boolean enable) {
|
|
this.mViewTransitionController.enableViewTransition(id, enable);
|
|
}
|
|
|
|
public boolean isViewTransitionEnabled(int id) {
|
|
return this.mViewTransitionController.isViewTransitionEnabled(id);
|
|
}
|
|
|
|
public boolean applyViewTransition(int viewTransitionId, MotionController motionController) {
|
|
return this.mViewTransitionController.applyViewTransition(viewTransitionId, motionController);
|
|
}
|
|
|
|
public static class Transition {
|
|
public static final int AUTO_ANIMATE_TO_END = 4;
|
|
public static final int AUTO_ANIMATE_TO_START = 3;
|
|
public static final int AUTO_JUMP_TO_END = 2;
|
|
public static final int AUTO_JUMP_TO_START = 1;
|
|
public static final int AUTO_NONE = 0;
|
|
public static final int INTERPOLATE_ANTICIPATE = 6;
|
|
public static final int INTERPOLATE_BOUNCE = 4;
|
|
public static final int INTERPOLATE_EASE_IN = 1;
|
|
public static final int INTERPOLATE_EASE_IN_OUT = 0;
|
|
public static final int INTERPOLATE_EASE_OUT = 2;
|
|
public static final int INTERPOLATE_LINEAR = 3;
|
|
public static final int INTERPOLATE_OVERSHOOT = 5;
|
|
public static final int INTERPOLATE_REFERENCE_ID = -2;
|
|
public static final int INTERPOLATE_SPLINE_STRING = -1;
|
|
static final int TRANSITION_FLAG_FIRST_DRAW = 1;
|
|
static final int TRANSITION_FLAG_INTERCEPT_TOUCH = 4;
|
|
static final int TRANSITION_FLAG_INTRA_AUTO = 2;
|
|
private int mAutoTransition;
|
|
private int mConstraintSetEnd;
|
|
private int mConstraintSetStart;
|
|
private int mDefaultInterpolator;
|
|
private int mDefaultInterpolatorID;
|
|
private String mDefaultInterpolatorString;
|
|
private boolean mDisable;
|
|
private int mDuration;
|
|
private int mId;
|
|
private boolean mIsAbstract;
|
|
private ArrayList<KeyFrames> mKeyFramesList;
|
|
private int mLayoutDuringTransition;
|
|
private final MotionScene mMotionScene;
|
|
private ArrayList<TransitionOnClick> mOnClicks;
|
|
private int mPathMotionArc;
|
|
private float mStagger;
|
|
private TouchResponse mTouchResponse;
|
|
private int mTransitionFlags;
|
|
|
|
public int getAutoTransition() {
|
|
return this.mAutoTransition;
|
|
}
|
|
|
|
public int getDuration() {
|
|
return this.mDuration;
|
|
}
|
|
|
|
public int getEndConstraintSetId() {
|
|
return this.mConstraintSetEnd;
|
|
}
|
|
|
|
public int getId() {
|
|
return this.mId;
|
|
}
|
|
|
|
public List<KeyFrames> getKeyFrameList() {
|
|
return this.mKeyFramesList;
|
|
}
|
|
|
|
public int getLayoutDuringTransition() {
|
|
return this.mLayoutDuringTransition;
|
|
}
|
|
|
|
public List<TransitionOnClick> getOnClickList() {
|
|
return this.mOnClicks;
|
|
}
|
|
|
|
public int getPathMotionArc() {
|
|
return this.mPathMotionArc;
|
|
}
|
|
|
|
public float getStagger() {
|
|
return this.mStagger;
|
|
}
|
|
|
|
public int getStartConstraintSetId() {
|
|
return this.mConstraintSetStart;
|
|
}
|
|
|
|
public TouchResponse getTouchResponse() {
|
|
return this.mTouchResponse;
|
|
}
|
|
|
|
public boolean isEnabled() {
|
|
return !this.mDisable;
|
|
}
|
|
|
|
public boolean isTransitionFlag(int flag) {
|
|
return (flag & this.mTransitionFlags) != 0;
|
|
}
|
|
|
|
public void setAutoTransition(int type) {
|
|
this.mAutoTransition = type;
|
|
}
|
|
|
|
public void setEnabled(boolean enable) {
|
|
this.mDisable = !enable;
|
|
}
|
|
|
|
public void setInterpolatorInfo(int interpolator, String interpolatorString, int interpolatorID) {
|
|
this.mDefaultInterpolator = interpolator;
|
|
this.mDefaultInterpolatorString = interpolatorString;
|
|
this.mDefaultInterpolatorID = interpolatorID;
|
|
}
|
|
|
|
public void setLayoutDuringTransition(int mode) {
|
|
this.mLayoutDuringTransition = mode;
|
|
}
|
|
|
|
public void setPathMotionArc(int arcMode) {
|
|
this.mPathMotionArc = arcMode;
|
|
}
|
|
|
|
public void setStagger(float stagger) {
|
|
this.mStagger = stagger;
|
|
}
|
|
|
|
public void setTransitionFlag(int flag) {
|
|
this.mTransitionFlags = flag;
|
|
}
|
|
|
|
public void setOnSwipe(OnSwipe onSwipe) {
|
|
this.mTouchResponse = onSwipe == null ? null : new TouchResponse(this.mMotionScene.mMotionLayout, onSwipe);
|
|
}
|
|
|
|
public void addOnClick(int id, int action) {
|
|
Iterator<TransitionOnClick> it = this.mOnClicks.iterator();
|
|
while (it.hasNext()) {
|
|
TransitionOnClick next = it.next();
|
|
if (next.mTargetId == id) {
|
|
next.mMode = action;
|
|
return;
|
|
}
|
|
}
|
|
this.mOnClicks.add(new TransitionOnClick(this, id, action));
|
|
}
|
|
|
|
public void removeOnClick(int id) {
|
|
TransitionOnClick transitionOnClick;
|
|
Iterator<TransitionOnClick> it = this.mOnClicks.iterator();
|
|
while (true) {
|
|
if (!it.hasNext()) {
|
|
transitionOnClick = null;
|
|
break;
|
|
} else {
|
|
transitionOnClick = it.next();
|
|
if (transitionOnClick.mTargetId == id) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (transitionOnClick != null) {
|
|
this.mOnClicks.remove(transitionOnClick);
|
|
}
|
|
}
|
|
|
|
public void addOnClick(Context context, XmlPullParser parser) {
|
|
this.mOnClicks.add(new TransitionOnClick(context, this, parser));
|
|
}
|
|
|
|
public void setDuration(int duration) {
|
|
this.mDuration = Math.max(duration, 8);
|
|
}
|
|
|
|
public void addKeyFrame(KeyFrames keyFrames) {
|
|
this.mKeyFramesList.add(keyFrames);
|
|
}
|
|
|
|
public void setEnable(boolean enable) {
|
|
setEnabled(enable);
|
|
}
|
|
|
|
public String debugString(Context context) {
|
|
String resourceEntryName = this.mConstraintSetStart == -1 ? "null" : context.getResources().getResourceEntryName(this.mConstraintSetStart);
|
|
if (this.mConstraintSetEnd == -1) {
|
|
return resourceEntryName + " -> null";
|
|
}
|
|
return resourceEntryName + " -> " + context.getResources().getResourceEntryName(this.mConstraintSetEnd);
|
|
}
|
|
|
|
public void setOnTouchUp(int touchUpMode) {
|
|
TouchResponse touchResponse = getTouchResponse();
|
|
if (touchResponse != null) {
|
|
touchResponse.setTouchUpMode(touchUpMode);
|
|
}
|
|
}
|
|
|
|
public static class TransitionOnClick implements View.OnClickListener {
|
|
public static final int ANIM_TOGGLE = 17;
|
|
public static final int ANIM_TO_END = 1;
|
|
public static final int ANIM_TO_START = 16;
|
|
public static final int JUMP_TO_END = 256;
|
|
public static final int JUMP_TO_START = 4096;
|
|
int mMode;
|
|
int mTargetId;
|
|
private final Transition mTransition;
|
|
|
|
public TransitionOnClick(Context context, Transition transition, XmlPullParser parser) {
|
|
this.mTargetId = -1;
|
|
this.mMode = 17;
|
|
this.mTransition = transition;
|
|
TypedArray obtainStyledAttributes = context.obtainStyledAttributes(Xml.asAttributeSet(parser), R.styleable.OnClick);
|
|
int indexCount = obtainStyledAttributes.getIndexCount();
|
|
for (int i = 0; i < indexCount; i++) {
|
|
int index = obtainStyledAttributes.getIndex(i);
|
|
if (index == R.styleable.OnClick_targetId) {
|
|
this.mTargetId = obtainStyledAttributes.getResourceId(index, this.mTargetId);
|
|
} else if (index == R.styleable.OnClick_clickAction) {
|
|
this.mMode = obtainStyledAttributes.getInt(index, this.mMode);
|
|
}
|
|
}
|
|
obtainStyledAttributes.recycle();
|
|
}
|
|
|
|
public TransitionOnClick(Transition transition, int id, int action) {
|
|
this.mTransition = transition;
|
|
this.mTargetId = id;
|
|
this.mMode = action;
|
|
}
|
|
|
|
public void addOnClickListeners(MotionLayout motionLayout, int i, Transition transition) {
|
|
int i2 = this.mTargetId;
|
|
View view = motionLayout;
|
|
if (i2 != -1) {
|
|
view = motionLayout.findViewById(i2);
|
|
}
|
|
if (view != null) {
|
|
int i3 = transition.mConstraintSetStart;
|
|
int i4 = transition.mConstraintSetEnd;
|
|
if (i3 == -1) {
|
|
view.setOnClickListener(this);
|
|
return;
|
|
}
|
|
int i5 = this.mMode;
|
|
boolean z = false;
|
|
boolean z2 = ((i5 & 1) != 0 && i == i3) | ((i5 & 1) != 0 && i == i3) | ((i5 & 256) != 0 && i == i3) | ((i5 & 16) != 0 && i == i4);
|
|
if ((i5 & 4096) != 0 && i == i4) {
|
|
z = true;
|
|
}
|
|
if (z2 || z) {
|
|
view.setOnClickListener(this);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
Log.e(TypedValues.MotionScene.NAME, "OnClick could not find id " + this.mTargetId);
|
|
}
|
|
|
|
public void removeOnClickListeners(MotionLayout motionLayout) {
|
|
int i = this.mTargetId;
|
|
if (i == -1) {
|
|
return;
|
|
}
|
|
View findViewById = motionLayout.findViewById(i);
|
|
if (findViewById == null) {
|
|
Log.e(TypedValues.MotionScene.NAME, " (*) could not find id " + this.mTargetId);
|
|
return;
|
|
}
|
|
findViewById.setOnClickListener(null);
|
|
}
|
|
|
|
boolean isTransitionViable(Transition current, MotionLayout tl) {
|
|
Transition transition = this.mTransition;
|
|
if (transition == current) {
|
|
return true;
|
|
}
|
|
int i = transition.mConstraintSetEnd;
|
|
int i2 = this.mTransition.mConstraintSetStart;
|
|
return i2 == -1 ? tl.mCurrentState != i : tl.mCurrentState == i2 || tl.mCurrentState == i;
|
|
}
|
|
|
|
@Override // android.view.View.OnClickListener
|
|
public void onClick(View view) {
|
|
MotionLayout motionLayout = this.mTransition.mMotionScene.mMotionLayout;
|
|
if (motionLayout.isInteractionEnabled()) {
|
|
if (this.mTransition.mConstraintSetStart != -1) {
|
|
Transition transition = this.mTransition.mMotionScene.mCurrentTransition;
|
|
int i = this.mMode;
|
|
boolean z = false;
|
|
boolean z2 = ((i & 1) == 0 && (i & 256) == 0) ? false : true;
|
|
boolean z3 = ((i & 16) == 0 && (i & 4096) == 0) ? false : true;
|
|
if (z2 && z3) {
|
|
Transition transition2 = this.mTransition.mMotionScene.mCurrentTransition;
|
|
Transition transition3 = this.mTransition;
|
|
if (transition2 != transition3) {
|
|
motionLayout.setTransition(transition3);
|
|
}
|
|
if (motionLayout.getCurrentState() != motionLayout.getEndState() && motionLayout.getProgress() <= 0.5f) {
|
|
z = z2;
|
|
z3 = false;
|
|
}
|
|
} else {
|
|
z = z2;
|
|
}
|
|
if (isTransitionViable(transition, motionLayout)) {
|
|
if (z && (this.mMode & 1) != 0) {
|
|
motionLayout.setTransition(this.mTransition);
|
|
motionLayout.transitionToEnd();
|
|
return;
|
|
}
|
|
if (z3 && (this.mMode & 16) != 0) {
|
|
motionLayout.setTransition(this.mTransition);
|
|
motionLayout.transitionToStart();
|
|
return;
|
|
} else if (z && (this.mMode & 256) != 0) {
|
|
motionLayout.setTransition(this.mTransition);
|
|
motionLayout.setProgress(1.0f);
|
|
return;
|
|
} else {
|
|
if (!z3 || (this.mMode & 4096) == 0) {
|
|
return;
|
|
}
|
|
motionLayout.setTransition(this.mTransition);
|
|
motionLayout.setProgress(0.0f);
|
|
return;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
int currentState = motionLayout.getCurrentState();
|
|
if (currentState == -1) {
|
|
motionLayout.transitionToState(this.mTransition.mConstraintSetEnd);
|
|
return;
|
|
}
|
|
Transition transition4 = new Transition(this.mTransition.mMotionScene, this.mTransition);
|
|
transition4.mConstraintSetStart = currentState;
|
|
transition4.mConstraintSetEnd = this.mTransition.mConstraintSetEnd;
|
|
motionLayout.setTransition(transition4);
|
|
motionLayout.transitionToEnd();
|
|
}
|
|
}
|
|
}
|
|
|
|
Transition(MotionScene motionScene, Transition global) {
|
|
this.mId = -1;
|
|
this.mIsAbstract = false;
|
|
this.mConstraintSetEnd = -1;
|
|
this.mConstraintSetStart = -1;
|
|
this.mDefaultInterpolator = 0;
|
|
this.mDefaultInterpolatorString = null;
|
|
this.mDefaultInterpolatorID = -1;
|
|
this.mDuration = 400;
|
|
this.mStagger = 0.0f;
|
|
this.mKeyFramesList = new ArrayList<>();
|
|
this.mTouchResponse = null;
|
|
this.mOnClicks = new ArrayList<>();
|
|
this.mAutoTransition = 0;
|
|
this.mDisable = false;
|
|
this.mPathMotionArc = -1;
|
|
this.mLayoutDuringTransition = 0;
|
|
this.mTransitionFlags = 0;
|
|
this.mMotionScene = motionScene;
|
|
this.mDuration = motionScene.mDefaultDuration;
|
|
if (global != null) {
|
|
this.mPathMotionArc = global.mPathMotionArc;
|
|
this.mDefaultInterpolator = global.mDefaultInterpolator;
|
|
this.mDefaultInterpolatorString = global.mDefaultInterpolatorString;
|
|
this.mDefaultInterpolatorID = global.mDefaultInterpolatorID;
|
|
this.mDuration = global.mDuration;
|
|
this.mKeyFramesList = global.mKeyFramesList;
|
|
this.mStagger = global.mStagger;
|
|
this.mLayoutDuringTransition = global.mLayoutDuringTransition;
|
|
}
|
|
}
|
|
|
|
public Transition(int id, MotionScene motionScene, int constraintSetStartId, int constraintSetEndId) {
|
|
this.mId = -1;
|
|
this.mIsAbstract = false;
|
|
this.mConstraintSetEnd = -1;
|
|
this.mConstraintSetStart = -1;
|
|
this.mDefaultInterpolator = 0;
|
|
this.mDefaultInterpolatorString = null;
|
|
this.mDefaultInterpolatorID = -1;
|
|
this.mDuration = 400;
|
|
this.mStagger = 0.0f;
|
|
this.mKeyFramesList = new ArrayList<>();
|
|
this.mTouchResponse = null;
|
|
this.mOnClicks = new ArrayList<>();
|
|
this.mAutoTransition = 0;
|
|
this.mDisable = false;
|
|
this.mPathMotionArc = -1;
|
|
this.mLayoutDuringTransition = 0;
|
|
this.mTransitionFlags = 0;
|
|
this.mId = id;
|
|
this.mMotionScene = motionScene;
|
|
this.mConstraintSetStart = constraintSetStartId;
|
|
this.mConstraintSetEnd = constraintSetEndId;
|
|
this.mDuration = motionScene.mDefaultDuration;
|
|
this.mLayoutDuringTransition = motionScene.mLayoutDuringTransition;
|
|
}
|
|
|
|
Transition(MotionScene motionScene, Context context, XmlPullParser parser) {
|
|
this.mId = -1;
|
|
this.mIsAbstract = false;
|
|
this.mConstraintSetEnd = -1;
|
|
this.mConstraintSetStart = -1;
|
|
this.mDefaultInterpolator = 0;
|
|
this.mDefaultInterpolatorString = null;
|
|
this.mDefaultInterpolatorID = -1;
|
|
this.mDuration = 400;
|
|
this.mStagger = 0.0f;
|
|
this.mKeyFramesList = new ArrayList<>();
|
|
this.mTouchResponse = null;
|
|
this.mOnClicks = new ArrayList<>();
|
|
this.mAutoTransition = 0;
|
|
this.mDisable = false;
|
|
this.mPathMotionArc = -1;
|
|
this.mLayoutDuringTransition = 0;
|
|
this.mTransitionFlags = 0;
|
|
this.mDuration = motionScene.mDefaultDuration;
|
|
this.mLayoutDuringTransition = motionScene.mLayoutDuringTransition;
|
|
this.mMotionScene = motionScene;
|
|
fillFromAttributeList(motionScene, context, Xml.asAttributeSet(parser));
|
|
}
|
|
|
|
private void fillFromAttributeList(MotionScene motionScene, Context context, AttributeSet attrs) {
|
|
TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attrs, R.styleable.Transition);
|
|
fill(motionScene, context, obtainStyledAttributes);
|
|
obtainStyledAttributes.recycle();
|
|
}
|
|
|
|
private void fill(MotionScene motionScene, Context context, TypedArray a) {
|
|
int indexCount = a.getIndexCount();
|
|
for (int i = 0; i < indexCount; i++) {
|
|
int index = a.getIndex(i);
|
|
if (index == R.styleable.Transition_constraintSetEnd) {
|
|
this.mConstraintSetEnd = a.getResourceId(index, -1);
|
|
String resourceTypeName = context.getResources().getResourceTypeName(this.mConstraintSetEnd);
|
|
if ("layout".equals(resourceTypeName)) {
|
|
ConstraintSet constraintSet = new ConstraintSet();
|
|
constraintSet.load(context, this.mConstraintSetEnd);
|
|
motionScene.mConstraintSetMap.append(this.mConstraintSetEnd, constraintSet);
|
|
} else if ("xml".equals(resourceTypeName)) {
|
|
this.mConstraintSetEnd = motionScene.parseInclude(context, this.mConstraintSetEnd);
|
|
}
|
|
} else if (index == R.styleable.Transition_constraintSetStart) {
|
|
this.mConstraintSetStart = a.getResourceId(index, this.mConstraintSetStart);
|
|
String resourceTypeName2 = context.getResources().getResourceTypeName(this.mConstraintSetStart);
|
|
if ("layout".equals(resourceTypeName2)) {
|
|
ConstraintSet constraintSet2 = new ConstraintSet();
|
|
constraintSet2.load(context, this.mConstraintSetStart);
|
|
motionScene.mConstraintSetMap.append(this.mConstraintSetStart, constraintSet2);
|
|
} else if ("xml".equals(resourceTypeName2)) {
|
|
this.mConstraintSetStart = motionScene.parseInclude(context, this.mConstraintSetStart);
|
|
}
|
|
} else if (index == R.styleable.Transition_motionInterpolator) {
|
|
TypedValue peekValue = a.peekValue(index);
|
|
if (peekValue.type == 1) {
|
|
int resourceId = a.getResourceId(index, -1);
|
|
this.mDefaultInterpolatorID = resourceId;
|
|
if (resourceId != -1) {
|
|
this.mDefaultInterpolator = -2;
|
|
}
|
|
} else if (peekValue.type == 3) {
|
|
String string = a.getString(index);
|
|
this.mDefaultInterpolatorString = string;
|
|
if (string != null) {
|
|
if (string.indexOf("/") > 0) {
|
|
this.mDefaultInterpolatorID = a.getResourceId(index, -1);
|
|
this.mDefaultInterpolator = -2;
|
|
} else {
|
|
this.mDefaultInterpolator = -1;
|
|
}
|
|
}
|
|
} else {
|
|
this.mDefaultInterpolator = a.getInteger(index, this.mDefaultInterpolator);
|
|
}
|
|
} else if (index == R.styleable.Transition_duration) {
|
|
int i2 = a.getInt(index, this.mDuration);
|
|
this.mDuration = i2;
|
|
if (i2 < 8) {
|
|
this.mDuration = 8;
|
|
}
|
|
} else if (index == R.styleable.Transition_staggered) {
|
|
this.mStagger = a.getFloat(index, this.mStagger);
|
|
} else if (index == R.styleable.Transition_autoTransition) {
|
|
this.mAutoTransition = a.getInteger(index, this.mAutoTransition);
|
|
} else if (index == R.styleable.Transition_android_id) {
|
|
this.mId = a.getResourceId(index, this.mId);
|
|
} else if (index == R.styleable.Transition_transitionDisable) {
|
|
this.mDisable = a.getBoolean(index, this.mDisable);
|
|
} else if (index == R.styleable.Transition_pathMotionArc) {
|
|
this.mPathMotionArc = a.getInteger(index, -1);
|
|
} else if (index == R.styleable.Transition_layoutDuringTransition) {
|
|
this.mLayoutDuringTransition = a.getInteger(index, 0);
|
|
} else if (index == R.styleable.Transition_transitionFlags) {
|
|
this.mTransitionFlags = a.getInteger(index, 0);
|
|
}
|
|
}
|
|
if (this.mConstraintSetStart == -1) {
|
|
this.mIsAbstract = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public MotionScene(MotionLayout layout) {
|
|
this.mMotionLayout = layout;
|
|
this.mViewTransitionController = new ViewTransitionController(layout);
|
|
}
|
|
|
|
MotionScene(Context context, MotionLayout layout, int resourceID) {
|
|
this.mMotionLayout = layout;
|
|
this.mViewTransitionController = new ViewTransitionController(layout);
|
|
load(context, resourceID);
|
|
this.mConstraintSetMap.put(R.id.motion_base, new ConstraintSet());
|
|
this.mConstraintSetIdMap.put("motion_base", Integer.valueOf(R.id.motion_base));
|
|
}
|
|
|
|
/* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
|
|
private void load(Context context, int resourceId) {
|
|
XmlResourceParser xml = context.getResources().getXml(resourceId);
|
|
try {
|
|
int eventType = xml.getEventType();
|
|
Transition transition = null;
|
|
while (true) {
|
|
char c = 1;
|
|
if (eventType == 1) {
|
|
return;
|
|
}
|
|
if (eventType == 0) {
|
|
xml.getName();
|
|
} else if (eventType == 2) {
|
|
String name = xml.getName();
|
|
if (this.DEBUG_DESKTOP) {
|
|
System.out.println("parsing = " + name);
|
|
}
|
|
switch (name.hashCode()) {
|
|
case -1349929691:
|
|
if (name.equals(CONSTRAINTSET_TAG)) {
|
|
c = 5;
|
|
break;
|
|
}
|
|
c = 65535;
|
|
break;
|
|
case -1239391468:
|
|
if (name.equals("KeyFrameSet")) {
|
|
c = '\b';
|
|
break;
|
|
}
|
|
c = 65535;
|
|
break;
|
|
case -687739768:
|
|
if (name.equals(INCLUDE_TAG_UC)) {
|
|
c = 7;
|
|
break;
|
|
}
|
|
c = 65535;
|
|
break;
|
|
case 61998586:
|
|
if (name.equals("ViewTransition")) {
|
|
c = '\t';
|
|
break;
|
|
}
|
|
c = 65535;
|
|
break;
|
|
case 269306229:
|
|
if (name.equals(TRANSITION_TAG)) {
|
|
break;
|
|
}
|
|
c = 65535;
|
|
break;
|
|
case 312750793:
|
|
if (name.equals(ONCLICK_TAG)) {
|
|
c = 3;
|
|
break;
|
|
}
|
|
c = 65535;
|
|
break;
|
|
case 327855227:
|
|
if (name.equals(ONSWIPE_TAG)) {
|
|
c = 2;
|
|
break;
|
|
}
|
|
c = 65535;
|
|
break;
|
|
case 793277014:
|
|
if (name.equals(TypedValues.MotionScene.NAME)) {
|
|
c = 0;
|
|
break;
|
|
}
|
|
c = 65535;
|
|
break;
|
|
case 1382829617:
|
|
if (name.equals(STATESET_TAG)) {
|
|
c = 4;
|
|
break;
|
|
}
|
|
c = 65535;
|
|
break;
|
|
case 1942574248:
|
|
if (name.equals(INCLUDE_TAG)) {
|
|
c = 6;
|
|
break;
|
|
}
|
|
c = 65535;
|
|
break;
|
|
default:
|
|
c = 65535;
|
|
break;
|
|
}
|
|
switch (c) {
|
|
case 0:
|
|
parseMotionSceneTags(context, xml);
|
|
break;
|
|
case 1:
|
|
ArrayList<Transition> arrayList = this.mTransitionList;
|
|
transition = new Transition(this, context, xml);
|
|
arrayList.add(transition);
|
|
if (this.mCurrentTransition == null && !transition.mIsAbstract) {
|
|
this.mCurrentTransition = transition;
|
|
if (transition.mTouchResponse != null) {
|
|
this.mCurrentTransition.mTouchResponse.setRTL(this.mRtl);
|
|
}
|
|
}
|
|
if (!transition.mIsAbstract) {
|
|
break;
|
|
} else {
|
|
if (transition.mConstraintSetEnd == -1) {
|
|
this.mDefaultTransition = transition;
|
|
} else {
|
|
this.mAbstractTransitionList.add(transition);
|
|
}
|
|
this.mTransitionList.remove(transition);
|
|
break;
|
|
}
|
|
case 2:
|
|
if (transition == null) {
|
|
Log.v(TypedValues.MotionScene.NAME, " OnSwipe (" + context.getResources().getResourceEntryName(resourceId) + ".xml:" + xml.getLineNumber() + ")");
|
|
}
|
|
if (transition == null) {
|
|
break;
|
|
} else {
|
|
transition.mTouchResponse = new TouchResponse(context, this.mMotionLayout, xml);
|
|
break;
|
|
}
|
|
case 3:
|
|
if (transition == null) {
|
|
break;
|
|
} else {
|
|
transition.addOnClick(context, xml);
|
|
break;
|
|
}
|
|
case 4:
|
|
this.mStateSet = new StateSet(context, xml);
|
|
break;
|
|
case 5:
|
|
parseConstraintSet(context, xml);
|
|
break;
|
|
case 6:
|
|
case 7:
|
|
parseInclude(context, xml);
|
|
break;
|
|
case '\b':
|
|
KeyFrames keyFrames = new KeyFrames(context, xml);
|
|
if (transition == null) {
|
|
break;
|
|
} else {
|
|
transition.mKeyFramesList.add(keyFrames);
|
|
break;
|
|
}
|
|
case '\t':
|
|
this.mViewTransitionController.add(new ViewTransition(context, xml));
|
|
break;
|
|
}
|
|
}
|
|
eventType = xml.next();
|
|
}
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
} catch (XmlPullParserException e2) {
|
|
e2.printStackTrace();
|
|
}
|
|
}
|
|
|
|
private void parseMotionSceneTags(Context context, XmlPullParser parser) {
|
|
TypedArray obtainStyledAttributes = context.obtainStyledAttributes(Xml.asAttributeSet(parser), R.styleable.MotionScene);
|
|
int indexCount = obtainStyledAttributes.getIndexCount();
|
|
for (int i = 0; i < indexCount; i++) {
|
|
int index = obtainStyledAttributes.getIndex(i);
|
|
if (index == R.styleable.MotionScene_defaultDuration) {
|
|
int i2 = obtainStyledAttributes.getInt(index, this.mDefaultDuration);
|
|
this.mDefaultDuration = i2;
|
|
if (i2 < 8) {
|
|
this.mDefaultDuration = 8;
|
|
}
|
|
} else if (index == R.styleable.MotionScene_layoutDuringTransition) {
|
|
this.mLayoutDuringTransition = obtainStyledAttributes.getInteger(index, 0);
|
|
}
|
|
}
|
|
obtainStyledAttributes.recycle();
|
|
}
|
|
|
|
private int getId(Context context, String idString) {
|
|
int i;
|
|
if (idString.contains("/")) {
|
|
i = context.getResources().getIdentifier(idString.substring(idString.indexOf(47) + 1), "id", context.getPackageName());
|
|
if (this.DEBUG_DESKTOP) {
|
|
System.out.println("id getMap res = " + i);
|
|
}
|
|
} else {
|
|
i = -1;
|
|
}
|
|
if (i != -1) {
|
|
return i;
|
|
}
|
|
if (idString != null && idString.length() > 1) {
|
|
return Integer.parseInt(idString.substring(1));
|
|
}
|
|
Log.e(TypedValues.MotionScene.NAME, "error in parsing id");
|
|
return i;
|
|
}
|
|
|
|
private void parseInclude(Context context, XmlPullParser mainParser) {
|
|
TypedArray obtainStyledAttributes = context.obtainStyledAttributes(Xml.asAttributeSet(mainParser), R.styleable.include);
|
|
int indexCount = obtainStyledAttributes.getIndexCount();
|
|
for (int i = 0; i < indexCount; i++) {
|
|
int index = obtainStyledAttributes.getIndex(i);
|
|
if (index == R.styleable.include_constraintSet) {
|
|
parseInclude(context, obtainStyledAttributes.getResourceId(index, -1));
|
|
}
|
|
}
|
|
obtainStyledAttributes.recycle();
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public int parseInclude(Context context, int resourceId) {
|
|
XmlResourceParser xml = context.getResources().getXml(resourceId);
|
|
try {
|
|
for (int eventType = xml.getEventType(); eventType != 1; eventType = xml.next()) {
|
|
String name = xml.getName();
|
|
if (2 == eventType && CONSTRAINTSET_TAG.equals(name)) {
|
|
return parseConstraintSet(context, xml);
|
|
}
|
|
}
|
|
return -1;
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
return -1;
|
|
} catch (XmlPullParserException e2) {
|
|
e2.printStackTrace();
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
|
|
private int parseConstraintSet(Context context, XmlPullParser parser) {
|
|
char c;
|
|
char c2;
|
|
ConstraintSet constraintSet = new ConstraintSet();
|
|
constraintSet.setForceId(false);
|
|
int attributeCount = parser.getAttributeCount();
|
|
int i = -1;
|
|
int i2 = -1;
|
|
for (int i3 = 0; i3 < attributeCount; i3++) {
|
|
String attributeName = parser.getAttributeName(i3);
|
|
String attributeValue = parser.getAttributeValue(i3);
|
|
if (this.DEBUG_DESKTOP) {
|
|
System.out.println("id string = " + attributeValue);
|
|
}
|
|
attributeName.hashCode();
|
|
switch (attributeName.hashCode()) {
|
|
case -1496482599:
|
|
if (attributeName.equals("deriveConstraintsFrom")) {
|
|
c = 0;
|
|
break;
|
|
}
|
|
c = 65535;
|
|
break;
|
|
case -1153153640:
|
|
if (attributeName.equals("constraintRotate")) {
|
|
c = 1;
|
|
break;
|
|
}
|
|
c = 65535;
|
|
break;
|
|
case 3355:
|
|
if (attributeName.equals("id")) {
|
|
c = 2;
|
|
break;
|
|
}
|
|
c = 65535;
|
|
break;
|
|
default:
|
|
c = 65535;
|
|
break;
|
|
}
|
|
switch (c) {
|
|
case 0:
|
|
i2 = getId(context, attributeValue);
|
|
break;
|
|
case 1:
|
|
try {
|
|
constraintSet.mRotate = Integer.parseInt(attributeValue);
|
|
break;
|
|
} catch (NumberFormatException unused) {
|
|
attributeValue.hashCode();
|
|
switch (attributeValue.hashCode()) {
|
|
case -768416914:
|
|
if (attributeValue.equals("x_left")) {
|
|
c2 = 0;
|
|
break;
|
|
}
|
|
c2 = 65535;
|
|
break;
|
|
case 3317767:
|
|
if (attributeValue.equals("left")) {
|
|
c2 = 1;
|
|
break;
|
|
}
|
|
c2 = 65535;
|
|
break;
|
|
case 3387192:
|
|
if (attributeValue.equals("none")) {
|
|
c2 = 2;
|
|
break;
|
|
}
|
|
c2 = 65535;
|
|
break;
|
|
case 108511772:
|
|
if (attributeValue.equals("right")) {
|
|
c2 = 3;
|
|
break;
|
|
}
|
|
c2 = 65535;
|
|
break;
|
|
case 1954540437:
|
|
if (attributeValue.equals("x_right")) {
|
|
c2 = 4;
|
|
break;
|
|
}
|
|
c2 = 65535;
|
|
break;
|
|
default:
|
|
c2 = 65535;
|
|
break;
|
|
}
|
|
switch (c2) {
|
|
case 0:
|
|
constraintSet.mRotate = 4;
|
|
break;
|
|
case 1:
|
|
constraintSet.mRotate = 2;
|
|
break;
|
|
case 2:
|
|
constraintSet.mRotate = 0;
|
|
break;
|
|
case 3:
|
|
constraintSet.mRotate = 1;
|
|
break;
|
|
case 4:
|
|
constraintSet.mRotate = 3;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
i = getId(context, attributeValue);
|
|
this.mConstraintSetIdMap.put(stripID(attributeValue), Integer.valueOf(i));
|
|
constraintSet.mIdString = Debug.getName(context, i);
|
|
break;
|
|
}
|
|
}
|
|
if (i != -1) {
|
|
if (this.mMotionLayout.mDebugPath != 0) {
|
|
constraintSet.setValidateOnParse(true);
|
|
}
|
|
constraintSet.load(context, parser);
|
|
if (i2 != -1) {
|
|
this.mDeriveMap.put(i, i2);
|
|
}
|
|
this.mConstraintSetMap.put(i, constraintSet);
|
|
}
|
|
return i;
|
|
}
|
|
|
|
public ConstraintSet getConstraintSet(Context context, String id) {
|
|
if (this.DEBUG_DESKTOP) {
|
|
System.out.println("id " + id);
|
|
System.out.println("size " + this.mConstraintSetMap.size());
|
|
}
|
|
for (int i = 0; i < this.mConstraintSetMap.size(); i++) {
|
|
int keyAt = this.mConstraintSetMap.keyAt(i);
|
|
String resourceName = context.getResources().getResourceName(keyAt);
|
|
if (this.DEBUG_DESKTOP) {
|
|
System.out.println("Id for <" + i + "> is <" + resourceName + "> looking for <" + id + ">");
|
|
}
|
|
if (id.equals(resourceName)) {
|
|
return this.mConstraintSetMap.get(keyAt);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
ConstraintSet getConstraintSet(int id) {
|
|
return getConstraintSet(id, -1, -1);
|
|
}
|
|
|
|
ConstraintSet getConstraintSet(int id, int width, int height) {
|
|
int stateGetConstraintID;
|
|
if (this.DEBUG_DESKTOP) {
|
|
System.out.println("id " + id);
|
|
System.out.println("size " + this.mConstraintSetMap.size());
|
|
}
|
|
StateSet stateSet = this.mStateSet;
|
|
if (stateSet != null && (stateGetConstraintID = stateSet.stateGetConstraintID(id, width, height)) != -1) {
|
|
id = stateGetConstraintID;
|
|
}
|
|
if (this.mConstraintSetMap.get(id) == null) {
|
|
Log.e(TypedValues.MotionScene.NAME, "Warning could not find ConstraintSet id/" + Debug.getName(this.mMotionLayout.getContext(), id) + " In MotionScene");
|
|
SparseArray<ConstraintSet> sparseArray = this.mConstraintSetMap;
|
|
return sparseArray.get(sparseArray.keyAt(0));
|
|
}
|
|
return this.mConstraintSetMap.get(id);
|
|
}
|
|
|
|
public void setConstraintSet(int id, ConstraintSet set) {
|
|
this.mConstraintSetMap.put(id, set);
|
|
}
|
|
|
|
public void getKeyFrames(MotionController motionController) {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition != null) {
|
|
Iterator it = transition.mKeyFramesList.iterator();
|
|
while (it.hasNext()) {
|
|
((KeyFrames) it.next()).addFrames(motionController);
|
|
}
|
|
} else {
|
|
Transition transition2 = this.mDefaultTransition;
|
|
if (transition2 != null) {
|
|
Iterator it2 = transition2.mKeyFramesList.iterator();
|
|
while (it2.hasNext()) {
|
|
((KeyFrames) it2.next()).addFrames(motionController);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Key getKeyFrame(Context context, int type, int target, int position) {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null) {
|
|
return null;
|
|
}
|
|
Iterator it = transition.mKeyFramesList.iterator();
|
|
while (it.hasNext()) {
|
|
KeyFrames keyFrames = (KeyFrames) it.next();
|
|
for (Integer num : keyFrames.getKeys()) {
|
|
if (target == num.intValue()) {
|
|
Iterator<Key> it2 = keyFrames.getKeyFramesForView(num.intValue()).iterator();
|
|
while (it2.hasNext()) {
|
|
Key next = it2.next();
|
|
if (next.mFramePosition == position && next.mType == type) {
|
|
return next;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
int getTransitionDirection(int stateId) {
|
|
Iterator<Transition> it = this.mTransitionList.iterator();
|
|
while (it.hasNext()) {
|
|
if (it.next().mConstraintSetStart == stateId) {
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
boolean hasKeyFramePosition(View view, int position) {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null) {
|
|
return false;
|
|
}
|
|
Iterator it = transition.mKeyFramesList.iterator();
|
|
while (it.hasNext()) {
|
|
Iterator<Key> it2 = ((KeyFrames) it.next()).getKeyFramesForView(view.getId()).iterator();
|
|
while (it2.hasNext()) {
|
|
if (it2.next().mFramePosition == position) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void setKeyframe(View view, int position, String name, Object value) {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null) {
|
|
return;
|
|
}
|
|
Iterator it = transition.mKeyFramesList.iterator();
|
|
while (it.hasNext()) {
|
|
Iterator<Key> it2 = ((KeyFrames) it.next()).getKeyFramesForView(view.getId()).iterator();
|
|
while (it2.hasNext()) {
|
|
if (it2.next().mFramePosition == position) {
|
|
if (value != null) {
|
|
((Float) value).floatValue();
|
|
}
|
|
name.equalsIgnoreCase("app:PerpendicularPath_percent");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
boolean supportTouch() {
|
|
Iterator<Transition> it = this.mTransitionList.iterator();
|
|
while (it.hasNext()) {
|
|
if (it.next().mTouchResponse != null) {
|
|
return true;
|
|
}
|
|
}
|
|
Transition transition = this.mCurrentTransition;
|
|
return (transition == null || transition.mTouchResponse == null) ? false : true;
|
|
}
|
|
|
|
void processTouchEvent(MotionEvent event, int currentState, MotionLayout motionLayout) {
|
|
MotionLayout.MotionTracker motionTracker;
|
|
MotionEvent motionEvent;
|
|
RectF rectF = new RectF();
|
|
if (this.mVelocityTracker == null) {
|
|
this.mVelocityTracker = this.mMotionLayout.obtainVelocityTracker();
|
|
}
|
|
this.mVelocityTracker.addMovement(event);
|
|
if (currentState != -1) {
|
|
int action = event.getAction();
|
|
boolean z = false;
|
|
if (action == 0) {
|
|
this.mLastTouchX = event.getRawX();
|
|
this.mLastTouchY = event.getRawY();
|
|
this.mLastTouchDown = event;
|
|
this.mIgnoreTouch = false;
|
|
if (this.mCurrentTransition.mTouchResponse != null) {
|
|
RectF limitBoundsTo = this.mCurrentTransition.mTouchResponse.getLimitBoundsTo(this.mMotionLayout, rectF);
|
|
if (limitBoundsTo != null && !limitBoundsTo.contains(this.mLastTouchDown.getX(), this.mLastTouchDown.getY())) {
|
|
this.mLastTouchDown = null;
|
|
this.mIgnoreTouch = true;
|
|
return;
|
|
}
|
|
RectF touchRegion = this.mCurrentTransition.mTouchResponse.getTouchRegion(this.mMotionLayout, rectF);
|
|
if (touchRegion == null || touchRegion.contains(this.mLastTouchDown.getX(), this.mLastTouchDown.getY())) {
|
|
this.mMotionOutsideRegion = false;
|
|
} else {
|
|
this.mMotionOutsideRegion = true;
|
|
}
|
|
this.mCurrentTransition.mTouchResponse.setDown(this.mLastTouchX, this.mLastTouchY);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
if (action == 2 && !this.mIgnoreTouch) {
|
|
float rawY = event.getRawY() - this.mLastTouchY;
|
|
float rawX = event.getRawX() - this.mLastTouchX;
|
|
if ((rawX == 0.0d && rawY == 0.0d) || (motionEvent = this.mLastTouchDown) == null) {
|
|
return;
|
|
}
|
|
Transition bestTransitionFor = bestTransitionFor(currentState, rawX, rawY, motionEvent);
|
|
if (bestTransitionFor != null) {
|
|
motionLayout.setTransition(bestTransitionFor);
|
|
RectF touchRegion2 = this.mCurrentTransition.mTouchResponse.getTouchRegion(this.mMotionLayout, rectF);
|
|
if (touchRegion2 != null && !touchRegion2.contains(this.mLastTouchDown.getX(), this.mLastTouchDown.getY())) {
|
|
z = true;
|
|
}
|
|
this.mMotionOutsideRegion = z;
|
|
this.mCurrentTransition.mTouchResponse.setUpTouchEvent(this.mLastTouchX, this.mLastTouchY);
|
|
}
|
|
}
|
|
}
|
|
if (this.mIgnoreTouch) {
|
|
return;
|
|
}
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition != null && transition.mTouchResponse != null && !this.mMotionOutsideRegion) {
|
|
this.mCurrentTransition.mTouchResponse.processTouchEvent(event, this.mVelocityTracker, currentState, this);
|
|
}
|
|
this.mLastTouchX = event.getRawX();
|
|
this.mLastTouchY = event.getRawY();
|
|
if (event.getAction() != 1 || (motionTracker = this.mVelocityTracker) == null) {
|
|
return;
|
|
}
|
|
motionTracker.recycle();
|
|
this.mVelocityTracker = null;
|
|
if (motionLayout.mCurrentState != -1) {
|
|
autoTransition(motionLayout, motionLayout.mCurrentState);
|
|
}
|
|
}
|
|
|
|
void processScrollMove(float dx, float dy) {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null || transition.mTouchResponse == null) {
|
|
return;
|
|
}
|
|
this.mCurrentTransition.mTouchResponse.scrollMove(dx, dy);
|
|
}
|
|
|
|
void processScrollUp(float dx, float dy) {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null || transition.mTouchResponse == null) {
|
|
return;
|
|
}
|
|
this.mCurrentTransition.mTouchResponse.scrollUp(dx, dy);
|
|
}
|
|
|
|
float getProgressDirection(float dx, float dy) {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null || transition.mTouchResponse == null) {
|
|
return 0.0f;
|
|
}
|
|
return this.mCurrentTransition.mTouchResponse.getProgressDirection(dx, dy);
|
|
}
|
|
|
|
int getStartId() {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null) {
|
|
return -1;
|
|
}
|
|
return transition.mConstraintSetStart;
|
|
}
|
|
|
|
int getEndId() {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null) {
|
|
return -1;
|
|
}
|
|
return transition.mConstraintSetEnd;
|
|
}
|
|
|
|
public Interpolator getInterpolator() {
|
|
int i = this.mCurrentTransition.mDefaultInterpolator;
|
|
if (i == -2) {
|
|
return AnimationUtils.loadInterpolator(this.mMotionLayout.getContext(), this.mCurrentTransition.mDefaultInterpolatorID);
|
|
}
|
|
if (i == -1) {
|
|
final Easing interpolator = Easing.getInterpolator(this.mCurrentTransition.mDefaultInterpolatorString);
|
|
return new Interpolator(this) { // from class: androidx.constraintlayout.motion.widget.MotionScene.1
|
|
@Override // android.animation.TimeInterpolator
|
|
public float getInterpolation(float v) {
|
|
return (float) interpolator.get(v);
|
|
}
|
|
};
|
|
}
|
|
if (i == 0) {
|
|
return new AccelerateDecelerateInterpolator();
|
|
}
|
|
if (i == 1) {
|
|
return new AccelerateInterpolator();
|
|
}
|
|
if (i == 2) {
|
|
return new DecelerateInterpolator();
|
|
}
|
|
if (i == 4) {
|
|
return new BounceInterpolator();
|
|
}
|
|
if (i == 5) {
|
|
return new OvershootInterpolator();
|
|
}
|
|
if (i != 6) {
|
|
return null;
|
|
}
|
|
return new AnticipateInterpolator();
|
|
}
|
|
|
|
public int getDuration() {
|
|
Transition transition = this.mCurrentTransition;
|
|
return transition != null ? transition.mDuration : this.mDefaultDuration;
|
|
}
|
|
|
|
public void setDuration(int duration) {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition != null) {
|
|
transition.setDuration(duration);
|
|
} else {
|
|
this.mDefaultDuration = duration;
|
|
}
|
|
}
|
|
|
|
public int gatPathMotionArc() {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition != null) {
|
|
return transition.mPathMotionArc;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public float getStaggered() {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition != null) {
|
|
return transition.mStagger;
|
|
}
|
|
return 0.0f;
|
|
}
|
|
|
|
float getMaxAcceleration() {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null || transition.mTouchResponse == null) {
|
|
return 0.0f;
|
|
}
|
|
return this.mCurrentTransition.mTouchResponse.getMaxAcceleration();
|
|
}
|
|
|
|
float getMaxVelocity() {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null || transition.mTouchResponse == null) {
|
|
return 0.0f;
|
|
}
|
|
return this.mCurrentTransition.mTouchResponse.getMaxVelocity();
|
|
}
|
|
|
|
float getSpringStiffiness() {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null || transition.mTouchResponse == null) {
|
|
return 0.0f;
|
|
}
|
|
return this.mCurrentTransition.mTouchResponse.getSpringStiffness();
|
|
}
|
|
|
|
float getSpringMass() {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null || transition.mTouchResponse == null) {
|
|
return 0.0f;
|
|
}
|
|
return this.mCurrentTransition.mTouchResponse.getSpringMass();
|
|
}
|
|
|
|
float getSpringDamping() {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null || transition.mTouchResponse == null) {
|
|
return 0.0f;
|
|
}
|
|
return this.mCurrentTransition.mTouchResponse.getSpringDamping();
|
|
}
|
|
|
|
float getSpringStopThreshold() {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null || transition.mTouchResponse == null) {
|
|
return 0.0f;
|
|
}
|
|
return this.mCurrentTransition.mTouchResponse.getSpringStopThreshold();
|
|
}
|
|
|
|
int getSpringBoundary() {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null || transition.mTouchResponse == null) {
|
|
return 0;
|
|
}
|
|
return this.mCurrentTransition.mTouchResponse.getSpringBoundary();
|
|
}
|
|
|
|
int getAutoCompleteMode() {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null || transition.mTouchResponse == null) {
|
|
return 0;
|
|
}
|
|
return this.mCurrentTransition.mTouchResponse.getAutoCompleteMode();
|
|
}
|
|
|
|
void setupTouch() {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null || transition.mTouchResponse == null) {
|
|
return;
|
|
}
|
|
this.mCurrentTransition.mTouchResponse.setupTouch();
|
|
}
|
|
|
|
boolean getMoveWhenScrollAtTop() {
|
|
Transition transition = this.mCurrentTransition;
|
|
if (transition == null || transition.mTouchResponse == null) {
|
|
return false;
|
|
}
|
|
return this.mCurrentTransition.mTouchResponse.getMoveWhenScrollAtTop();
|
|
}
|
|
|
|
void readFallback(MotionLayout motionLayout) {
|
|
for (int i = 0; i < this.mConstraintSetMap.size(); i++) {
|
|
int keyAt = this.mConstraintSetMap.keyAt(i);
|
|
if (hasCycleDependency(keyAt)) {
|
|
Log.e(TypedValues.MotionScene.NAME, "Cannot be derived from yourself");
|
|
return;
|
|
}
|
|
readConstraintChain(keyAt, motionLayout);
|
|
}
|
|
}
|
|
|
|
private boolean hasCycleDependency(int key) {
|
|
int i = this.mDeriveMap.get(key);
|
|
int size = this.mDeriveMap.size();
|
|
while (i > 0) {
|
|
if (i == key) {
|
|
return true;
|
|
}
|
|
int i2 = size - 1;
|
|
if (size < 0) {
|
|
return true;
|
|
}
|
|
i = this.mDeriveMap.get(i);
|
|
size = i2;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void readConstraintChain(int key, MotionLayout motionLayout) {
|
|
ConstraintSet constraintSet = this.mConstraintSetMap.get(key);
|
|
constraintSet.derivedState = constraintSet.mIdString;
|
|
int i = this.mDeriveMap.get(key);
|
|
if (i > 0) {
|
|
readConstraintChain(i, motionLayout);
|
|
ConstraintSet constraintSet2 = this.mConstraintSetMap.get(i);
|
|
if (constraintSet2 == null) {
|
|
Log.e(TypedValues.MotionScene.NAME, "ERROR! invalid deriveConstraintsFrom: @id/" + Debug.getName(this.mMotionLayout.getContext(), i));
|
|
return;
|
|
} else {
|
|
constraintSet.derivedState += "/" + constraintSet2.derivedState;
|
|
constraintSet.readFallback(constraintSet2);
|
|
}
|
|
} else {
|
|
constraintSet.derivedState += " layout";
|
|
constraintSet.readFallback(motionLayout);
|
|
}
|
|
constraintSet.applyDeltaFrom(constraintSet);
|
|
}
|
|
|
|
public static String stripID(String id) {
|
|
if (id == null) {
|
|
return "";
|
|
}
|
|
int indexOf = id.indexOf(47);
|
|
return indexOf < 0 ? id : id.substring(indexOf + 1);
|
|
}
|
|
|
|
public int lookUpConstraintId(String id) {
|
|
Integer num = this.mConstraintSetIdMap.get(id);
|
|
if (num == null) {
|
|
return 0;
|
|
}
|
|
return num.intValue();
|
|
}
|
|
|
|
public String lookUpConstraintName(int id) {
|
|
for (Map.Entry<String, Integer> entry : this.mConstraintSetIdMap.entrySet()) {
|
|
Integer value = entry.getValue();
|
|
if (value != null && value.intValue() == id) {
|
|
return entry.getKey();
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static String getLine(Context context, int resourceId, XmlPullParser pullParser) {
|
|
return ".(" + Debug.getName(context, resourceId) + ".xml:" + pullParser.getLineNumber() + ") \"" + pullParser.getName() + "\"";
|
|
}
|
|
}
|