1401 lines
58 KiB
Java
1401 lines
58 KiB
Java
package androidx.constraintlayout.motion.widget;
|
|
|
|
import android.content.Context;
|
|
import android.graphics.Rect;
|
|
import android.graphics.RectF;
|
|
import android.util.Log;
|
|
import android.util.SparseArray;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.view.animation.AccelerateDecelerateInterpolator;
|
|
import android.view.animation.AccelerateInterpolator;
|
|
import android.view.animation.AnimationUtils;
|
|
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.CurveFit;
|
|
import androidx.constraintlayout.core.motion.utils.Easing;
|
|
import androidx.constraintlayout.core.motion.utils.KeyCache;
|
|
import androidx.constraintlayout.core.motion.utils.VelocityMatrix;
|
|
import androidx.constraintlayout.core.widgets.analyzer.BasicMeasure;
|
|
import androidx.constraintlayout.motion.utils.CustomSupport;
|
|
import androidx.constraintlayout.motion.utils.ViewOscillator;
|
|
import androidx.constraintlayout.motion.utils.ViewSpline;
|
|
import androidx.constraintlayout.motion.utils.ViewState;
|
|
import androidx.constraintlayout.motion.utils.ViewTimeCycle;
|
|
import androidx.constraintlayout.widget.ConstraintAttribute;
|
|
import androidx.constraintlayout.widget.ConstraintLayout;
|
|
import androidx.constraintlayout.widget.ConstraintSet;
|
|
import java.lang.reflect.Array;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
|
|
/* loaded from: classes.dex */
|
|
public class MotionController {
|
|
static final int BOUNCE = 4;
|
|
private static final boolean DEBUG = false;
|
|
public static final int DRAW_PATH_AS_CONFIGURED = 4;
|
|
public static final int DRAW_PATH_BASIC = 1;
|
|
public static final int DRAW_PATH_CARTESIAN = 3;
|
|
public static final int DRAW_PATH_NONE = 0;
|
|
public static final int DRAW_PATH_RECTANGLE = 5;
|
|
public static final int DRAW_PATH_RELATIVE = 2;
|
|
public static final int DRAW_PATH_SCREEN = 6;
|
|
static final int EASE_IN = 1;
|
|
static final int EASE_IN_OUT = 0;
|
|
static final int EASE_OUT = 2;
|
|
private static final boolean FAVOR_FIXED_SIZE_VIEWS = false;
|
|
public static final int HORIZONTAL_PATH_X = 2;
|
|
public static final int HORIZONTAL_PATH_Y = 3;
|
|
private static final int INTERPOLATOR_REFERENCE_ID = -2;
|
|
private static final int INTERPOLATOR_UNDEFINED = -3;
|
|
static final int LINEAR = 3;
|
|
static final int OVERSHOOT = 5;
|
|
public static final int PATH_PERCENT = 0;
|
|
public static final int PATH_PERPENDICULAR = 1;
|
|
public static final int ROTATION_LEFT = 2;
|
|
public static final int ROTATION_RIGHT = 1;
|
|
private static final int SPLINE_STRING = -1;
|
|
private static final String TAG = "MotionController";
|
|
public static final int VERTICAL_PATH_X = 4;
|
|
public static final int VERTICAL_PATH_Y = 5;
|
|
String[] attributeTable;
|
|
private CurveFit mArcSpline;
|
|
private int[] mAttributeInterpolatorCount;
|
|
private String[] mAttributeNames;
|
|
private HashMap<String, ViewSpline> mAttributesMap;
|
|
String mConstraintTag;
|
|
float mCurrentCenterX;
|
|
float mCurrentCenterY;
|
|
private HashMap<String, ViewOscillator> mCycleMap;
|
|
int mId;
|
|
private double[] mInterpolateData;
|
|
private int[] mInterpolateVariables;
|
|
private double[] mInterpolateVelocity;
|
|
private KeyTrigger[] mKeyTriggers;
|
|
private CurveFit[] mSpline;
|
|
private HashMap<String, ViewTimeCycle> mTimeCycleAttributesMap;
|
|
View mView;
|
|
Rect mTempRect = new Rect();
|
|
boolean mForceMeasure = false;
|
|
private int mCurveFitType = -1;
|
|
private MotionPaths mStartMotionPath = new MotionPaths();
|
|
private MotionPaths mEndMotionPath = new MotionPaths();
|
|
private MotionConstrainedPoint mStartPoint = new MotionConstrainedPoint();
|
|
private MotionConstrainedPoint mEndPoint = new MotionConstrainedPoint();
|
|
float mMotionStagger = Float.NaN;
|
|
float mStaggerOffset = 0.0f;
|
|
float mStaggerScale = 1.0f;
|
|
private int MAX_DIMENSION = 4;
|
|
private float[] mValuesBuff = new float[4];
|
|
private ArrayList<MotionPaths> mMotionPaths = new ArrayList<>();
|
|
private float[] mVelocity = new float[1];
|
|
private ArrayList<Key> mKeyList = new ArrayList<>();
|
|
private int mPathMotionArc = Key.UNSET;
|
|
private int mTransformPivotTarget = Key.UNSET;
|
|
private View mTransformPivotView = null;
|
|
private int mQuantizeMotionSteps = Key.UNSET;
|
|
private float mQuantizeMotionPhase = Float.NaN;
|
|
private Interpolator mQuantizeMotionInterpolator = null;
|
|
private boolean mNoMovement = false;
|
|
|
|
public float getCenterX() {
|
|
return this.mCurrentCenterX;
|
|
}
|
|
|
|
public float getCenterY() {
|
|
return this.mCurrentCenterY;
|
|
}
|
|
|
|
public int getTransformPivotTarget() {
|
|
return this.mTransformPivotTarget;
|
|
}
|
|
|
|
public View getView() {
|
|
return this.mView;
|
|
}
|
|
|
|
public void remeasure() {
|
|
this.mForceMeasure = true;
|
|
}
|
|
|
|
public void setPathMotionArc(int arc) {
|
|
this.mPathMotionArc = arc;
|
|
}
|
|
|
|
public void setTransformPivotTarget(int transformPivotTarget) {
|
|
this.mTransformPivotTarget = transformPivotTarget;
|
|
this.mTransformPivotView = null;
|
|
}
|
|
|
|
MotionPaths getKeyFrame(int i) {
|
|
return this.mMotionPaths.get(i);
|
|
}
|
|
|
|
MotionController(View view) {
|
|
setView(view);
|
|
}
|
|
|
|
public float getStartX() {
|
|
return this.mStartMotionPath.x;
|
|
}
|
|
|
|
public float getStartY() {
|
|
return this.mStartMotionPath.y;
|
|
}
|
|
|
|
public float getFinalX() {
|
|
return this.mEndMotionPath.x;
|
|
}
|
|
|
|
public float getFinalY() {
|
|
return this.mEndMotionPath.y;
|
|
}
|
|
|
|
public float getStartWidth() {
|
|
return this.mStartMotionPath.width;
|
|
}
|
|
|
|
public float getStartHeight() {
|
|
return this.mStartMotionPath.height;
|
|
}
|
|
|
|
public float getFinalWidth() {
|
|
return this.mEndMotionPath.width;
|
|
}
|
|
|
|
public float getFinalHeight() {
|
|
return this.mEndMotionPath.height;
|
|
}
|
|
|
|
public int getAnimateRelativeTo() {
|
|
return this.mStartMotionPath.mAnimateRelativeTo;
|
|
}
|
|
|
|
public void setupRelative(MotionController motionController) {
|
|
this.mStartMotionPath.setupRelative(motionController, motionController.mStartMotionPath);
|
|
this.mEndMotionPath.setupRelative(motionController, motionController.mEndMotionPath);
|
|
}
|
|
|
|
public void getCenter(double p, float[] pos, float[] vel) {
|
|
double[] dArr = new double[4];
|
|
double[] dArr2 = new double[4];
|
|
this.mSpline[0].getPos(p, dArr);
|
|
this.mSpline[0].getSlope(p, dArr2);
|
|
Arrays.fill(vel, 0.0f);
|
|
this.mStartMotionPath.getCenter(p, this.mInterpolateVariables, dArr, pos, dArr2, vel);
|
|
}
|
|
|
|
void buildPath(float[] points, int pointCount) {
|
|
float f = 1.0f;
|
|
float f2 = 1.0f / (pointCount - 1);
|
|
HashMap<String, ViewSpline> hashMap = this.mAttributesMap;
|
|
ViewSpline viewSpline = hashMap == null ? null : hashMap.get("translationX");
|
|
HashMap<String, ViewSpline> hashMap2 = this.mAttributesMap;
|
|
ViewSpline viewSpline2 = hashMap2 == null ? null : hashMap2.get("translationY");
|
|
HashMap<String, ViewOscillator> hashMap3 = this.mCycleMap;
|
|
ViewOscillator viewOscillator = hashMap3 == null ? null : hashMap3.get("translationX");
|
|
HashMap<String, ViewOscillator> hashMap4 = this.mCycleMap;
|
|
ViewOscillator viewOscillator2 = hashMap4 != null ? hashMap4.get("translationY") : null;
|
|
int i = 0;
|
|
while (i < pointCount) {
|
|
float f3 = i * f2;
|
|
float f4 = this.mStaggerScale;
|
|
float f5 = 0.0f;
|
|
if (f4 != f) {
|
|
float f6 = this.mStaggerOffset;
|
|
if (f3 < f6) {
|
|
f3 = 0.0f;
|
|
}
|
|
if (f3 > f6 && f3 < 1.0d) {
|
|
f3 = Math.min((f3 - f6) * f4, f);
|
|
}
|
|
}
|
|
float f7 = f3;
|
|
double d = f7;
|
|
Easing easing = this.mStartMotionPath.mKeyFrameEasing;
|
|
Iterator<MotionPaths> it = this.mMotionPaths.iterator();
|
|
float f8 = Float.NaN;
|
|
while (it.hasNext()) {
|
|
MotionPaths next = it.next();
|
|
if (next.mKeyFrameEasing != null) {
|
|
if (next.time < f7) {
|
|
easing = next.mKeyFrameEasing;
|
|
f5 = next.time;
|
|
} else if (Float.isNaN(f8)) {
|
|
f8 = next.time;
|
|
}
|
|
}
|
|
}
|
|
if (easing != null) {
|
|
if (Float.isNaN(f8)) {
|
|
f8 = 1.0f;
|
|
}
|
|
d = (((float) easing.get((f7 - f5) / r16)) * (f8 - f5)) + f5;
|
|
}
|
|
double d2 = d;
|
|
this.mSpline[0].getPos(d2, this.mInterpolateData);
|
|
CurveFit curveFit = this.mArcSpline;
|
|
if (curveFit != null) {
|
|
double[] dArr = this.mInterpolateData;
|
|
if (dArr.length > 0) {
|
|
curveFit.getPos(d2, dArr);
|
|
}
|
|
}
|
|
int i2 = i * 2;
|
|
int i3 = i;
|
|
this.mStartMotionPath.getCenter(d2, this.mInterpolateVariables, this.mInterpolateData, points, i2);
|
|
if (viewOscillator != null) {
|
|
points[i2] = points[i2] + viewOscillator.get(f7);
|
|
} else if (viewSpline != null) {
|
|
points[i2] = points[i2] + viewSpline.get(f7);
|
|
}
|
|
if (viewOscillator2 != null) {
|
|
int i4 = i2 + 1;
|
|
points[i4] = points[i4] + viewOscillator2.get(f7);
|
|
} else if (viewSpline2 != null) {
|
|
int i5 = i2 + 1;
|
|
points[i5] = points[i5] + viewSpline2.get(f7);
|
|
}
|
|
i = i3 + 1;
|
|
f = 1.0f;
|
|
}
|
|
}
|
|
|
|
double[] getPos(double position) {
|
|
this.mSpline[0].getPos(position, this.mInterpolateData);
|
|
CurveFit curveFit = this.mArcSpline;
|
|
if (curveFit != null) {
|
|
double[] dArr = this.mInterpolateData;
|
|
if (dArr.length > 0) {
|
|
curveFit.getPos(position, dArr);
|
|
}
|
|
}
|
|
return this.mInterpolateData;
|
|
}
|
|
|
|
void buildBounds(float[] bounds, int pointCount) {
|
|
float f = 1.0f / (pointCount - 1);
|
|
HashMap<String, ViewSpline> hashMap = this.mAttributesMap;
|
|
if (hashMap != null) {
|
|
hashMap.get("translationX");
|
|
}
|
|
HashMap<String, ViewSpline> hashMap2 = this.mAttributesMap;
|
|
if (hashMap2 != null) {
|
|
hashMap2.get("translationY");
|
|
}
|
|
HashMap<String, ViewOscillator> hashMap3 = this.mCycleMap;
|
|
if (hashMap3 != null) {
|
|
hashMap3.get("translationX");
|
|
}
|
|
HashMap<String, ViewOscillator> hashMap4 = this.mCycleMap;
|
|
if (hashMap4 != null) {
|
|
hashMap4.get("translationY");
|
|
}
|
|
for (int i = 0; i < pointCount; i++) {
|
|
float f2 = i * f;
|
|
float f3 = this.mStaggerScale;
|
|
float f4 = 0.0f;
|
|
if (f3 != 1.0f) {
|
|
float f5 = this.mStaggerOffset;
|
|
if (f2 < f5) {
|
|
f2 = 0.0f;
|
|
}
|
|
if (f2 > f5 && f2 < 1.0d) {
|
|
f2 = Math.min((f2 - f5) * f3, 1.0f);
|
|
}
|
|
}
|
|
double d = f2;
|
|
Easing easing = this.mStartMotionPath.mKeyFrameEasing;
|
|
Iterator<MotionPaths> it = this.mMotionPaths.iterator();
|
|
float f6 = Float.NaN;
|
|
while (it.hasNext()) {
|
|
MotionPaths next = it.next();
|
|
if (next.mKeyFrameEasing != null) {
|
|
if (next.time < f2) {
|
|
easing = next.mKeyFrameEasing;
|
|
f4 = next.time;
|
|
} else if (Float.isNaN(f6)) {
|
|
f6 = next.time;
|
|
}
|
|
}
|
|
}
|
|
if (easing != null) {
|
|
if (Float.isNaN(f6)) {
|
|
f6 = 1.0f;
|
|
}
|
|
d = (((float) easing.get((f2 - f4) / r10)) * (f6 - f4)) + f4;
|
|
}
|
|
this.mSpline[0].getPos(d, this.mInterpolateData);
|
|
CurveFit curveFit = this.mArcSpline;
|
|
if (curveFit != null) {
|
|
double[] dArr = this.mInterpolateData;
|
|
if (dArr.length > 0) {
|
|
curveFit.getPos(d, dArr);
|
|
}
|
|
}
|
|
this.mStartMotionPath.getBounds(this.mInterpolateVariables, this.mInterpolateData, bounds, i * 2);
|
|
}
|
|
}
|
|
|
|
private float getPreCycleDistance() {
|
|
float[] fArr = new float[2];
|
|
float f = 1.0f / 99;
|
|
double d = 0.0d;
|
|
double d2 = 0.0d;
|
|
float f2 = 0.0f;
|
|
int i = 0;
|
|
while (i < 100) {
|
|
float f3 = i * f;
|
|
double d3 = f3;
|
|
Easing easing = this.mStartMotionPath.mKeyFrameEasing;
|
|
Iterator<MotionPaths> it = this.mMotionPaths.iterator();
|
|
float f4 = Float.NaN;
|
|
float f5 = 0.0f;
|
|
while (it.hasNext()) {
|
|
MotionPaths next = it.next();
|
|
if (next.mKeyFrameEasing != null) {
|
|
if (next.time < f3) {
|
|
easing = next.mKeyFrameEasing;
|
|
f5 = next.time;
|
|
} else if (Float.isNaN(f4)) {
|
|
f4 = next.time;
|
|
}
|
|
}
|
|
}
|
|
if (easing != null) {
|
|
if (Float.isNaN(f4)) {
|
|
f4 = 1.0f;
|
|
}
|
|
d3 = (((float) easing.get((f3 - f5) / r17)) * (f4 - f5)) + f5;
|
|
}
|
|
this.mSpline[0].getPos(d3, this.mInterpolateData);
|
|
float f6 = f2;
|
|
int i2 = i;
|
|
this.mStartMotionPath.getCenter(d3, this.mInterpolateVariables, this.mInterpolateData, fArr, 0);
|
|
f2 = i2 > 0 ? (float) (f6 + Math.hypot(d2 - fArr[1], d - fArr[0])) : f6;
|
|
d = fArr[0];
|
|
i = i2 + 1;
|
|
d2 = fArr[1];
|
|
}
|
|
return f2;
|
|
}
|
|
|
|
KeyPositionBase getPositionKeyframe(int layoutWidth, int layoutHeight, float x, float y) {
|
|
RectF rectF = new RectF();
|
|
rectF.left = this.mStartMotionPath.x;
|
|
rectF.top = this.mStartMotionPath.y;
|
|
rectF.right = rectF.left + this.mStartMotionPath.width;
|
|
rectF.bottom = rectF.top + this.mStartMotionPath.height;
|
|
RectF rectF2 = new RectF();
|
|
rectF2.left = this.mEndMotionPath.x;
|
|
rectF2.top = this.mEndMotionPath.y;
|
|
rectF2.right = rectF2.left + this.mEndMotionPath.width;
|
|
rectF2.bottom = rectF2.top + this.mEndMotionPath.height;
|
|
Iterator<Key> it = this.mKeyList.iterator();
|
|
while (it.hasNext()) {
|
|
Key next = it.next();
|
|
if (next instanceof KeyPositionBase) {
|
|
KeyPositionBase keyPositionBase = (KeyPositionBase) next;
|
|
if (keyPositionBase.intersects(layoutWidth, layoutHeight, rectF, rectF2, x, y)) {
|
|
return keyPositionBase;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
int buildKeyFrames(float[] keyFrames, int[] mode) {
|
|
if (keyFrames == null) {
|
|
return 0;
|
|
}
|
|
double[] timePoints = this.mSpline[0].getTimePoints();
|
|
if (mode != null) {
|
|
Iterator<MotionPaths> it = this.mMotionPaths.iterator();
|
|
int i = 0;
|
|
while (it.hasNext()) {
|
|
mode[i] = it.next().mMode;
|
|
i++;
|
|
}
|
|
}
|
|
int i2 = 0;
|
|
for (int i3 = 0; i3 < timePoints.length; i3++) {
|
|
this.mSpline[0].getPos(timePoints[i3], this.mInterpolateData);
|
|
this.mStartMotionPath.getCenter(timePoints[i3], this.mInterpolateVariables, this.mInterpolateData, keyFrames, i2);
|
|
i2 += 2;
|
|
}
|
|
return i2 / 2;
|
|
}
|
|
|
|
int buildKeyBounds(float[] keyBounds, int[] mode) {
|
|
if (keyBounds == null) {
|
|
return 0;
|
|
}
|
|
double[] timePoints = this.mSpline[0].getTimePoints();
|
|
if (mode != null) {
|
|
Iterator<MotionPaths> it = this.mMotionPaths.iterator();
|
|
int i = 0;
|
|
while (it.hasNext()) {
|
|
mode[i] = it.next().mMode;
|
|
i++;
|
|
}
|
|
}
|
|
int i2 = 0;
|
|
for (double d : timePoints) {
|
|
this.mSpline[0].getPos(d, this.mInterpolateData);
|
|
this.mStartMotionPath.getBounds(this.mInterpolateVariables, this.mInterpolateData, keyBounds, i2);
|
|
i2 += 2;
|
|
}
|
|
return i2 / 2;
|
|
}
|
|
|
|
int getAttributeValues(String attributeType, float[] points, int pointCount) {
|
|
ViewSpline viewSpline = this.mAttributesMap.get(attributeType);
|
|
if (viewSpline == null) {
|
|
return -1;
|
|
}
|
|
for (int i = 0; i < points.length; i++) {
|
|
points[i] = viewSpline.get(i / (points.length - 1));
|
|
}
|
|
return points.length;
|
|
}
|
|
|
|
void buildRect(float p, float[] path, int offset) {
|
|
this.mSpline[0].getPos(getAdjustedPosition(p, null), this.mInterpolateData);
|
|
this.mStartMotionPath.getRect(this.mInterpolateVariables, this.mInterpolateData, path, offset);
|
|
}
|
|
|
|
void buildRectangles(float[] path, int pointCount) {
|
|
float f = 1.0f / (pointCount - 1);
|
|
for (int i = 0; i < pointCount; i++) {
|
|
this.mSpline[0].getPos(getAdjustedPosition(i * f, null), this.mInterpolateData);
|
|
this.mStartMotionPath.getRect(this.mInterpolateVariables, this.mInterpolateData, path, i * 8);
|
|
}
|
|
}
|
|
|
|
float getKeyFrameParameter(int type, float x, float y) {
|
|
float f = this.mEndMotionPath.x - this.mStartMotionPath.x;
|
|
float f2 = this.mEndMotionPath.y - this.mStartMotionPath.y;
|
|
float f3 = this.mStartMotionPath.x + (this.mStartMotionPath.width / 2.0f);
|
|
float f4 = this.mStartMotionPath.y + (this.mStartMotionPath.height / 2.0f);
|
|
float hypot = (float) Math.hypot(f, f2);
|
|
if (hypot < 1.0E-7d) {
|
|
return Float.NaN;
|
|
}
|
|
float f5 = x - f3;
|
|
float f6 = y - f4;
|
|
if (((float) Math.hypot(f5, f6)) == 0.0f) {
|
|
return 0.0f;
|
|
}
|
|
float f7 = (f5 * f) + (f6 * f2);
|
|
if (type == 0) {
|
|
return f7 / hypot;
|
|
}
|
|
if (type == 1) {
|
|
return (float) Math.sqrt((hypot * hypot) - (f7 * f7));
|
|
}
|
|
if (type == 2) {
|
|
return f5 / f;
|
|
}
|
|
if (type == 3) {
|
|
return f6 / f;
|
|
}
|
|
if (type == 4) {
|
|
return f5 / f2;
|
|
}
|
|
if (type != 5) {
|
|
return 0.0f;
|
|
}
|
|
return f6 / f2;
|
|
}
|
|
|
|
private void insertKey(MotionPaths point) {
|
|
if (Collections.binarySearch(this.mMotionPaths, point) == 0) {
|
|
Log.e(TAG, " KeyPath position \"" + point.position + "\" outside of range");
|
|
}
|
|
this.mMotionPaths.add((-r0) - 1, point);
|
|
}
|
|
|
|
void addKeys(ArrayList<Key> list) {
|
|
this.mKeyList.addAll(list);
|
|
}
|
|
|
|
public void addKey(Key key) {
|
|
this.mKeyList.add(key);
|
|
}
|
|
|
|
public void setup(int parentWidth, int parentHeight, float transitionDuration, long currentTime) {
|
|
ArrayList arrayList;
|
|
double[][] dArr;
|
|
ConstraintAttribute constraintAttribute;
|
|
ViewTimeCycle makeSpline;
|
|
ConstraintAttribute constraintAttribute2;
|
|
Integer num;
|
|
ViewSpline makeSpline2;
|
|
ConstraintAttribute constraintAttribute3;
|
|
new HashSet();
|
|
HashSet<String> hashSet = new HashSet<>();
|
|
HashSet<String> hashSet2 = new HashSet<>();
|
|
HashSet<String> hashSet3 = new HashSet<>();
|
|
HashMap<String, Integer> hashMap = new HashMap<>();
|
|
if (this.mPathMotionArc != Key.UNSET) {
|
|
this.mStartMotionPath.mPathMotionArc = this.mPathMotionArc;
|
|
}
|
|
this.mStartPoint.different(this.mEndPoint, hashSet2);
|
|
ArrayList<Key> arrayList2 = this.mKeyList;
|
|
if (arrayList2 != null) {
|
|
Iterator<Key> it = arrayList2.iterator();
|
|
arrayList = null;
|
|
while (it.hasNext()) {
|
|
Key next = it.next();
|
|
if (next instanceof KeyPosition) {
|
|
KeyPosition keyPosition = (KeyPosition) next;
|
|
insertKey(new MotionPaths(parentWidth, parentHeight, keyPosition, this.mStartMotionPath, this.mEndMotionPath));
|
|
if (keyPosition.mCurveFit != Key.UNSET) {
|
|
this.mCurveFitType = keyPosition.mCurveFit;
|
|
}
|
|
} else if (next instanceof KeyCycle) {
|
|
next.getAttributeNames(hashSet3);
|
|
} else if (next instanceof KeyTimeCycle) {
|
|
next.getAttributeNames(hashSet);
|
|
} else if (next instanceof KeyTrigger) {
|
|
if (arrayList == null) {
|
|
arrayList = new ArrayList();
|
|
}
|
|
arrayList.add((KeyTrigger) next);
|
|
} else {
|
|
next.setInterpolation(hashMap);
|
|
next.getAttributeNames(hashSet2);
|
|
}
|
|
}
|
|
} else {
|
|
arrayList = null;
|
|
}
|
|
if (arrayList != null) {
|
|
this.mKeyTriggers = (KeyTrigger[]) arrayList.toArray(new KeyTrigger[0]);
|
|
}
|
|
if (!hashSet2.isEmpty()) {
|
|
this.mAttributesMap = new HashMap<>();
|
|
Iterator<String> it2 = hashSet2.iterator();
|
|
while (it2.hasNext()) {
|
|
String next2 = it2.next();
|
|
if (next2.startsWith("CUSTOM,")) {
|
|
SparseArray sparseArray = new SparseArray();
|
|
String str = next2.split(",")[1];
|
|
Iterator<Key> it3 = this.mKeyList.iterator();
|
|
while (it3.hasNext()) {
|
|
Key next3 = it3.next();
|
|
if (next3.mCustomConstraints != null && (constraintAttribute3 = next3.mCustomConstraints.get(str)) != null) {
|
|
sparseArray.append(next3.mFramePosition, constraintAttribute3);
|
|
}
|
|
}
|
|
makeSpline2 = ViewSpline.makeCustomSpline(next2, (SparseArray<ConstraintAttribute>) sparseArray);
|
|
} else {
|
|
makeSpline2 = ViewSpline.makeSpline(next2);
|
|
}
|
|
if (makeSpline2 != null) {
|
|
makeSpline2.setType(next2);
|
|
this.mAttributesMap.put(next2, makeSpline2);
|
|
}
|
|
}
|
|
ArrayList<Key> arrayList3 = this.mKeyList;
|
|
if (arrayList3 != null) {
|
|
Iterator<Key> it4 = arrayList3.iterator();
|
|
while (it4.hasNext()) {
|
|
Key next4 = it4.next();
|
|
if (next4 instanceof KeyAttributes) {
|
|
next4.addValues(this.mAttributesMap);
|
|
}
|
|
}
|
|
}
|
|
this.mStartPoint.addValues(this.mAttributesMap, 0);
|
|
this.mEndPoint.addValues(this.mAttributesMap, 100);
|
|
for (String str2 : this.mAttributesMap.keySet()) {
|
|
int intValue = (!hashMap.containsKey(str2) || (num = hashMap.get(str2)) == null) ? 0 : num.intValue();
|
|
ViewSpline viewSpline = this.mAttributesMap.get(str2);
|
|
if (viewSpline != null) {
|
|
viewSpline.setup(intValue);
|
|
}
|
|
}
|
|
}
|
|
if (!hashSet.isEmpty()) {
|
|
if (this.mTimeCycleAttributesMap == null) {
|
|
this.mTimeCycleAttributesMap = new HashMap<>();
|
|
}
|
|
Iterator<String> it5 = hashSet.iterator();
|
|
while (it5.hasNext()) {
|
|
String next5 = it5.next();
|
|
if (!this.mTimeCycleAttributesMap.containsKey(next5)) {
|
|
if (next5.startsWith("CUSTOM,")) {
|
|
SparseArray sparseArray2 = new SparseArray();
|
|
String str3 = next5.split(",")[1];
|
|
Iterator<Key> it6 = this.mKeyList.iterator();
|
|
while (it6.hasNext()) {
|
|
Key next6 = it6.next();
|
|
if (next6.mCustomConstraints != null && (constraintAttribute2 = next6.mCustomConstraints.get(str3)) != null) {
|
|
sparseArray2.append(next6.mFramePosition, constraintAttribute2);
|
|
}
|
|
}
|
|
makeSpline = ViewTimeCycle.makeCustomSpline(next5, sparseArray2);
|
|
} else {
|
|
makeSpline = ViewTimeCycle.makeSpline(next5, currentTime);
|
|
}
|
|
if (makeSpline != null) {
|
|
makeSpline.setType(next5);
|
|
this.mTimeCycleAttributesMap.put(next5, makeSpline);
|
|
}
|
|
}
|
|
}
|
|
ArrayList<Key> arrayList4 = this.mKeyList;
|
|
if (arrayList4 != null) {
|
|
Iterator<Key> it7 = arrayList4.iterator();
|
|
while (it7.hasNext()) {
|
|
Key next7 = it7.next();
|
|
if (next7 instanceof KeyTimeCycle) {
|
|
((KeyTimeCycle) next7).addTimeValues(this.mTimeCycleAttributesMap);
|
|
}
|
|
}
|
|
}
|
|
for (String str4 : this.mTimeCycleAttributesMap.keySet()) {
|
|
this.mTimeCycleAttributesMap.get(str4).setup(hashMap.containsKey(str4) ? hashMap.get(str4).intValue() : 0);
|
|
}
|
|
}
|
|
int size = this.mMotionPaths.size();
|
|
int i = size + 2;
|
|
MotionPaths[] motionPathsArr = new MotionPaths[i];
|
|
motionPathsArr[0] = this.mStartMotionPath;
|
|
motionPathsArr[size + 1] = this.mEndMotionPath;
|
|
if (this.mMotionPaths.size() > 0 && this.mCurveFitType == -1) {
|
|
this.mCurveFitType = 0;
|
|
}
|
|
Iterator<MotionPaths> it8 = this.mMotionPaths.iterator();
|
|
int i2 = 1;
|
|
while (it8.hasNext()) {
|
|
motionPathsArr[i2] = it8.next();
|
|
i2++;
|
|
}
|
|
HashSet hashSet4 = new HashSet();
|
|
for (String str5 : this.mEndMotionPath.attributes.keySet()) {
|
|
if (this.mStartMotionPath.attributes.containsKey(str5)) {
|
|
if (!hashSet2.contains("CUSTOM," + str5)) {
|
|
hashSet4.add(str5);
|
|
}
|
|
}
|
|
}
|
|
String[] strArr = (String[]) hashSet4.toArray(new String[0]);
|
|
this.mAttributeNames = strArr;
|
|
this.mAttributeInterpolatorCount = new int[strArr.length];
|
|
int i3 = 0;
|
|
while (true) {
|
|
String[] strArr2 = this.mAttributeNames;
|
|
if (i3 >= strArr2.length) {
|
|
break;
|
|
}
|
|
String str6 = strArr2[i3];
|
|
this.mAttributeInterpolatorCount[i3] = 0;
|
|
int i4 = 0;
|
|
while (true) {
|
|
if (i4 >= i) {
|
|
break;
|
|
}
|
|
if (motionPathsArr[i4].attributes.containsKey(str6) && (constraintAttribute = motionPathsArr[i4].attributes.get(str6)) != null) {
|
|
int[] iArr = this.mAttributeInterpolatorCount;
|
|
iArr[i3] = iArr[i3] + constraintAttribute.numberOfInterpolatedValues();
|
|
break;
|
|
}
|
|
i4++;
|
|
}
|
|
i3++;
|
|
}
|
|
boolean z = motionPathsArr[0].mPathMotionArc != Key.UNSET;
|
|
int length = 18 + this.mAttributeNames.length;
|
|
boolean[] zArr = new boolean[length];
|
|
for (int i5 = 1; i5 < i; i5++) {
|
|
motionPathsArr[i5].different(motionPathsArr[i5 - 1], zArr, this.mAttributeNames, z);
|
|
}
|
|
int i6 = 0;
|
|
for (int i7 = 1; i7 < length; i7++) {
|
|
if (zArr[i7]) {
|
|
i6++;
|
|
}
|
|
}
|
|
this.mInterpolateVariables = new int[i6];
|
|
int max = Math.max(2, i6);
|
|
this.mInterpolateData = new double[max];
|
|
this.mInterpolateVelocity = new double[max];
|
|
int i8 = 0;
|
|
for (int i9 = 1; i9 < length; i9++) {
|
|
if (zArr[i9]) {
|
|
this.mInterpolateVariables[i8] = i9;
|
|
i8++;
|
|
}
|
|
}
|
|
double[][] dArr2 = (double[][]) Array.newInstance((Class<?>) Double.TYPE, i, this.mInterpolateVariables.length);
|
|
double[] dArr3 = new double[i];
|
|
for (int i10 = 0; i10 < i; i10++) {
|
|
motionPathsArr[i10].fillStandard(dArr2[i10], this.mInterpolateVariables);
|
|
dArr3[i10] = motionPathsArr[i10].time;
|
|
}
|
|
int i11 = 0;
|
|
while (true) {
|
|
int[] iArr2 = this.mInterpolateVariables;
|
|
if (i11 >= iArr2.length) {
|
|
break;
|
|
}
|
|
if (iArr2[i11] < MotionPaths.names.length) {
|
|
String str7 = MotionPaths.names[this.mInterpolateVariables[i11]] + " [";
|
|
for (int i12 = 0; i12 < i; i12++) {
|
|
str7 = str7 + dArr2[i12][i11];
|
|
}
|
|
}
|
|
i11++;
|
|
}
|
|
this.mSpline = new CurveFit[this.mAttributeNames.length + 1];
|
|
int i13 = 0;
|
|
while (true) {
|
|
String[] strArr3 = this.mAttributeNames;
|
|
if (i13 >= strArr3.length) {
|
|
break;
|
|
}
|
|
String str8 = strArr3[i13];
|
|
int i14 = 0;
|
|
double[] dArr4 = null;
|
|
int i15 = 0;
|
|
double[][] dArr5 = null;
|
|
while (i14 < i) {
|
|
if (motionPathsArr[i14].hasCustomData(str8)) {
|
|
if (dArr5 == null) {
|
|
dArr4 = new double[i];
|
|
dArr5 = (double[][]) Array.newInstance((Class<?>) Double.TYPE, i, motionPathsArr[i14].getCustomDataCount(str8));
|
|
}
|
|
dArr = dArr2;
|
|
dArr4[i15] = motionPathsArr[i14].time;
|
|
motionPathsArr[i14].getCustomData(str8, dArr5[i15], 0);
|
|
i15++;
|
|
} else {
|
|
dArr = dArr2;
|
|
}
|
|
i14++;
|
|
dArr2 = dArr;
|
|
}
|
|
i13++;
|
|
this.mSpline[i13] = CurveFit.get(this.mCurveFitType, Arrays.copyOf(dArr4, i15), (double[][]) Arrays.copyOf(dArr5, i15));
|
|
dArr2 = dArr2;
|
|
}
|
|
this.mSpline[0] = CurveFit.get(this.mCurveFitType, dArr3, dArr2);
|
|
if (motionPathsArr[0].mPathMotionArc != Key.UNSET) {
|
|
int[] iArr3 = new int[i];
|
|
double[] dArr6 = new double[i];
|
|
double[][] dArr7 = (double[][]) Array.newInstance((Class<?>) Double.TYPE, i, 2);
|
|
for (int i16 = 0; i16 < i; i16++) {
|
|
iArr3[i16] = motionPathsArr[i16].mPathMotionArc;
|
|
dArr6[i16] = motionPathsArr[i16].time;
|
|
dArr7[i16][0] = motionPathsArr[i16].x;
|
|
dArr7[i16][1] = motionPathsArr[i16].y;
|
|
}
|
|
this.mArcSpline = CurveFit.getArc(iArr3, dArr6, dArr7);
|
|
}
|
|
this.mCycleMap = new HashMap<>();
|
|
if (this.mKeyList != null) {
|
|
Iterator<String> it9 = hashSet3.iterator();
|
|
float f = Float.NaN;
|
|
while (it9.hasNext()) {
|
|
String next8 = it9.next();
|
|
ViewOscillator makeSpline3 = ViewOscillator.makeSpline(next8);
|
|
if (makeSpline3 != null) {
|
|
if (makeSpline3.variesByPath() && Float.isNaN(f)) {
|
|
f = getPreCycleDistance();
|
|
}
|
|
makeSpline3.setType(next8);
|
|
this.mCycleMap.put(next8, makeSpline3);
|
|
}
|
|
}
|
|
Iterator<Key> it10 = this.mKeyList.iterator();
|
|
while (it10.hasNext()) {
|
|
Key next9 = it10.next();
|
|
if (next9 instanceof KeyCycle) {
|
|
((KeyCycle) next9).addCycleValues(this.mCycleMap);
|
|
}
|
|
}
|
|
Iterator<ViewOscillator> it11 = this.mCycleMap.values().iterator();
|
|
while (it11.hasNext()) {
|
|
it11.next().setup(f);
|
|
}
|
|
}
|
|
}
|
|
|
|
public String toString() {
|
|
return " start: x: " + this.mStartMotionPath.x + " y: " + this.mStartMotionPath.y + " end: x: " + this.mEndMotionPath.x + " y: " + this.mEndMotionPath.y;
|
|
}
|
|
|
|
private void readView(MotionPaths motionPaths) {
|
|
motionPaths.setBounds((int) this.mView.getX(), (int) this.mView.getY(), this.mView.getWidth(), this.mView.getHeight());
|
|
}
|
|
|
|
public void setView(View view) {
|
|
this.mView = view;
|
|
this.mId = view.getId();
|
|
ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
|
|
if (layoutParams instanceof ConstraintLayout.LayoutParams) {
|
|
this.mConstraintTag = ((ConstraintLayout.LayoutParams) layoutParams).getConstraintTag();
|
|
}
|
|
}
|
|
|
|
void setStartCurrentState(View v) {
|
|
this.mStartMotionPath.time = 0.0f;
|
|
this.mStartMotionPath.position = 0.0f;
|
|
this.mStartMotionPath.setBounds(v.getX(), v.getY(), v.getWidth(), v.getHeight());
|
|
this.mStartPoint.setState(v);
|
|
}
|
|
|
|
public void setStartState(ViewState rect, View v, int rotation, int preWidth, int preHeight) {
|
|
this.mStartMotionPath.time = 0.0f;
|
|
this.mStartMotionPath.position = 0.0f;
|
|
Rect rect2 = new Rect();
|
|
if (rotation == 1) {
|
|
int i = rect.left + rect.right;
|
|
rect2.left = ((rect.top + rect.bottom) - rect.width()) / 2;
|
|
rect2.top = preWidth - ((i + rect.height()) / 2);
|
|
rect2.right = rect2.left + rect.width();
|
|
rect2.bottom = rect2.top + rect.height();
|
|
} else if (rotation == 2) {
|
|
int i2 = rect.left + rect.right;
|
|
rect2.left = preHeight - (((rect.top + rect.bottom) + rect.width()) / 2);
|
|
rect2.top = (i2 - rect.height()) / 2;
|
|
rect2.right = rect2.left + rect.width();
|
|
rect2.bottom = rect2.top + rect.height();
|
|
}
|
|
this.mStartMotionPath.setBounds(rect2.left, rect2.top, rect2.width(), rect2.height());
|
|
this.mStartPoint.setState(rect2, v, rotation, rect.rotation);
|
|
}
|
|
|
|
void rotate(Rect rect, Rect out, int rotation, int preHeight, int preWidth) {
|
|
if (rotation == 1) {
|
|
int i = rect.left + rect.right;
|
|
out.left = ((rect.top + rect.bottom) - rect.width()) / 2;
|
|
out.top = preWidth - ((i + rect.height()) / 2);
|
|
out.right = out.left + rect.width();
|
|
out.bottom = out.top + rect.height();
|
|
return;
|
|
}
|
|
if (rotation == 2) {
|
|
int i2 = rect.left + rect.right;
|
|
out.left = preHeight - (((rect.top + rect.bottom) + rect.width()) / 2);
|
|
out.top = (i2 - rect.height()) / 2;
|
|
out.right = out.left + rect.width();
|
|
out.bottom = out.top + rect.height();
|
|
return;
|
|
}
|
|
if (rotation != 3) {
|
|
if (rotation != 4) {
|
|
return;
|
|
}
|
|
int i3 = rect.left + rect.right;
|
|
out.left = preHeight - (((rect.bottom + rect.top) + rect.width()) / 2);
|
|
out.top = (i3 - rect.height()) / 2;
|
|
out.right = out.left + rect.width();
|
|
out.bottom = out.top + rect.height();
|
|
return;
|
|
}
|
|
int i4 = rect.left + rect.right;
|
|
int i5 = rect.top;
|
|
int i6 = rect.bottom;
|
|
out.left = ((rect.height() / 2) + rect.top) - (i4 / 2);
|
|
out.top = preWidth - ((i4 + rect.height()) / 2);
|
|
out.right = out.left + rect.width();
|
|
out.bottom = out.top + rect.height();
|
|
}
|
|
|
|
void setStartState(Rect cw, ConstraintSet constraintSet, int parentWidth, int parentHeight) {
|
|
int i = constraintSet.mRotate;
|
|
if (i != 0) {
|
|
rotate(cw, this.mTempRect, i, parentWidth, parentHeight);
|
|
}
|
|
this.mStartMotionPath.time = 0.0f;
|
|
this.mStartMotionPath.position = 0.0f;
|
|
readView(this.mStartMotionPath);
|
|
this.mStartMotionPath.setBounds(cw.left, cw.top, cw.width(), cw.height());
|
|
ConstraintSet.Constraint parameters = constraintSet.getParameters(this.mId);
|
|
this.mStartMotionPath.applyParameters(parameters);
|
|
this.mMotionStagger = parameters.motion.mMotionStagger;
|
|
this.mStartPoint.setState(cw, constraintSet, i, this.mId);
|
|
this.mTransformPivotTarget = parameters.transform.transformPivotTarget;
|
|
this.mQuantizeMotionSteps = parameters.motion.mQuantizeMotionSteps;
|
|
this.mQuantizeMotionPhase = parameters.motion.mQuantizeMotionPhase;
|
|
this.mQuantizeMotionInterpolator = getInterpolator(this.mView.getContext(), parameters.motion.mQuantizeInterpolatorType, parameters.motion.mQuantizeInterpolatorString, parameters.motion.mQuantizeInterpolatorID);
|
|
}
|
|
|
|
private static Interpolator getInterpolator(Context context, int type, String interpolatorString, int id) {
|
|
if (type == -2) {
|
|
return AnimationUtils.loadInterpolator(context, id);
|
|
}
|
|
if (type == -1) {
|
|
final Easing interpolator = Easing.getInterpolator(interpolatorString);
|
|
return new Interpolator() { // from class: androidx.constraintlayout.motion.widget.MotionController.1
|
|
@Override // android.animation.TimeInterpolator
|
|
public float getInterpolation(float v) {
|
|
return (float) Easing.this.get(v);
|
|
}
|
|
};
|
|
}
|
|
if (type == 0) {
|
|
return new AccelerateDecelerateInterpolator();
|
|
}
|
|
if (type == 1) {
|
|
return new AccelerateInterpolator();
|
|
}
|
|
if (type == 2) {
|
|
return new DecelerateInterpolator();
|
|
}
|
|
if (type == 4) {
|
|
return new BounceInterpolator();
|
|
}
|
|
if (type != 5) {
|
|
return null;
|
|
}
|
|
return new OvershootInterpolator();
|
|
}
|
|
|
|
void setEndState(Rect cw, ConstraintSet constraintSet, int parentWidth, int parentHeight) {
|
|
int i = constraintSet.mRotate;
|
|
if (i != 0) {
|
|
rotate(cw, this.mTempRect, i, parentWidth, parentHeight);
|
|
cw = this.mTempRect;
|
|
}
|
|
this.mEndMotionPath.time = 1.0f;
|
|
this.mEndMotionPath.position = 1.0f;
|
|
readView(this.mEndMotionPath);
|
|
this.mEndMotionPath.setBounds(cw.left, cw.top, cw.width(), cw.height());
|
|
this.mEndMotionPath.applyParameters(constraintSet.getParameters(this.mId));
|
|
this.mEndPoint.setState(cw, constraintSet, i, this.mId);
|
|
}
|
|
|
|
void setBothStates(View v) {
|
|
this.mStartMotionPath.time = 0.0f;
|
|
this.mStartMotionPath.position = 0.0f;
|
|
this.mNoMovement = true;
|
|
this.mStartMotionPath.setBounds(v.getX(), v.getY(), v.getWidth(), v.getHeight());
|
|
this.mEndMotionPath.setBounds(v.getX(), v.getY(), v.getWidth(), v.getHeight());
|
|
this.mStartPoint.setState(v);
|
|
this.mEndPoint.setState(v);
|
|
}
|
|
|
|
private float getAdjustedPosition(float position, float[] velocity) {
|
|
float f = 0.0f;
|
|
if (velocity != null) {
|
|
velocity[0] = 1.0f;
|
|
} else {
|
|
float f2 = this.mStaggerScale;
|
|
if (f2 != 1.0d) {
|
|
float f3 = this.mStaggerOffset;
|
|
if (position < f3) {
|
|
position = 0.0f;
|
|
}
|
|
if (position > f3 && position < 1.0d) {
|
|
position = Math.min((position - f3) * f2, 1.0f);
|
|
}
|
|
}
|
|
}
|
|
Easing easing = this.mStartMotionPath.mKeyFrameEasing;
|
|
Iterator<MotionPaths> it = this.mMotionPaths.iterator();
|
|
float f4 = Float.NaN;
|
|
while (it.hasNext()) {
|
|
MotionPaths next = it.next();
|
|
if (next.mKeyFrameEasing != null) {
|
|
if (next.time < position) {
|
|
easing = next.mKeyFrameEasing;
|
|
f = next.time;
|
|
} else if (Float.isNaN(f4)) {
|
|
f4 = next.time;
|
|
}
|
|
}
|
|
}
|
|
if (easing != null) {
|
|
float f5 = (Float.isNaN(f4) ? 1.0f : f4) - f;
|
|
double d = (position - f) / f5;
|
|
position = (((float) easing.get(d)) * f5) + f;
|
|
if (velocity != null) {
|
|
velocity[0] = (float) easing.getDiff(d);
|
|
}
|
|
}
|
|
return position;
|
|
}
|
|
|
|
void endTrigger(boolean start) {
|
|
if (!"button".equals(Debug.getName(this.mView)) || this.mKeyTriggers == null) {
|
|
return;
|
|
}
|
|
int i = 0;
|
|
while (true) {
|
|
KeyTrigger[] keyTriggerArr = this.mKeyTriggers;
|
|
if (i >= keyTriggerArr.length) {
|
|
return;
|
|
}
|
|
keyTriggerArr[i].conditionallyFire(start ? -100.0f : 100.0f, this.mView);
|
|
i++;
|
|
}
|
|
}
|
|
|
|
boolean interpolate(View child, float global_position, long time, KeyCache keyCache) {
|
|
ViewTimeCycle.PathRotate pathRotate;
|
|
boolean z;
|
|
char c;
|
|
double d;
|
|
float f;
|
|
float adjustedPosition = getAdjustedPosition(global_position, null);
|
|
if (this.mQuantizeMotionSteps != Key.UNSET) {
|
|
float f2 = 1.0f / this.mQuantizeMotionSteps;
|
|
float floor = ((float) Math.floor(adjustedPosition / f2)) * f2;
|
|
float f3 = (adjustedPosition % f2) / f2;
|
|
if (!Float.isNaN(this.mQuantizeMotionPhase)) {
|
|
f3 = (f3 + this.mQuantizeMotionPhase) % 1.0f;
|
|
}
|
|
Interpolator interpolator = this.mQuantizeMotionInterpolator;
|
|
if (interpolator != null) {
|
|
f = interpolator.getInterpolation(f3);
|
|
} else {
|
|
f = ((double) f3) > 0.5d ? 1.0f : 0.0f;
|
|
}
|
|
adjustedPosition = (f * f2) + floor;
|
|
}
|
|
float f4 = adjustedPosition;
|
|
HashMap<String, ViewSpline> hashMap = this.mAttributesMap;
|
|
if (hashMap != null) {
|
|
Iterator<ViewSpline> it = hashMap.values().iterator();
|
|
while (it.hasNext()) {
|
|
it.next().setProperty(child, f4);
|
|
}
|
|
}
|
|
HashMap<String, ViewTimeCycle> hashMap2 = this.mTimeCycleAttributesMap;
|
|
if (hashMap2 != null) {
|
|
ViewTimeCycle.PathRotate pathRotate2 = null;
|
|
boolean z2 = false;
|
|
for (ViewTimeCycle viewTimeCycle : hashMap2.values()) {
|
|
if (viewTimeCycle instanceof ViewTimeCycle.PathRotate) {
|
|
pathRotate2 = (ViewTimeCycle.PathRotate) viewTimeCycle;
|
|
} else {
|
|
z2 |= viewTimeCycle.setProperty(child, f4, time, keyCache);
|
|
}
|
|
}
|
|
z = z2;
|
|
pathRotate = pathRotate2;
|
|
} else {
|
|
pathRotate = null;
|
|
z = false;
|
|
}
|
|
CurveFit[] curveFitArr = this.mSpline;
|
|
if (curveFitArr != null) {
|
|
double d2 = f4;
|
|
curveFitArr[0].getPos(d2, this.mInterpolateData);
|
|
this.mSpline[0].getSlope(d2, this.mInterpolateVelocity);
|
|
CurveFit curveFit = this.mArcSpline;
|
|
if (curveFit != null) {
|
|
double[] dArr = this.mInterpolateData;
|
|
if (dArr.length > 0) {
|
|
curveFit.getPos(d2, dArr);
|
|
this.mArcSpline.getSlope(d2, this.mInterpolateVelocity);
|
|
}
|
|
}
|
|
if (this.mNoMovement) {
|
|
d = d2;
|
|
} else {
|
|
d = d2;
|
|
this.mStartMotionPath.setView(f4, child, this.mInterpolateVariables, this.mInterpolateData, this.mInterpolateVelocity, null, this.mForceMeasure);
|
|
this.mForceMeasure = false;
|
|
}
|
|
if (this.mTransformPivotTarget != Key.UNSET) {
|
|
if (this.mTransformPivotView == null) {
|
|
this.mTransformPivotView = ((View) child.getParent()).findViewById(this.mTransformPivotTarget);
|
|
}
|
|
if (this.mTransformPivotView != null) {
|
|
float top = (r1.getTop() + this.mTransformPivotView.getBottom()) / 2.0f;
|
|
float left = (this.mTransformPivotView.getLeft() + this.mTransformPivotView.getRight()) / 2.0f;
|
|
if (child.getRight() - child.getLeft() > 0 && child.getBottom() - child.getTop() > 0) {
|
|
child.setPivotX(left - child.getLeft());
|
|
child.setPivotY(top - child.getTop());
|
|
}
|
|
}
|
|
}
|
|
HashMap<String, ViewSpline> hashMap3 = this.mAttributesMap;
|
|
if (hashMap3 != null) {
|
|
for (ViewSpline viewSpline : hashMap3.values()) {
|
|
if (viewSpline instanceof ViewSpline.PathRotate) {
|
|
double[] dArr2 = this.mInterpolateVelocity;
|
|
if (dArr2.length > 1) {
|
|
((ViewSpline.PathRotate) viewSpline).setPathRotate(child, f4, dArr2[0], dArr2[1]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (pathRotate != null) {
|
|
double[] dArr3 = this.mInterpolateVelocity;
|
|
c = 1;
|
|
z |= pathRotate.setPathRotate(child, keyCache, f4, time, dArr3[0], dArr3[1]);
|
|
} else {
|
|
c = 1;
|
|
}
|
|
int i = 1;
|
|
while (true) {
|
|
CurveFit[] curveFitArr2 = this.mSpline;
|
|
if (i >= curveFitArr2.length) {
|
|
break;
|
|
}
|
|
curveFitArr2[i].getPos(d, this.mValuesBuff);
|
|
CustomSupport.setInterpolatedValue(this.mStartMotionPath.attributes.get(this.mAttributeNames[i - 1]), child, this.mValuesBuff);
|
|
i++;
|
|
}
|
|
if (this.mStartPoint.mVisibilityMode == 0) {
|
|
if (f4 <= 0.0f) {
|
|
child.setVisibility(this.mStartPoint.visibility);
|
|
} else if (f4 >= 1.0f) {
|
|
child.setVisibility(this.mEndPoint.visibility);
|
|
} else if (this.mEndPoint.visibility != this.mStartPoint.visibility) {
|
|
child.setVisibility(0);
|
|
}
|
|
}
|
|
if (this.mKeyTriggers != null) {
|
|
int i2 = 0;
|
|
while (true) {
|
|
KeyTrigger[] keyTriggerArr = this.mKeyTriggers;
|
|
if (i2 >= keyTriggerArr.length) {
|
|
break;
|
|
}
|
|
keyTriggerArr[i2].conditionallyFire(f4, child);
|
|
i2++;
|
|
}
|
|
}
|
|
} else {
|
|
c = 1;
|
|
float f5 = this.mStartMotionPath.x + ((this.mEndMotionPath.x - this.mStartMotionPath.x) * f4);
|
|
float f6 = f5 + 0.5f;
|
|
int i3 = (int) f6;
|
|
float f7 = this.mStartMotionPath.y + ((this.mEndMotionPath.y - this.mStartMotionPath.y) * f4) + 0.5f;
|
|
int i4 = (int) f7;
|
|
int i5 = (int) (f6 + this.mStartMotionPath.width + ((this.mEndMotionPath.width - this.mStartMotionPath.width) * f4));
|
|
int i6 = (int) (f7 + this.mStartMotionPath.height + ((this.mEndMotionPath.height - this.mStartMotionPath.height) * f4));
|
|
int i7 = i5 - i3;
|
|
int i8 = i6 - i4;
|
|
if (this.mEndMotionPath.width != this.mStartMotionPath.width || this.mEndMotionPath.height != this.mStartMotionPath.height || this.mForceMeasure) {
|
|
child.measure(View.MeasureSpec.makeMeasureSpec(i7, BasicMeasure.EXACTLY), View.MeasureSpec.makeMeasureSpec(i8, BasicMeasure.EXACTLY));
|
|
this.mForceMeasure = false;
|
|
}
|
|
child.layout(i3, i4, i5, i6);
|
|
}
|
|
HashMap<String, ViewOscillator> hashMap4 = this.mCycleMap;
|
|
if (hashMap4 != null) {
|
|
for (ViewOscillator viewOscillator : hashMap4.values()) {
|
|
if (viewOscillator instanceof ViewOscillator.PathRotateSet) {
|
|
double[] dArr4 = this.mInterpolateVelocity;
|
|
((ViewOscillator.PathRotateSet) viewOscillator).setPathRotate(child, f4, dArr4[0], dArr4[c]);
|
|
} else {
|
|
viewOscillator.setProperty(child, f4);
|
|
}
|
|
}
|
|
}
|
|
return z;
|
|
}
|
|
|
|
void getDpDt(float position, float locationX, float locationY, float[] mAnchorDpDt) {
|
|
double[] dArr;
|
|
float adjustedPosition = getAdjustedPosition(position, this.mVelocity);
|
|
CurveFit[] curveFitArr = this.mSpline;
|
|
int i = 0;
|
|
if (curveFitArr != null) {
|
|
double d = adjustedPosition;
|
|
curveFitArr[0].getSlope(d, this.mInterpolateVelocity);
|
|
this.mSpline[0].getPos(d, this.mInterpolateData);
|
|
float f = this.mVelocity[0];
|
|
while (true) {
|
|
dArr = this.mInterpolateVelocity;
|
|
if (i >= dArr.length) {
|
|
break;
|
|
}
|
|
dArr[i] = dArr[i] * f;
|
|
i++;
|
|
}
|
|
CurveFit curveFit = this.mArcSpline;
|
|
if (curveFit != null) {
|
|
double[] dArr2 = this.mInterpolateData;
|
|
if (dArr2.length > 0) {
|
|
curveFit.getPos(d, dArr2);
|
|
this.mArcSpline.getSlope(d, this.mInterpolateVelocity);
|
|
this.mStartMotionPath.setDpDt(locationX, locationY, mAnchorDpDt, this.mInterpolateVariables, this.mInterpolateVelocity, this.mInterpolateData);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
this.mStartMotionPath.setDpDt(locationX, locationY, mAnchorDpDt, this.mInterpolateVariables, dArr, this.mInterpolateData);
|
|
return;
|
|
}
|
|
float f2 = this.mEndMotionPath.x - this.mStartMotionPath.x;
|
|
float f3 = this.mEndMotionPath.y - this.mStartMotionPath.y;
|
|
float f4 = (this.mEndMotionPath.width - this.mStartMotionPath.width) + f2;
|
|
float f5 = (this.mEndMotionPath.height - this.mStartMotionPath.height) + f3;
|
|
mAnchorDpDt[0] = (f2 * (1.0f - locationX)) + (f4 * locationX);
|
|
mAnchorDpDt[1] = (f3 * (1.0f - locationY)) + (f5 * locationY);
|
|
}
|
|
|
|
void getPostLayoutDvDp(float position, int width, int height, float locationX, float locationY, float[] mAnchorDpDt) {
|
|
float adjustedPosition = getAdjustedPosition(position, this.mVelocity);
|
|
HashMap<String, ViewSpline> hashMap = this.mAttributesMap;
|
|
ViewSpline viewSpline = hashMap == null ? null : hashMap.get("translationX");
|
|
HashMap<String, ViewSpline> hashMap2 = this.mAttributesMap;
|
|
ViewSpline viewSpline2 = hashMap2 == null ? null : hashMap2.get("translationY");
|
|
HashMap<String, ViewSpline> hashMap3 = this.mAttributesMap;
|
|
ViewSpline viewSpline3 = hashMap3 == null ? null : hashMap3.get(Key.ROTATION);
|
|
HashMap<String, ViewSpline> hashMap4 = this.mAttributesMap;
|
|
ViewSpline viewSpline4 = hashMap4 == null ? null : hashMap4.get("scaleX");
|
|
HashMap<String, ViewSpline> hashMap5 = this.mAttributesMap;
|
|
ViewSpline viewSpline5 = hashMap5 == null ? null : hashMap5.get("scaleY");
|
|
HashMap<String, ViewOscillator> hashMap6 = this.mCycleMap;
|
|
ViewOscillator viewOscillator = hashMap6 == null ? null : hashMap6.get("translationX");
|
|
HashMap<String, ViewOscillator> hashMap7 = this.mCycleMap;
|
|
ViewOscillator viewOscillator2 = hashMap7 == null ? null : hashMap7.get("translationY");
|
|
HashMap<String, ViewOscillator> hashMap8 = this.mCycleMap;
|
|
ViewOscillator viewOscillator3 = hashMap8 == null ? null : hashMap8.get(Key.ROTATION);
|
|
HashMap<String, ViewOscillator> hashMap9 = this.mCycleMap;
|
|
ViewOscillator viewOscillator4 = hashMap9 == null ? null : hashMap9.get("scaleX");
|
|
HashMap<String, ViewOscillator> hashMap10 = this.mCycleMap;
|
|
ViewOscillator viewOscillator5 = hashMap10 != null ? hashMap10.get("scaleY") : null;
|
|
VelocityMatrix velocityMatrix = new VelocityMatrix();
|
|
velocityMatrix.clear();
|
|
velocityMatrix.setRotationVelocity(viewSpline3, adjustedPosition);
|
|
velocityMatrix.setTranslationVelocity(viewSpline, viewSpline2, adjustedPosition);
|
|
velocityMatrix.setScaleVelocity(viewSpline4, viewSpline5, adjustedPosition);
|
|
velocityMatrix.setRotationVelocity(viewOscillator3, adjustedPosition);
|
|
velocityMatrix.setTranslationVelocity(viewOscillator, viewOscillator2, adjustedPosition);
|
|
velocityMatrix.setScaleVelocity(viewOscillator4, viewOscillator5, adjustedPosition);
|
|
CurveFit curveFit = this.mArcSpline;
|
|
if (curveFit != null) {
|
|
double[] dArr = this.mInterpolateData;
|
|
if (dArr.length > 0) {
|
|
double d = adjustedPosition;
|
|
curveFit.getPos(d, dArr);
|
|
this.mArcSpline.getSlope(d, this.mInterpolateVelocity);
|
|
this.mStartMotionPath.setDpDt(locationX, locationY, mAnchorDpDt, this.mInterpolateVariables, this.mInterpolateVelocity, this.mInterpolateData);
|
|
}
|
|
velocityMatrix.applyTransform(locationX, locationY, width, height, mAnchorDpDt);
|
|
return;
|
|
}
|
|
int i = 0;
|
|
if (this.mSpline != null) {
|
|
double adjustedPosition2 = getAdjustedPosition(adjustedPosition, this.mVelocity);
|
|
this.mSpline[0].getSlope(adjustedPosition2, this.mInterpolateVelocity);
|
|
this.mSpline[0].getPos(adjustedPosition2, this.mInterpolateData);
|
|
float f = this.mVelocity[0];
|
|
while (true) {
|
|
double[] dArr2 = this.mInterpolateVelocity;
|
|
if (i < dArr2.length) {
|
|
dArr2[i] = dArr2[i] * f;
|
|
i++;
|
|
} else {
|
|
this.mStartMotionPath.setDpDt(locationX, locationY, mAnchorDpDt, this.mInterpolateVariables, dArr2, this.mInterpolateData);
|
|
velocityMatrix.applyTransform(locationX, locationY, width, height, mAnchorDpDt);
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
float f2 = this.mEndMotionPath.x - this.mStartMotionPath.x;
|
|
float f3 = this.mEndMotionPath.y - this.mStartMotionPath.y;
|
|
ViewOscillator viewOscillator6 = viewOscillator5;
|
|
float f4 = (this.mEndMotionPath.width - this.mStartMotionPath.width) + f2;
|
|
float f5 = (this.mEndMotionPath.height - this.mStartMotionPath.height) + f3;
|
|
mAnchorDpDt[0] = (f2 * (1.0f - locationX)) + (f4 * locationX);
|
|
mAnchorDpDt[1] = (f3 * (1.0f - locationY)) + (f5 * locationY);
|
|
velocityMatrix.clear();
|
|
velocityMatrix.setRotationVelocity(viewSpline3, adjustedPosition);
|
|
velocityMatrix.setTranslationVelocity(viewSpline, viewSpline2, adjustedPosition);
|
|
velocityMatrix.setScaleVelocity(viewSpline4, viewSpline5, adjustedPosition);
|
|
velocityMatrix.setRotationVelocity(viewOscillator3, adjustedPosition);
|
|
velocityMatrix.setTranslationVelocity(viewOscillator, viewOscillator2, adjustedPosition);
|
|
velocityMatrix.setScaleVelocity(viewOscillator4, viewOscillator6, adjustedPosition);
|
|
velocityMatrix.applyTransform(locationX, locationY, width, height, mAnchorDpDt);
|
|
}
|
|
}
|
|
|
|
public int getDrawPath() {
|
|
int i = this.mStartMotionPath.mDrawPath;
|
|
Iterator<MotionPaths> it = this.mMotionPaths.iterator();
|
|
while (it.hasNext()) {
|
|
i = Math.max(i, it.next().mDrawPath);
|
|
}
|
|
return Math.max(i, this.mEndMotionPath.mDrawPath);
|
|
}
|
|
|
|
public void setDrawPath(int debugMode) {
|
|
this.mStartMotionPath.mDrawPath = debugMode;
|
|
}
|
|
|
|
String name() {
|
|
return this.mView.getContext().getResources().getResourceEntryName(this.mView.getId());
|
|
}
|
|
|
|
void positionKeyframe(View view, KeyPositionBase key, float x, float y, String[] attribute, float[] value) {
|
|
RectF rectF = new RectF();
|
|
rectF.left = this.mStartMotionPath.x;
|
|
rectF.top = this.mStartMotionPath.y;
|
|
rectF.right = rectF.left + this.mStartMotionPath.width;
|
|
rectF.bottom = rectF.top + this.mStartMotionPath.height;
|
|
RectF rectF2 = new RectF();
|
|
rectF2.left = this.mEndMotionPath.x;
|
|
rectF2.top = this.mEndMotionPath.y;
|
|
rectF2.right = rectF2.left + this.mEndMotionPath.width;
|
|
rectF2.bottom = rectF2.top + this.mEndMotionPath.height;
|
|
key.positionAttributes(view, rectF, rectF2, x, y, attribute, value);
|
|
}
|
|
|
|
public int getKeyFramePositions(int[] type, float[] pos) {
|
|
Iterator<Key> it = this.mKeyList.iterator();
|
|
int i = 0;
|
|
int i2 = 0;
|
|
while (it.hasNext()) {
|
|
Key next = it.next();
|
|
type[i] = next.mFramePosition + (next.mType * 1000);
|
|
double d = next.mFramePosition / 100.0f;
|
|
this.mSpline[0].getPos(d, this.mInterpolateData);
|
|
this.mStartMotionPath.getCenter(d, this.mInterpolateVariables, this.mInterpolateData, pos, i2);
|
|
i2 += 2;
|
|
i++;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
public int getKeyFrameInfo(int type, int[] info) {
|
|
float[] fArr = new float[2];
|
|
Iterator<Key> it = this.mKeyList.iterator();
|
|
int i = 0;
|
|
int i2 = 0;
|
|
while (it.hasNext()) {
|
|
Key next = it.next();
|
|
if (next.mType == type || type != -1) {
|
|
info[i2] = 0;
|
|
info[i2 + 1] = next.mType;
|
|
info[i2 + 2] = next.mFramePosition;
|
|
double d = next.mFramePosition / 100.0f;
|
|
this.mSpline[0].getPos(d, this.mInterpolateData);
|
|
this.mStartMotionPath.getCenter(d, this.mInterpolateVariables, this.mInterpolateData, fArr, 0);
|
|
info[i2 + 3] = Float.floatToIntBits(fArr[0]);
|
|
int i3 = i2 + 4;
|
|
info[i3] = Float.floatToIntBits(fArr[1]);
|
|
if (next instanceof KeyPosition) {
|
|
KeyPosition keyPosition = (KeyPosition) next;
|
|
info[i2 + 5] = keyPosition.mPositionType;
|
|
info[i2 + 6] = Float.floatToIntBits(keyPosition.mPercentX);
|
|
i3 = i2 + 7;
|
|
info[i3] = Float.floatToIntBits(keyPosition.mPercentY);
|
|
}
|
|
int i4 = i3 + 1;
|
|
info[i2] = i4 - i2;
|
|
i++;
|
|
i2 = i4;
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
}
|