|
|
@@ -1,655 +0,0 @@
|
|
|
-package com.kfzs.duanduan.view;
|
|
|
-
|
|
|
-import android.content.Context;
|
|
|
-import android.graphics.Canvas;
|
|
|
-import android.graphics.Color;
|
|
|
-import android.graphics.Paint;
|
|
|
-import android.graphics.Path;
|
|
|
-import android.graphics.RectF;
|
|
|
-import android.os.Bundle;
|
|
|
-import android.os.Parcelable;
|
|
|
-import android.util.AttributeSet;
|
|
|
-import android.view.View;
|
|
|
-
|
|
|
-import java.util.ArrayList;
|
|
|
-import java.util.List;
|
|
|
-
|
|
|
-/**
|
|
|
- * @ Created by Dlg
|
|
|
- * @ <p>TiTle: ArrowDownloadButton</p>
|
|
|
- * @ <p>Description:</p>
|
|
|
- * @ date: 2018/1/30 14:54
|
|
|
- * @ QQ: 315096953
|
|
|
- */
|
|
|
-public class ArrowDownloadButton extends View {
|
|
|
-
|
|
|
- private static final int BLUE_ONE = Color.parseColor("#f2f2f2");
|
|
|
- private static final int WHILE = Color.parseColor("#F44336");
|
|
|
- private static final boolean mIsClockwise = true;//是否为顺时针旋转
|
|
|
- private static final float RADIUS = 180;
|
|
|
- private static final int TRI_POINT_NUMBER = 17;
|
|
|
- private static final float MAX_WAVE_HEIGHT = 12;//10,最大波浪高
|
|
|
- private static final float MIN_WAVE_HEIGHT = 5;//最低波浪高
|
|
|
- private static final int PROGRESS = 100;
|
|
|
- private static final int ANGLE = 360;
|
|
|
- private static final float TEXT_Y = 67.5f;
|
|
|
- private static final float OFFSET = 10;
|
|
|
- private static final float SMALL_RADIUS = 5;
|
|
|
- private static final float TEXT_SIZE = 40;
|
|
|
- private static final float ARC_WIDTH = 26;
|
|
|
- private static final float ARROW_WIDTH = 14;
|
|
|
- private static final float TRI_WIDTH = 14;
|
|
|
- private static final float LOADING_WIDTH = 14;
|
|
|
-
|
|
|
- private static final float STEP = 2;
|
|
|
- private static final float ELASTICITY_STEP = 10;
|
|
|
- private static final float ROPE_STEP_X = 30;
|
|
|
- private static final float ROPE_STEP_Y = 32;
|
|
|
- private static final float ROPE_HEAD_STEP_Y = 17;
|
|
|
- private static final float JUMP_STEP = 45;
|
|
|
- private static final float DOWN_STEP = 7.5f;
|
|
|
- private static final float TRI_STEP = 16.875f;
|
|
|
- private static final float TIME_STEP = 20;
|
|
|
- private static final float HOOK_STEP_Y = 15;
|
|
|
- private static final float HOOK_COUNT = 4;
|
|
|
- private static final float LITTLE_STEP = 8;
|
|
|
- private static final int DURATION = 20;
|
|
|
- private static final int COMPLETE_DURATION = 20;
|
|
|
-
|
|
|
- /**
|
|
|
- * start instance
|
|
|
- **/
|
|
|
- private static final String INSTANCE_STATE = "instance_state";
|
|
|
- /**
|
|
|
- *
|
|
|
- */
|
|
|
- private static final String X_I = "x";
|
|
|
- private static final String Y_I = "y";
|
|
|
- private static final String RADIUS_I = "radius";
|
|
|
- private static final String MAX_WAVE_HEIGHT_I = "max_wave_height";
|
|
|
- private static final String MIN_WAVE_HEIGHT_I = "min_wave_height";
|
|
|
- private static final String TEXT_Y_I = "text_y";
|
|
|
- private static final String STEP_I = "step";
|
|
|
- private static final String ELASTICITY_STEP_I = "elasticity_step";
|
|
|
- private static final String ROPE_STEP_X_I = "rope_step_x";
|
|
|
- private static final String ROPE_STEP_Y_I = "rope_step_y";
|
|
|
- private static final String ROPE_HEAD_STEP_Y_I = "rope_head_step_y";
|
|
|
- private static final String JUMP_STEP_I = "jump_step";
|
|
|
- private static final String DOWN_STEP_I = "down_step";
|
|
|
- private static final String TRI_STEP_I = "tri_step";
|
|
|
- private static final String HOOK_STEP_Y_I = "hook_step";
|
|
|
- private static final String LITTLE_STEP_I = "little_step";
|
|
|
- private static final String SMALL_RADIUS_I = "small_radius";
|
|
|
- private static final String TEXT_SIZE_I = "text_size";
|
|
|
- private static final String ARC_WIDTH_I = "arc_width";
|
|
|
- private static final String ARROW_WIDTH_I = "arrow_width";
|
|
|
- private static final String TRI_WIDTH_I = "tri_width";
|
|
|
- private static final String LOADING_WIDTH_I = "loading_width";
|
|
|
- private static final String IS_FIRST_I = "is_first";
|
|
|
- private static final String IS_ANIMATING_I = "is_animating";
|
|
|
- private static final String BEZIER_I = "bezier";
|
|
|
- private static final String IS_LOADING_I = "is_loading";
|
|
|
- private static final String IS_COMPLETED_I = "is_completed";
|
|
|
- private static final String IS_END_I = "is_end";
|
|
|
- private static final String COUNT_I = "count";
|
|
|
- private static final String LENGTH_I = "length";
|
|
|
- private static final String CURRENT_TIME_I = "current_time";
|
|
|
- private static final String WAVE_HEIGHT_I = "wave_height";
|
|
|
- private static final String PROGRESS_I = "progress";
|
|
|
- private static final String HOOK_COUNT_I = "hook_count";
|
|
|
- private static final String LENGTH_X_I = "length_x";
|
|
|
- private static final String LENGTH_Y_I = "length_y";
|
|
|
-
|
|
|
-
|
|
|
- private float x = 550;
|
|
|
- private float y = 550;
|
|
|
- private float radius = RADIUS;
|
|
|
- private float maxWaveHeight = MAX_WAVE_HEIGHT;
|
|
|
- private float minWaveHeight = MIN_WAVE_HEIGHT;
|
|
|
- private float textY = TEXT_Y;
|
|
|
- private float step = STEP;
|
|
|
- private float elasticityStep = ELASTICITY_STEP;
|
|
|
- private float ropeStepX = ROPE_STEP_X;
|
|
|
- private float ropeStepY = ROPE_STEP_Y;
|
|
|
- private float ropeHeadStepY = ROPE_HEAD_STEP_Y;
|
|
|
- private float jumpStep = JUMP_STEP;
|
|
|
- private float downStep = DOWN_STEP;
|
|
|
- private float triStep = TRI_STEP;
|
|
|
- private float hookStepY = HOOK_STEP_Y;
|
|
|
- private float littleStep = LITTLE_STEP;
|
|
|
- private float smallRadius = SMALL_RADIUS;
|
|
|
- private float textSize = TEXT_SIZE;
|
|
|
- private float arcWidth = ARC_WIDTH;
|
|
|
- private float arrowWidth = ARROW_WIDTH;
|
|
|
- private float triWidth = TRI_WIDTH;
|
|
|
- private float loadingWidth = LOADING_WIDTH;
|
|
|
-
|
|
|
- private Paint arrowPaint;
|
|
|
- private Paint arcPaint;
|
|
|
- private Paint smallPaint;
|
|
|
- private Paint triPaint;
|
|
|
- private Paint loadingPaint;
|
|
|
- private Paint textPaint;
|
|
|
-
|
|
|
- private Path arrowPath;
|
|
|
- private Path triPath;
|
|
|
- private Path textPath;
|
|
|
-
|
|
|
- private RectF oval;
|
|
|
-
|
|
|
- private Point a;
|
|
|
- private Point b;
|
|
|
- private Point c;
|
|
|
- private Point d;
|
|
|
- private Point e;
|
|
|
- private Point jumpPoint;
|
|
|
-
|
|
|
- private List<Point> triPoints = new ArrayList<>();
|
|
|
-
|
|
|
- private boolean isFirst = true;
|
|
|
- private boolean isAnimating = false;
|
|
|
- private boolean bezier = false;
|
|
|
- private boolean isLoading = false;
|
|
|
- private boolean isCompleted = false;
|
|
|
- private boolean isEnd = false;
|
|
|
- private int count = 0;
|
|
|
- private float length;
|
|
|
- private int currentTime = 0;
|
|
|
- private float waveHeight = MIN_WAVE_HEIGHT;
|
|
|
- private float progress = 0;
|
|
|
- private int hookCount = 0;
|
|
|
- float lengthX = 3 * radius / 4;
|
|
|
- float lengthY = 3 * radius / 4;
|
|
|
-
|
|
|
- public float getProgress() {
|
|
|
- return progress;
|
|
|
- }
|
|
|
-
|
|
|
- public void setProgress(float progress) {
|
|
|
- if (progress > 100) {
|
|
|
- this.progress = 100;
|
|
|
- } else {
|
|
|
- this.progress = progress;
|
|
|
- }
|
|
|
-
|
|
|
- if (progress == 100) {
|
|
|
- isLoading = false;
|
|
|
- isCompleted = true;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- public ArrowDownloadButton(Context context) {
|
|
|
- this(context, null);
|
|
|
- }
|
|
|
-
|
|
|
- public ArrowDownloadButton(Context context, AttributeSet attrs) {
|
|
|
- this(context, attrs, 0);
|
|
|
- }
|
|
|
-
|
|
|
- public ArrowDownloadButton(Context context, AttributeSet attrs, int defStyleAttr) {
|
|
|
- super(context, attrs, defStyleAttr);
|
|
|
- init();
|
|
|
- }
|
|
|
-
|
|
|
- @Override
|
|
|
- protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
|
|
|
- setMeasuredDimension(measure(widthMeasureSpec, true), measure(heightMeasureSpec, false));
|
|
|
- }
|
|
|
-
|
|
|
- private int measure(int measureSpec, boolean isWidth) {
|
|
|
- int result;
|
|
|
- int mode = MeasureSpec.getMode(measureSpec);
|
|
|
- int size = MeasureSpec.getSize(measureSpec);
|
|
|
- int padding = isWidth ? getPaddingLeft() + getPaddingRight() : getPaddingTop() + getPaddingBottom();
|
|
|
- if (mode == MeasureSpec.EXACTLY) {
|
|
|
- result = size;
|
|
|
- } else {
|
|
|
- result = isWidth ? getSuggestedMinimumWidth() : getSuggestedMinimumHeight();
|
|
|
- result += padding;
|
|
|
- if (mode == MeasureSpec.AT_MOST) {
|
|
|
- if (isWidth) {
|
|
|
- result = Math.max(result, size);
|
|
|
- } else {
|
|
|
- result = Math.min(result, size);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return result;
|
|
|
- }
|
|
|
-
|
|
|
- @Override
|
|
|
- protected void onDraw(Canvas canvas) {
|
|
|
- if (isFirst) {
|
|
|
- init();
|
|
|
- isFirst = false;
|
|
|
- }
|
|
|
- canvas.drawCircle(x, y, radius, arcPaint);
|
|
|
- drawArrow(canvas);
|
|
|
- if (isAnimating) {
|
|
|
- animating();
|
|
|
- }
|
|
|
- if (isLoading) {
|
|
|
- loading(canvas);
|
|
|
- }
|
|
|
- if (isCompleted) {
|
|
|
- afterCompleted(canvas);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- private void init() {
|
|
|
- float temp = getHeight() > getWidth() ? getWidth() / 2 : getHeight() / 2;
|
|
|
- radius = temp - temp * OFFSET / RADIUS - temp * ELASTICITY_STEP / RADIUS - 6;
|
|
|
- x = getPaddingLeft() + getWidth() / 2;
|
|
|
- y = getPaddingTop() + getHeight() / 2;
|
|
|
- maxWaveHeight = convert(MAX_WAVE_HEIGHT);
|
|
|
- minWaveHeight = convert(MIN_WAVE_HEIGHT);
|
|
|
- textY = convert(TEXT_Y);
|
|
|
- step = convert(STEP);
|
|
|
- elasticityStep = convert(ELASTICITY_STEP);
|
|
|
- ropeStepX = convert(ROPE_STEP_X);
|
|
|
- ropeStepY = convert(ROPE_STEP_Y);
|
|
|
- ropeHeadStepY = convert(ROPE_HEAD_STEP_Y);
|
|
|
- jumpStep = convert(JUMP_STEP);
|
|
|
- downStep = convert(DOWN_STEP);
|
|
|
- triStep = convert(TRI_STEP);
|
|
|
- hookStepY = convert(HOOK_STEP_Y);
|
|
|
- littleStep = convert(LITTLE_STEP);
|
|
|
- smallRadius = convert(SMALL_RADIUS);
|
|
|
- textSize = convert(TEXT_SIZE);
|
|
|
- arcWidth = convert(ARC_WIDTH);
|
|
|
- arrowWidth = convert(ARROW_WIDTH);
|
|
|
- triWidth = convert(TRI_WIDTH);
|
|
|
- loadingWidth = convert(LOADING_WIDTH);
|
|
|
- lengthX = 3 * radius / 4;
|
|
|
- lengthY = 3 * radius / 4;
|
|
|
-
|
|
|
- arrowPath = new Path();
|
|
|
- triPath = new Path();
|
|
|
- textPath = new Path();
|
|
|
- oval = new RectF();
|
|
|
- oval.left = x - radius;
|
|
|
- oval.top = y - radius;
|
|
|
- oval.right = x + radius;
|
|
|
- oval.bottom = y + radius;
|
|
|
- length = radius / 2;
|
|
|
- initializePaints();
|
|
|
- initializePoints();
|
|
|
- }
|
|
|
-
|
|
|
- /**
|
|
|
- * start animating before loading
|
|
|
- */
|
|
|
- public void startAnimating() {
|
|
|
- isAnimating = true;
|
|
|
- invalidate();
|
|
|
- }
|
|
|
-
|
|
|
- /**
|
|
|
- * reset to initial state
|
|
|
- */
|
|
|
- public void reset() {
|
|
|
- isAnimating = false;
|
|
|
- isLoading = false;
|
|
|
- bezier = false;
|
|
|
- isCompleted = false;
|
|
|
- isEnd = false;
|
|
|
- length = radius / 2;
|
|
|
- count = 0;
|
|
|
- hookCount = 0;
|
|
|
- jumpPoint.x = -1;
|
|
|
- progress = 0;
|
|
|
- lengthX = 3 * radius / 4;
|
|
|
- lengthY = 3 * radius / 4;
|
|
|
- a.y = y + length;
|
|
|
- b.y = y - length;
|
|
|
- e.y = y + length;
|
|
|
- c.x = x - length / 2;
|
|
|
- c.y = y + length / 2;
|
|
|
- d.x = x + length / 2;
|
|
|
- d.y = y + length / 2;
|
|
|
- invalidate();
|
|
|
- }
|
|
|
-
|
|
|
- /**
|
|
|
- * animating
|
|
|
- */
|
|
|
- public void animating() {
|
|
|
- if (count < 19) {
|
|
|
- length = length * 3 / 4;
|
|
|
- a.y = y + length;
|
|
|
- b.y = y - length;
|
|
|
-
|
|
|
- if (((count + 1) % 3) == 0 && count < 9) {
|
|
|
- e.y = e.y + step;
|
|
|
- c.y = c.y + step;
|
|
|
- d.y = d.y + step;
|
|
|
- }
|
|
|
- if (count > 8 && count < 12) {
|
|
|
- jumpPoint.x = x;
|
|
|
- jumpPoint.y = y - jumpStep * (count - 8);
|
|
|
- c.x = c.x - ropeStepX;
|
|
|
- c.y = c.y - ropeHeadStepY;
|
|
|
- d.x = d.x + ropeStepX;
|
|
|
- d.y = d.y - ropeHeadStepY;
|
|
|
- e.y = e.y - ropeStepY;
|
|
|
- }
|
|
|
- if (count > 11) {
|
|
|
- bezier = true;
|
|
|
- if (count == 12) {
|
|
|
- jumpPoint.y = jumpPoint.y - jumpStep * 2;
|
|
|
- } else {
|
|
|
- jumpPoint.y = jumpPoint.y + downStep;
|
|
|
- if (count < 16) {
|
|
|
- int time1 = 15 - count;
|
|
|
- e.y = y + time1 * elasticityStep;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- count++;
|
|
|
- postInvalidateDelayed(DURATION);
|
|
|
- } else {
|
|
|
- isAnimating = false;
|
|
|
- bezier = false;
|
|
|
- if (progress != 100) {
|
|
|
- isLoading = true;
|
|
|
- } else {
|
|
|
- isLoading = false;
|
|
|
- isCompleted = true;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /**
|
|
|
- * under loading
|
|
|
- *
|
|
|
- * @param canvas Target Canvas
|
|
|
- */
|
|
|
- private void loading(Canvas canvas) {
|
|
|
- Point currentPoint = triPoints.get(0);
|
|
|
- Point nextPoint;
|
|
|
- for (int i = 0; i < TRI_POINT_NUMBER; i++) {
|
|
|
- Point p = triPoints.get(i);
|
|
|
- p.x = (x - 3 * radius / 4) + triStep * i;
|
|
|
- p.y = y + calculateTri(TIME_STEP * i, currentTime);
|
|
|
- }
|
|
|
- for (int i = 1; i < TRI_POINT_NUMBER; i++) {
|
|
|
- nextPoint = triPoints.get(i);
|
|
|
- triPath.reset();
|
|
|
- triPath.moveTo(currentPoint.x, currentPoint.y);
|
|
|
- triPath.lineTo(nextPoint.x, nextPoint.y);
|
|
|
- canvas.drawCircle(nextPoint.x, nextPoint.y, smallRadius, smallPaint);
|
|
|
- canvas.drawPath(triPath, triPaint);
|
|
|
- currentPoint = nextPoint;
|
|
|
- }
|
|
|
- textPath.moveTo(x - textSize, y + textY);
|
|
|
- textPath.lineTo(x + textSize, y + textY);
|
|
|
- canvas.drawTextOnPath((int) progress + "%", textPath, 0, 0, textPaint);
|
|
|
- currentTime = (int) (currentTime + TIME_STEP);
|
|
|
- float sweepAngle = (progress / PROGRESS * ANGLE);
|
|
|
- sweepAngle = mIsClockwise ? sweepAngle : -sweepAngle;
|
|
|
- canvas.drawArc(oval, 270, 0 + sweepAngle, false, loadingPaint);
|
|
|
- postInvalidateDelayed(DURATION);
|
|
|
- }
|
|
|
-
|
|
|
- /**
|
|
|
- * the method do such things:
|
|
|
- * 1.draw arrow.
|
|
|
- * 2.when animate was completed, let the small ball jump.
|
|
|
- *
|
|
|
- * @param canvas Target Canvas
|
|
|
- */
|
|
|
- protected void drawArrow(Canvas canvas) {
|
|
|
- if (jumpPoint.x != -1) {
|
|
|
- canvas.drawCircle(jumpPoint.x, jumpPoint.y, smallRadius, smallPaint);
|
|
|
- }
|
|
|
- if (bezier) {
|
|
|
- arrowPath.reset();
|
|
|
- arrowPath.moveTo(c.x, c.y);
|
|
|
- arrowPath.quadTo(e.x, e.y, d.x, d.y);
|
|
|
- canvas.drawPath(arrowPath, arrowPaint);
|
|
|
- } else if (isLoading) {
|
|
|
- } else if (isCompleted) {
|
|
|
- } else if (isEnd) {
|
|
|
- canvas.drawCircle(x, y, radius, loadingPaint);
|
|
|
- drawArrowOrHook(canvas);
|
|
|
- } else {
|
|
|
- arrowPath.reset();
|
|
|
- arrowPath.moveTo(a.x, a.y);
|
|
|
- arrowPath.lineTo(b.x, b.y);
|
|
|
- canvas.drawPath(arrowPath, arrowPaint);
|
|
|
-
|
|
|
- canvas.drawCircle(a.x, a.y, smallRadius, smallPaint);
|
|
|
- canvas.drawCircle(b.x, b.y, smallRadius, smallPaint);
|
|
|
-
|
|
|
- drawArrowOrHook(canvas);
|
|
|
-
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /**
|
|
|
- * draw arrow or hook
|
|
|
- *
|
|
|
- * @param canvas Target Canvas
|
|
|
- */
|
|
|
- private void drawArrowOrHook(Canvas canvas) {
|
|
|
- arrowPath.reset();
|
|
|
- arrowPath.moveTo(e.x, e.y);
|
|
|
- arrowPath.lineTo(c.x, c.y);
|
|
|
- canvas.drawPath(arrowPath, arrowPaint);
|
|
|
- arrowPath.reset();
|
|
|
- arrowPath.moveTo(e.x, e.y);
|
|
|
- arrowPath.lineTo(d.x, d.y);
|
|
|
- canvas.drawPath(arrowPath, arrowPaint);
|
|
|
-
|
|
|
- canvas.drawCircle(c.x, c.y, smallRadius, smallPaint);
|
|
|
- canvas.drawCircle(d.x, d.y, smallRadius, smallPaint);
|
|
|
- canvas.drawCircle(e.x, e.y, smallRadius, smallPaint);
|
|
|
- }
|
|
|
-
|
|
|
- /**
|
|
|
- * the animate after loading
|
|
|
- *
|
|
|
- * @param canvas Target Canvas
|
|
|
- */
|
|
|
- private void afterCompleted(Canvas canvas) {
|
|
|
- canvas.drawCircle(x, y, radius, loadingPaint);
|
|
|
- if (hookCount == HOOK_COUNT - 1) {
|
|
|
- e.y = e.y + littleStep;
|
|
|
- c.x = c.x - littleStep;
|
|
|
- d.x = d.x + littleStep;
|
|
|
- d.y = d.y - littleStep;
|
|
|
- isCompleted = false;
|
|
|
- isEnd = true;
|
|
|
- } else {
|
|
|
- e.x = x;
|
|
|
- e.y = y + hookStepY * (hookCount + 1);
|
|
|
- lengthX = lengthX * 3 / 4;
|
|
|
- c.x = x - lengthX * 3 / 4;
|
|
|
- c.y = y;
|
|
|
- d.x = x + lengthY - radius / (float) 8 * (hookCount + 1);
|
|
|
- d.y = y - hookStepY * (hookCount + 1);
|
|
|
- hookCount++;
|
|
|
- }
|
|
|
- drawArrowOrHook(canvas);
|
|
|
- postInvalidateDelayed(COMPLETE_DURATION);
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- protected void initializePaints() {
|
|
|
- arcPaint = new Paint();
|
|
|
- arcPaint.setAntiAlias(true);
|
|
|
- arcPaint.setStyle(Paint.Style.STROKE);
|
|
|
- arcPaint.setStrokeWidth(arcWidth);
|
|
|
- arcPaint.setColor(BLUE_ONE);
|
|
|
-
|
|
|
- arrowPaint = new Paint();
|
|
|
- arrowPaint.setAntiAlias(true);
|
|
|
- arrowPaint.setStyle(Paint.Style.STROKE);
|
|
|
- arrowPaint.setStrokeWidth(arrowWidth);
|
|
|
- arrowPaint.setColor(WHILE);
|
|
|
-
|
|
|
- smallPaint = new Paint();
|
|
|
- smallPaint.setAntiAlias(true);
|
|
|
- smallPaint.setStyle(Paint.Style.FILL);
|
|
|
- smallPaint.setColor(WHILE);
|
|
|
-
|
|
|
- triPaint = new Paint();
|
|
|
- triPaint.setAntiAlias(true);
|
|
|
- triPaint.setStyle(Paint.Style.STROKE);
|
|
|
- triPaint.setStrokeWidth(triWidth);
|
|
|
- triPaint.setColor(WHILE);
|
|
|
-
|
|
|
- loadingPaint = new Paint();
|
|
|
- loadingPaint.setAntiAlias(true);
|
|
|
- loadingPaint.setStyle(Paint.Style.STROKE);
|
|
|
- loadingPaint.setStrokeWidth(loadingWidth);
|
|
|
- loadingPaint.setColor(WHILE);
|
|
|
-
|
|
|
- textPaint = new Paint();
|
|
|
- textPaint.setAntiAlias(true);
|
|
|
- textPaint.setStyle(Paint.Style.FILL);
|
|
|
- textPaint.setStrokeWidth(1);
|
|
|
- textPaint.setColor(WHILE);
|
|
|
- textPaint.setTextSize(textSize);
|
|
|
- }
|
|
|
-
|
|
|
- protected void initializePoints() {
|
|
|
- a = new Point(x, y + radius / 2);
|
|
|
- b = new Point(x, y - radius / 2);
|
|
|
- c = new Point(x - radius / 4, y + radius / 4);
|
|
|
- d = new Point(x + radius / 4, y + radius / 4);
|
|
|
- e = new Point(x, y + radius / 2);
|
|
|
- jumpPoint = new Point();
|
|
|
-
|
|
|
- for (int i = 0; i < TRI_POINT_NUMBER; i++) {
|
|
|
- Point point = new Point();
|
|
|
- point.x = (x - 3 * radius / 4) + triStep * i;
|
|
|
- point.y = y + calculateTri(TIME_STEP * i, 0);
|
|
|
- triPoints.add(point);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /**
|
|
|
- * calculate the wave
|
|
|
- *
|
|
|
- * @param originalTime original time
|
|
|
- * @param currentTime current time
|
|
|
- * @return wave
|
|
|
- */
|
|
|
- private float calculateTri(float originalTime, float currentTime) {
|
|
|
- if (progress < PROGRESS / 3) {
|
|
|
- waveHeight = MIN_WAVE_HEIGHT;
|
|
|
- } else if (progress < PROGRESS * 2 / 3) {
|
|
|
- waveHeight = maxWaveHeight;
|
|
|
- } else {
|
|
|
- waveHeight = minWaveHeight;
|
|
|
- }
|
|
|
- return (float) (waveHeight * Math.sin((Math.PI / 80) * (originalTime + currentTime)));
|
|
|
- }
|
|
|
-
|
|
|
- private float convert(float original) {
|
|
|
- return radius * original / RADIUS;
|
|
|
- }
|
|
|
-
|
|
|
- @Override
|
|
|
- protected Parcelable onSaveInstanceState() {
|
|
|
- final Bundle bundle = new Bundle();
|
|
|
- bundle.putParcelable(INSTANCE_STATE, super.onSaveInstanceState());
|
|
|
- bundle.putFloat(X_I, x);
|
|
|
- bundle.putFloat(Y_I, y);
|
|
|
- bundle.putFloat(RADIUS_I, radius);
|
|
|
- bundle.putFloat(MAX_WAVE_HEIGHT_I, maxWaveHeight);
|
|
|
- bundle.putFloat(MIN_WAVE_HEIGHT_I, minWaveHeight);
|
|
|
- bundle.putFloat(TEXT_Y_I, textY);
|
|
|
- bundle.putFloat(STEP_I, step);
|
|
|
- bundle.putFloat(ELASTICITY_STEP_I, elasticityStep);
|
|
|
- bundle.putFloat(ROPE_STEP_X_I, ropeStepX);
|
|
|
- bundle.putFloat(ROPE_STEP_Y_I, ropeStepY);
|
|
|
- bundle.putFloat(ROPE_HEAD_STEP_Y_I, ropeHeadStepY);
|
|
|
- bundle.putFloat(JUMP_STEP_I, jumpStep);
|
|
|
- bundle.putFloat(DOWN_STEP_I, downStep);
|
|
|
- bundle.putFloat(TRI_STEP_I, triStep);
|
|
|
- bundle.putFloat(HOOK_STEP_Y_I, hookStepY);
|
|
|
- bundle.putFloat(LITTLE_STEP_I, littleStep);
|
|
|
- bundle.putFloat(SMALL_RADIUS_I, smallRadius);
|
|
|
- bundle.putFloat(TEXT_SIZE_I, textSize);
|
|
|
- bundle.putFloat(ARC_WIDTH_I, arcWidth);
|
|
|
- bundle.putFloat(ARROW_WIDTH_I, arrowWidth);
|
|
|
- bundle.putFloat(TRI_WIDTH_I, triWidth);
|
|
|
- bundle.putFloat(LOADING_WIDTH_I, loadingWidth);
|
|
|
- bundle.putBoolean(IS_FIRST_I, isFirst);
|
|
|
- bundle.putBoolean(IS_ANIMATING_I, isAnimating);
|
|
|
- bundle.putBoolean(BEZIER_I, bezier);
|
|
|
- bundle.putBoolean(IS_LOADING_I, isLoading);
|
|
|
- bundle.putBoolean(IS_COMPLETED_I, isCompleted);
|
|
|
- bundle.putBoolean(IS_END_I, isEnd);
|
|
|
- bundle.putInt(COUNT_I, count);
|
|
|
- bundle.putFloat(LENGTH_I, length);
|
|
|
- bundle.putInt(CURRENT_TIME_I, currentTime);
|
|
|
- bundle.putFloat(WAVE_HEIGHT_I, waveHeight);
|
|
|
- bundle.putFloat(PROGRESS_I, progress);
|
|
|
- bundle.putInt(HOOK_COUNT_I, hookCount);
|
|
|
- bundle.putFloat(LENGTH_X_I, lengthX);
|
|
|
- bundle.putFloat(LENGTH_Y_I, lengthY);
|
|
|
- return bundle;
|
|
|
- }
|
|
|
-
|
|
|
- @Override
|
|
|
- protected void onRestoreInstanceState(Parcelable state) {
|
|
|
- if (state instanceof Bundle) {
|
|
|
- final Bundle bundle = (Bundle) state;
|
|
|
- x = bundle.getFloat(X_I);
|
|
|
- y = bundle.getFloat(Y_I);
|
|
|
- radius = bundle.getFloat(RADIUS_I);
|
|
|
- maxWaveHeight = bundle.getFloat(MAX_WAVE_HEIGHT_I);
|
|
|
- minWaveHeight = bundle.getFloat(MIN_WAVE_HEIGHT_I);
|
|
|
- textY = bundle.getFloat(TEXT_Y_I);
|
|
|
- step = bundle.getFloat(STEP_I);
|
|
|
- elasticityStep = bundle.getFloat(ELASTICITY_STEP_I);
|
|
|
- ropeStepX = bundle.getFloat(ROPE_STEP_X_I);
|
|
|
- ropeStepY = bundle.getFloat(ROPE_STEP_Y_I);
|
|
|
- ropeHeadStepY = bundle.getFloat(ROPE_HEAD_STEP_Y_I);
|
|
|
- jumpStep = bundle.getFloat(JUMP_STEP_I);
|
|
|
- downStep = bundle.getFloat(DOWN_STEP_I);
|
|
|
- triStep = bundle.getFloat(TRI_STEP_I);
|
|
|
- hookStepY = bundle.getFloat(HOOK_STEP_Y_I);
|
|
|
- littleStep = bundle.getFloat(LITTLE_STEP_I);
|
|
|
- smallRadius = bundle.getFloat(SMALL_RADIUS_I);
|
|
|
- textSize = bundle.getFloat(TEXT_SIZE_I);
|
|
|
- arcWidth = bundle.getFloat(ARC_WIDTH_I);
|
|
|
- arrowWidth = bundle.getFloat(ARROW_WIDTH_I);
|
|
|
- triWidth = bundle.getFloat(TRI_WIDTH_I);
|
|
|
- loadingWidth = bundle.getFloat(LOADING_WIDTH_I);
|
|
|
- isFirst = bundle.getBoolean(IS_FIRST_I);
|
|
|
- isAnimating = bundle.getBoolean(IS_ANIMATING_I);
|
|
|
- bezier = bundle.getBoolean(BEZIER_I);
|
|
|
- isLoading = bundle.getBoolean(IS_LOADING_I);
|
|
|
- isCompleted = bundle.getBoolean(IS_COMPLETED_I);
|
|
|
- isEnd = bundle.getBoolean(IS_END_I);
|
|
|
- count = bundle.getInt(COUNT_I);
|
|
|
- length = bundle.getFloat(LENGTH_I);
|
|
|
- currentTime = bundle.getInt(CURRENT_TIME_I);
|
|
|
- waveHeight = bundle.getFloat(WAVE_HEIGHT_I);
|
|
|
- progress = bundle.getFloat(PROGRESS_I);
|
|
|
- hookCount = bundle.getInt(HOOK_COUNT_I);
|
|
|
- lengthX = bundle.getFloat(LENGTH_X_I);
|
|
|
- lengthY = bundle.getFloat(LENGTH_Y_I);
|
|
|
- }
|
|
|
- super.onRestoreInstanceState(state);
|
|
|
- }
|
|
|
-
|
|
|
- static class Point {
|
|
|
- public float x;
|
|
|
- public float y;
|
|
|
-
|
|
|
- public Point(float x, float y) {
|
|
|
- this.x = x;
|
|
|
- this.y = y;
|
|
|
- }
|
|
|
-
|
|
|
- public Point() {
|
|
|
- x = -1;
|
|
|
- y = -1;
|
|
|
- }
|
|
|
- }
|
|
|
-}
|