827 lines
29 KiB
Java
827 lines
29 KiB
Java
package androidx.constraintlayout.motion.widget;
|
|
|
|
import android.content.Context;
|
|
import android.content.res.TypedArray;
|
|
import android.util.AttributeSet;
|
|
import android.util.Log;
|
|
import android.util.SparseIntArray;
|
|
import androidx.constraintlayout.widget.ConstraintAttribute;
|
|
import androidx.constraintlayout.widget.R;
|
|
import c.d.b.a.a;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
public class KeyCycle extends Key {
|
|
public static final int KEY_TYPE = 4;
|
|
public static final String NAME = "KeyCycle";
|
|
private static final String TAG = "KeyCycle";
|
|
private float mAlpha = Float.NaN;
|
|
private int mCurveFit = 0;
|
|
private float mElevation = Float.NaN;
|
|
private float mProgress = Float.NaN;
|
|
private float mRotation = Float.NaN;
|
|
private float mRotationX = Float.NaN;
|
|
private float mRotationY = Float.NaN;
|
|
private float mScaleX = Float.NaN;
|
|
private float mScaleY = Float.NaN;
|
|
private String mTransitionEasing = null;
|
|
private float mTransitionPathRotate = Float.NaN;
|
|
private float mTranslationX = Float.NaN;
|
|
private float mTranslationY = Float.NaN;
|
|
private float mTranslationZ = Float.NaN;
|
|
private float mWaveOffset = 0.0f;
|
|
private float mWavePeriod = Float.NaN;
|
|
private int mWaveShape = -1;
|
|
private int mWaveVariesBy = -1;
|
|
|
|
public static class Loader {
|
|
private static final int ANDROID_ALPHA = 9;
|
|
private static final int ANDROID_ELEVATION = 10;
|
|
private static final int ANDROID_ROTATION = 11;
|
|
private static final int ANDROID_ROTATION_X = 12;
|
|
private static final int ANDROID_ROTATION_Y = 13;
|
|
private static final int ANDROID_SCALE_X = 15;
|
|
private static final int ANDROID_SCALE_Y = 16;
|
|
private static final int ANDROID_TRANSLATION_X = 17;
|
|
private static final int ANDROID_TRANSLATION_Y = 18;
|
|
private static final int ANDROID_TRANSLATION_Z = 19;
|
|
private static final int CURVE_FIT = 4;
|
|
private static final int FRAME_POSITION = 2;
|
|
private static final int PROGRESS = 20;
|
|
private static final int TARGET_ID = 1;
|
|
private static final int TRANSITION_EASING = 3;
|
|
private static final int TRANSITION_PATH_ROTATE = 14;
|
|
private static final int WAVE_OFFSET = 7;
|
|
private static final int WAVE_PERIOD = 6;
|
|
private static final int WAVE_SHAPE = 5;
|
|
private static final int WAVE_VARIES_BY = 8;
|
|
private static SparseIntArray mAttrMap;
|
|
|
|
static {
|
|
SparseIntArray sparseIntArray = new SparseIntArray();
|
|
mAttrMap = sparseIntArray;
|
|
sparseIntArray.append(R.styleable.KeyCycle_motionTarget, 1);
|
|
mAttrMap.append(R.styleable.KeyCycle_framePosition, 2);
|
|
mAttrMap.append(R.styleable.KeyCycle_transitionEasing, 3);
|
|
mAttrMap.append(R.styleable.KeyCycle_curveFit, 4);
|
|
mAttrMap.append(R.styleable.KeyCycle_waveShape, 5);
|
|
mAttrMap.append(R.styleable.KeyCycle_wavePeriod, 6);
|
|
mAttrMap.append(R.styleable.KeyCycle_waveOffset, 7);
|
|
mAttrMap.append(R.styleable.KeyCycle_waveVariesBy, 8);
|
|
mAttrMap.append(R.styleable.KeyCycle_android_alpha, 9);
|
|
mAttrMap.append(R.styleable.KeyCycle_android_elevation, 10);
|
|
mAttrMap.append(R.styleable.KeyCycle_android_rotation, 11);
|
|
mAttrMap.append(R.styleable.KeyCycle_android_rotationX, 12);
|
|
mAttrMap.append(R.styleable.KeyCycle_android_rotationY, 13);
|
|
mAttrMap.append(R.styleable.KeyCycle_transitionPathRotate, 14);
|
|
mAttrMap.append(R.styleable.KeyCycle_android_scaleX, 15);
|
|
mAttrMap.append(R.styleable.KeyCycle_android_scaleY, 16);
|
|
mAttrMap.append(R.styleable.KeyCycle_android_translationX, 17);
|
|
mAttrMap.append(R.styleable.KeyCycle_android_translationY, 18);
|
|
mAttrMap.append(R.styleable.KeyCycle_android_translationZ, 19);
|
|
mAttrMap.append(R.styleable.KeyCycle_motionProgress, 20);
|
|
}
|
|
|
|
private Loader() {
|
|
}
|
|
|
|
public static /* synthetic */ void access$000(KeyCycle keyCycle, TypedArray typedArray) {
|
|
read(keyCycle, typedArray);
|
|
}
|
|
|
|
private static void read(KeyCycle keyCycle, TypedArray typedArray) {
|
|
int indexCount = typedArray.getIndexCount();
|
|
for (int i = 0; i < indexCount; i++) {
|
|
int index = typedArray.getIndex(i);
|
|
switch (mAttrMap.get(index)) {
|
|
case 1:
|
|
if (!MotionLayout.IS_IN_EDIT_MODE) {
|
|
if (typedArray.peekValue(index).type == 3) {
|
|
keyCycle.mTargetString = typedArray.getString(index);
|
|
break;
|
|
} else {
|
|
keyCycle.mTargetId = typedArray.getResourceId(index, keyCycle.mTargetId);
|
|
break;
|
|
}
|
|
} else {
|
|
int resourceId = typedArray.getResourceId(index, keyCycle.mTargetId);
|
|
keyCycle.mTargetId = resourceId;
|
|
if (resourceId == -1) {
|
|
keyCycle.mTargetString = typedArray.getString(index);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
case 2:
|
|
keyCycle.mFramePosition = typedArray.getInt(index, keyCycle.mFramePosition);
|
|
break;
|
|
case 3:
|
|
KeyCycle.access$102(keyCycle, typedArray.getString(index));
|
|
break;
|
|
case 4:
|
|
KeyCycle.access$202(keyCycle, typedArray.getInteger(index, KeyCycle.access$200(keyCycle)));
|
|
break;
|
|
case 5:
|
|
KeyCycle.access$302(keyCycle, typedArray.getInt(index, KeyCycle.access$300(keyCycle)));
|
|
break;
|
|
case 6:
|
|
KeyCycle.access$402(keyCycle, typedArray.getFloat(index, KeyCycle.access$400(keyCycle)));
|
|
break;
|
|
case 7:
|
|
if (typedArray.peekValue(index).type == 5) {
|
|
KeyCycle.access$502(keyCycle, typedArray.getDimension(index, KeyCycle.access$500(keyCycle)));
|
|
break;
|
|
} else {
|
|
KeyCycle.access$502(keyCycle, typedArray.getFloat(index, KeyCycle.access$500(keyCycle)));
|
|
break;
|
|
}
|
|
case 8:
|
|
KeyCycle.access$602(keyCycle, typedArray.getInt(index, KeyCycle.access$600(keyCycle)));
|
|
break;
|
|
case 9:
|
|
KeyCycle.access$702(keyCycle, typedArray.getFloat(index, KeyCycle.access$700(keyCycle)));
|
|
break;
|
|
case 10:
|
|
KeyCycle.access$802(keyCycle, typedArray.getDimension(index, KeyCycle.access$800(keyCycle)));
|
|
break;
|
|
case 11:
|
|
KeyCycle.access$902(keyCycle, typedArray.getFloat(index, KeyCycle.access$900(keyCycle)));
|
|
break;
|
|
case 12:
|
|
KeyCycle.access$1002(keyCycle, typedArray.getFloat(index, KeyCycle.access$1000(keyCycle)));
|
|
break;
|
|
case 13:
|
|
KeyCycle.access$1102(keyCycle, typedArray.getFloat(index, KeyCycle.access$1100(keyCycle)));
|
|
break;
|
|
case 14:
|
|
KeyCycle.access$1202(keyCycle, typedArray.getFloat(index, KeyCycle.access$1200(keyCycle)));
|
|
break;
|
|
case 15:
|
|
KeyCycle.access$1302(keyCycle, typedArray.getFloat(index, KeyCycle.access$1300(keyCycle)));
|
|
break;
|
|
case 16:
|
|
KeyCycle.access$1402(keyCycle, typedArray.getFloat(index, KeyCycle.access$1400(keyCycle)));
|
|
break;
|
|
case 17:
|
|
KeyCycle.access$1502(keyCycle, typedArray.getDimension(index, KeyCycle.access$1500(keyCycle)));
|
|
break;
|
|
case 18:
|
|
KeyCycle.access$1602(keyCycle, typedArray.getDimension(index, KeyCycle.access$1600(keyCycle)));
|
|
break;
|
|
case 19:
|
|
KeyCycle.access$1702(keyCycle, typedArray.getDimension(index, KeyCycle.access$1700(keyCycle)));
|
|
break;
|
|
case 20:
|
|
KeyCycle.access$1802(keyCycle, typedArray.getFloat(index, KeyCycle.access$1800(keyCycle)));
|
|
break;
|
|
default:
|
|
StringBuilder L = a.L("unused attribute 0x");
|
|
L.append(Integer.toHexString(index));
|
|
L.append(" ");
|
|
L.append(mAttrMap.get(index));
|
|
Log.e("KeyCycle", L.toString());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public KeyCycle() {
|
|
this.mType = 4;
|
|
this.mCustomConstraints = new HashMap<>();
|
|
}
|
|
|
|
public static /* synthetic */ float access$1000(KeyCycle keyCycle) {
|
|
return keyCycle.mRotationX;
|
|
}
|
|
|
|
public static /* synthetic */ float access$1002(KeyCycle keyCycle, float f) {
|
|
keyCycle.mRotationX = f;
|
|
return f;
|
|
}
|
|
|
|
public static /* synthetic */ String access$102(KeyCycle keyCycle, String str) {
|
|
keyCycle.mTransitionEasing = str;
|
|
return str;
|
|
}
|
|
|
|
public static /* synthetic */ float access$1100(KeyCycle keyCycle) {
|
|
return keyCycle.mRotationY;
|
|
}
|
|
|
|
public static /* synthetic */ float access$1102(KeyCycle keyCycle, float f) {
|
|
keyCycle.mRotationY = f;
|
|
return f;
|
|
}
|
|
|
|
public static /* synthetic */ float access$1200(KeyCycle keyCycle) {
|
|
return keyCycle.mTransitionPathRotate;
|
|
}
|
|
|
|
public static /* synthetic */ float access$1202(KeyCycle keyCycle, float f) {
|
|
keyCycle.mTransitionPathRotate = f;
|
|
return f;
|
|
}
|
|
|
|
public static /* synthetic */ float access$1300(KeyCycle keyCycle) {
|
|
return keyCycle.mScaleX;
|
|
}
|
|
|
|
public static /* synthetic */ float access$1302(KeyCycle keyCycle, float f) {
|
|
keyCycle.mScaleX = f;
|
|
return f;
|
|
}
|
|
|
|
public static /* synthetic */ float access$1400(KeyCycle keyCycle) {
|
|
return keyCycle.mScaleY;
|
|
}
|
|
|
|
public static /* synthetic */ float access$1402(KeyCycle keyCycle, float f) {
|
|
keyCycle.mScaleY = f;
|
|
return f;
|
|
}
|
|
|
|
public static /* synthetic */ float access$1500(KeyCycle keyCycle) {
|
|
return keyCycle.mTranslationX;
|
|
}
|
|
|
|
public static /* synthetic */ float access$1502(KeyCycle keyCycle, float f) {
|
|
keyCycle.mTranslationX = f;
|
|
return f;
|
|
}
|
|
|
|
public static /* synthetic */ float access$1600(KeyCycle keyCycle) {
|
|
return keyCycle.mTranslationY;
|
|
}
|
|
|
|
public static /* synthetic */ float access$1602(KeyCycle keyCycle, float f) {
|
|
keyCycle.mTranslationY = f;
|
|
return f;
|
|
}
|
|
|
|
public static /* synthetic */ float access$1700(KeyCycle keyCycle) {
|
|
return keyCycle.mTranslationZ;
|
|
}
|
|
|
|
public static /* synthetic */ float access$1702(KeyCycle keyCycle, float f) {
|
|
keyCycle.mTranslationZ = f;
|
|
return f;
|
|
}
|
|
|
|
public static /* synthetic */ float access$1800(KeyCycle keyCycle) {
|
|
return keyCycle.mProgress;
|
|
}
|
|
|
|
public static /* synthetic */ float access$1802(KeyCycle keyCycle, float f) {
|
|
keyCycle.mProgress = f;
|
|
return f;
|
|
}
|
|
|
|
public static /* synthetic */ int access$200(KeyCycle keyCycle) {
|
|
return keyCycle.mCurveFit;
|
|
}
|
|
|
|
public static /* synthetic */ int access$202(KeyCycle keyCycle, int i) {
|
|
keyCycle.mCurveFit = i;
|
|
return i;
|
|
}
|
|
|
|
public static /* synthetic */ int access$300(KeyCycle keyCycle) {
|
|
return keyCycle.mWaveShape;
|
|
}
|
|
|
|
public static /* synthetic */ int access$302(KeyCycle keyCycle, int i) {
|
|
keyCycle.mWaveShape = i;
|
|
return i;
|
|
}
|
|
|
|
public static /* synthetic */ float access$400(KeyCycle keyCycle) {
|
|
return keyCycle.mWavePeriod;
|
|
}
|
|
|
|
public static /* synthetic */ float access$402(KeyCycle keyCycle, float f) {
|
|
keyCycle.mWavePeriod = f;
|
|
return f;
|
|
}
|
|
|
|
public static /* synthetic */ float access$500(KeyCycle keyCycle) {
|
|
return keyCycle.mWaveOffset;
|
|
}
|
|
|
|
public static /* synthetic */ float access$502(KeyCycle keyCycle, float f) {
|
|
keyCycle.mWaveOffset = f;
|
|
return f;
|
|
}
|
|
|
|
public static /* synthetic */ int access$600(KeyCycle keyCycle) {
|
|
return keyCycle.mWaveVariesBy;
|
|
}
|
|
|
|
public static /* synthetic */ int access$602(KeyCycle keyCycle, int i) {
|
|
keyCycle.mWaveVariesBy = i;
|
|
return i;
|
|
}
|
|
|
|
public static /* synthetic */ float access$700(KeyCycle keyCycle) {
|
|
return keyCycle.mAlpha;
|
|
}
|
|
|
|
public static /* synthetic */ float access$702(KeyCycle keyCycle, float f) {
|
|
keyCycle.mAlpha = f;
|
|
return f;
|
|
}
|
|
|
|
public static /* synthetic */ float access$800(KeyCycle keyCycle) {
|
|
return keyCycle.mElevation;
|
|
}
|
|
|
|
public static /* synthetic */ float access$802(KeyCycle keyCycle, float f) {
|
|
keyCycle.mElevation = f;
|
|
return f;
|
|
}
|
|
|
|
public static /* synthetic */ float access$900(KeyCycle keyCycle) {
|
|
return keyCycle.mRotation;
|
|
}
|
|
|
|
public static /* synthetic */ float access$902(KeyCycle keyCycle, float f) {
|
|
keyCycle.mRotation = f;
|
|
return f;
|
|
}
|
|
|
|
public void addCycleValues(HashMap<String, KeyCycleOscillator> hashMap) {
|
|
for (String str : hashMap.keySet()) {
|
|
if (str.startsWith(Key.CUSTOM)) {
|
|
ConstraintAttribute constraintAttribute = this.mCustomConstraints.get(str.substring(7));
|
|
if (constraintAttribute != null && constraintAttribute.getType() == ConstraintAttribute.AttributeType.FLOAT_TYPE) {
|
|
hashMap.get(str).setPoint(this.mFramePosition, this.mWaveShape, this.mWaveVariesBy, this.mWavePeriod, this.mWaveOffset, constraintAttribute.getValueToInterpolate(), constraintAttribute);
|
|
}
|
|
} else {
|
|
float value = getValue(str);
|
|
if (!Float.isNaN(value)) {
|
|
hashMap.get(str).setPoint(this.mFramePosition, this.mWaveShape, this.mWaveVariesBy, this.mWavePeriod, this.mWaveOffset, value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // androidx.constraintlayout.motion.widget.Key
|
|
public void addValues(HashMap<String, SplineSet> hashMap) {
|
|
StringBuilder L = a.L("add ");
|
|
L.append(hashMap.size());
|
|
L.append(" values");
|
|
Debug.logStack("KeyCycle", L.toString(), 2);
|
|
for (String str : hashMap.keySet()) {
|
|
SplineSet splineSet = hashMap.get(str);
|
|
str.hashCode();
|
|
str.hashCode();
|
|
char c2 = 65535;
|
|
switch (str.hashCode()) {
|
|
case -1249320806:
|
|
if (str.equals(Key.ROTATION_X)) {
|
|
c2 = 0;
|
|
break;
|
|
}
|
|
break;
|
|
case -1249320805:
|
|
if (str.equals(Key.ROTATION_Y)) {
|
|
c2 = 1;
|
|
break;
|
|
}
|
|
break;
|
|
case -1225497657:
|
|
if (str.equals(Key.TRANSLATION_X)) {
|
|
c2 = 2;
|
|
break;
|
|
}
|
|
break;
|
|
case -1225497656:
|
|
if (str.equals(Key.TRANSLATION_Y)) {
|
|
c2 = 3;
|
|
break;
|
|
}
|
|
break;
|
|
case -1225497655:
|
|
if (str.equals(Key.TRANSLATION_Z)) {
|
|
c2 = 4;
|
|
break;
|
|
}
|
|
break;
|
|
case -1001078227:
|
|
if (str.equals("progress")) {
|
|
c2 = 5;
|
|
break;
|
|
}
|
|
break;
|
|
case -908189618:
|
|
if (str.equals(Key.SCALE_X)) {
|
|
c2 = 6;
|
|
break;
|
|
}
|
|
break;
|
|
case -908189617:
|
|
if (str.equals(Key.SCALE_Y)) {
|
|
c2 = 7;
|
|
break;
|
|
}
|
|
break;
|
|
case -40300674:
|
|
if (str.equals(Key.ROTATION)) {
|
|
c2 = '\b';
|
|
break;
|
|
}
|
|
break;
|
|
case -4379043:
|
|
if (str.equals(Key.ELEVATION)) {
|
|
c2 = '\t';
|
|
break;
|
|
}
|
|
break;
|
|
case 37232917:
|
|
if (str.equals(Key.TRANSITION_PATH_ROTATE)) {
|
|
c2 = '\n';
|
|
break;
|
|
}
|
|
break;
|
|
case 92909918:
|
|
if (str.equals(Key.ALPHA)) {
|
|
c2 = 11;
|
|
break;
|
|
}
|
|
break;
|
|
case 156108012:
|
|
if (str.equals(Key.WAVE_OFFSET)) {
|
|
c2 = '\f';
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
switch (c2) {
|
|
case 0:
|
|
splineSet.setPoint(this.mFramePosition, this.mRotationX);
|
|
break;
|
|
case 1:
|
|
splineSet.setPoint(this.mFramePosition, this.mRotationY);
|
|
break;
|
|
case 2:
|
|
splineSet.setPoint(this.mFramePosition, this.mTranslationX);
|
|
break;
|
|
case 3:
|
|
splineSet.setPoint(this.mFramePosition, this.mTranslationY);
|
|
break;
|
|
case 4:
|
|
splineSet.setPoint(this.mFramePosition, this.mTranslationZ);
|
|
break;
|
|
case 5:
|
|
splineSet.setPoint(this.mFramePosition, this.mProgress);
|
|
break;
|
|
case 6:
|
|
splineSet.setPoint(this.mFramePosition, this.mScaleX);
|
|
break;
|
|
case 7:
|
|
splineSet.setPoint(this.mFramePosition, this.mScaleY);
|
|
break;
|
|
case '\b':
|
|
splineSet.setPoint(this.mFramePosition, this.mRotation);
|
|
break;
|
|
case '\t':
|
|
splineSet.setPoint(this.mFramePosition, this.mElevation);
|
|
break;
|
|
case '\n':
|
|
splineSet.setPoint(this.mFramePosition, this.mTransitionPathRotate);
|
|
break;
|
|
case 11:
|
|
splineSet.setPoint(this.mFramePosition, this.mAlpha);
|
|
break;
|
|
case '\f':
|
|
splineSet.setPoint(this.mFramePosition, this.mWaveOffset);
|
|
break;
|
|
default:
|
|
Log.v("KeyCycle", "WARNING KeyCycle UNKNOWN " + str);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // androidx.constraintlayout.motion.widget.Key
|
|
public void getAttributeNames(HashSet<String> hashSet) {
|
|
if (!Float.isNaN(this.mAlpha)) {
|
|
hashSet.add(Key.ALPHA);
|
|
}
|
|
if (!Float.isNaN(this.mElevation)) {
|
|
hashSet.add(Key.ELEVATION);
|
|
}
|
|
if (!Float.isNaN(this.mRotation)) {
|
|
hashSet.add(Key.ROTATION);
|
|
}
|
|
if (!Float.isNaN(this.mRotationX)) {
|
|
hashSet.add(Key.ROTATION_X);
|
|
}
|
|
if (!Float.isNaN(this.mRotationY)) {
|
|
hashSet.add(Key.ROTATION_Y);
|
|
}
|
|
if (!Float.isNaN(this.mScaleX)) {
|
|
hashSet.add(Key.SCALE_X);
|
|
}
|
|
if (!Float.isNaN(this.mScaleY)) {
|
|
hashSet.add(Key.SCALE_Y);
|
|
}
|
|
if (!Float.isNaN(this.mTransitionPathRotate)) {
|
|
hashSet.add(Key.TRANSITION_PATH_ROTATE);
|
|
}
|
|
if (!Float.isNaN(this.mTranslationX)) {
|
|
hashSet.add(Key.TRANSLATION_X);
|
|
}
|
|
if (!Float.isNaN(this.mTranslationY)) {
|
|
hashSet.add(Key.TRANSLATION_Y);
|
|
}
|
|
if (!Float.isNaN(this.mTranslationZ)) {
|
|
hashSet.add(Key.TRANSLATION_Z);
|
|
}
|
|
if (this.mCustomConstraints.size() > 0) {
|
|
Iterator<String> it = this.mCustomConstraints.keySet().iterator();
|
|
while (it.hasNext()) {
|
|
hashSet.add("CUSTOM," + it.next());
|
|
}
|
|
}
|
|
}
|
|
|
|
public float getValue(String str) {
|
|
str.hashCode();
|
|
char c2 = 65535;
|
|
switch (str.hashCode()) {
|
|
case -1249320806:
|
|
if (str.equals(Key.ROTATION_X)) {
|
|
c2 = 0;
|
|
break;
|
|
}
|
|
break;
|
|
case -1249320805:
|
|
if (str.equals(Key.ROTATION_Y)) {
|
|
c2 = 1;
|
|
break;
|
|
}
|
|
break;
|
|
case -1225497657:
|
|
if (str.equals(Key.TRANSLATION_X)) {
|
|
c2 = 2;
|
|
break;
|
|
}
|
|
break;
|
|
case -1225497656:
|
|
if (str.equals(Key.TRANSLATION_Y)) {
|
|
c2 = 3;
|
|
break;
|
|
}
|
|
break;
|
|
case -1225497655:
|
|
if (str.equals(Key.TRANSLATION_Z)) {
|
|
c2 = 4;
|
|
break;
|
|
}
|
|
break;
|
|
case -1001078227:
|
|
if (str.equals("progress")) {
|
|
c2 = 5;
|
|
break;
|
|
}
|
|
break;
|
|
case -908189618:
|
|
if (str.equals(Key.SCALE_X)) {
|
|
c2 = 6;
|
|
break;
|
|
}
|
|
break;
|
|
case -908189617:
|
|
if (str.equals(Key.SCALE_Y)) {
|
|
c2 = 7;
|
|
break;
|
|
}
|
|
break;
|
|
case -40300674:
|
|
if (str.equals(Key.ROTATION)) {
|
|
c2 = '\b';
|
|
break;
|
|
}
|
|
break;
|
|
case -4379043:
|
|
if (str.equals(Key.ELEVATION)) {
|
|
c2 = '\t';
|
|
break;
|
|
}
|
|
break;
|
|
case 37232917:
|
|
if (str.equals(Key.TRANSITION_PATH_ROTATE)) {
|
|
c2 = '\n';
|
|
break;
|
|
}
|
|
break;
|
|
case 92909918:
|
|
if (str.equals(Key.ALPHA)) {
|
|
c2 = 11;
|
|
break;
|
|
}
|
|
break;
|
|
case 156108012:
|
|
if (str.equals(Key.WAVE_OFFSET)) {
|
|
c2 = '\f';
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
switch (c2) {
|
|
case 0:
|
|
return this.mRotationX;
|
|
case 1:
|
|
return this.mRotationY;
|
|
case 2:
|
|
return this.mTranslationX;
|
|
case 3:
|
|
return this.mTranslationY;
|
|
case 4:
|
|
return this.mTranslationZ;
|
|
case 5:
|
|
return this.mProgress;
|
|
case 6:
|
|
return this.mScaleX;
|
|
case 7:
|
|
return this.mScaleY;
|
|
case '\b':
|
|
return this.mRotation;
|
|
case '\t':
|
|
return this.mElevation;
|
|
case '\n':
|
|
return this.mTransitionPathRotate;
|
|
case 11:
|
|
return this.mAlpha;
|
|
case '\f':
|
|
return this.mWaveOffset;
|
|
default:
|
|
Log.v("KeyCycle", "WARNING! KeyCycle UNKNOWN " + str);
|
|
return Float.NaN;
|
|
}
|
|
}
|
|
|
|
@Override // androidx.constraintlayout.motion.widget.Key
|
|
public void load(Context context, AttributeSet attributeSet) {
|
|
Loader.access$000(this, context.obtainStyledAttributes(attributeSet, R.styleable.KeyCycle));
|
|
}
|
|
|
|
@Override // androidx.constraintlayout.motion.widget.Key
|
|
public void setValue(String str, Object obj) {
|
|
str.hashCode();
|
|
char c2 = 65535;
|
|
switch (str.hashCode()) {
|
|
case -1812823328:
|
|
if (str.equals("transitionEasing")) {
|
|
c2 = 0;
|
|
break;
|
|
}
|
|
break;
|
|
case -1249320806:
|
|
if (str.equals(Key.ROTATION_X)) {
|
|
c2 = 1;
|
|
break;
|
|
}
|
|
break;
|
|
case -1249320805:
|
|
if (str.equals(Key.ROTATION_Y)) {
|
|
c2 = 2;
|
|
break;
|
|
}
|
|
break;
|
|
case -1225497657:
|
|
if (str.equals(Key.TRANSLATION_X)) {
|
|
c2 = 3;
|
|
break;
|
|
}
|
|
break;
|
|
case -1225497656:
|
|
if (str.equals(Key.TRANSLATION_Y)) {
|
|
c2 = 4;
|
|
break;
|
|
}
|
|
break;
|
|
case -1001078227:
|
|
if (str.equals("progress")) {
|
|
c2 = 5;
|
|
break;
|
|
}
|
|
break;
|
|
case -908189618:
|
|
if (str.equals(Key.SCALE_X)) {
|
|
c2 = 6;
|
|
break;
|
|
}
|
|
break;
|
|
case -908189617:
|
|
if (str.equals(Key.SCALE_Y)) {
|
|
c2 = 7;
|
|
break;
|
|
}
|
|
break;
|
|
case -40300674:
|
|
if (str.equals(Key.ROTATION)) {
|
|
c2 = '\b';
|
|
break;
|
|
}
|
|
break;
|
|
case -4379043:
|
|
if (str.equals(Key.ELEVATION)) {
|
|
c2 = '\t';
|
|
break;
|
|
}
|
|
break;
|
|
case 37232917:
|
|
if (str.equals(Key.TRANSITION_PATH_ROTATE)) {
|
|
c2 = '\n';
|
|
break;
|
|
}
|
|
break;
|
|
case 92909918:
|
|
if (str.equals(Key.ALPHA)) {
|
|
c2 = 11;
|
|
break;
|
|
}
|
|
break;
|
|
case 156108012:
|
|
if (str.equals(Key.WAVE_OFFSET)) {
|
|
c2 = '\f';
|
|
break;
|
|
}
|
|
break;
|
|
case 184161818:
|
|
if (str.equals(Key.WAVE_PERIOD)) {
|
|
c2 = '\r';
|
|
break;
|
|
}
|
|
break;
|
|
case 579057826:
|
|
if (str.equals("curveFit")) {
|
|
c2 = 14;
|
|
break;
|
|
}
|
|
break;
|
|
case 1317633238:
|
|
if (str.equals("mTranslationZ")) {
|
|
c2 = 15;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
switch (c2) {
|
|
case 0:
|
|
this.mTransitionEasing = obj.toString();
|
|
return;
|
|
case 1:
|
|
this.mRotationX = toFloat(obj);
|
|
return;
|
|
case 2:
|
|
this.mRotationY = toFloat(obj);
|
|
return;
|
|
case 3:
|
|
this.mTranslationX = toFloat(obj);
|
|
return;
|
|
case 4:
|
|
this.mTranslationY = toFloat(obj);
|
|
return;
|
|
case 5:
|
|
this.mProgress = toFloat(obj);
|
|
return;
|
|
case 6:
|
|
this.mScaleX = toFloat(obj);
|
|
return;
|
|
case 7:
|
|
this.mScaleY = toFloat(obj);
|
|
return;
|
|
case '\b':
|
|
this.mRotation = toFloat(obj);
|
|
return;
|
|
case '\t':
|
|
this.mElevation = toFloat(obj);
|
|
return;
|
|
case '\n':
|
|
this.mTransitionPathRotate = toFloat(obj);
|
|
return;
|
|
case 11:
|
|
this.mAlpha = toFloat(obj);
|
|
return;
|
|
case '\f':
|
|
this.mWaveOffset = toFloat(obj);
|
|
return;
|
|
case '\r':
|
|
this.mWavePeriod = toFloat(obj);
|
|
return;
|
|
case 14:
|
|
this.mCurveFit = toInt(obj);
|
|
return;
|
|
case 15:
|
|
this.mTranslationZ = toFloat(obj);
|
|
return;
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
}
|