Android自定義View阻尼動畫&貝塞爾曲線的實現

阿新 • • 發佈：2019-01-13

效果圖：

直接上程式碼啦：

package com.example.administrator.myapplication.customview;

import android.animation.Animator;
import android.animation.AnimatorSet;
import android.animation.ObjectAnimator;
import android.animation.PropertyValuesHolder;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Path;
import android.graphics.PointF;
import android.graphics.drawable.GradientDrawable;
import android.util.AttributeSet;
import android.util.TypedValue;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.AccelerateDecelerateInterpolator;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;

import com.example.administrator.myapplication.R;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by Administrator on 2016/9/14.
 */
public class AnimationView extends RelativeLayout {


    private final int SMALL_CIRCLE_RADIS = dp2px(20);
    private final int LARGE_CIRCLE_RADIS = dp2px(25);
    private final int OUT_CIRCLE_RADIS = dp2px(50);

    private final int TYPE_SMALL = 0x01;
    private final int TYPE_LARGE = 0x02;
    private final int TYPE_OUTER = 0x03;


    private Context mContext;

    //小圓圈顏色
    private int mSmallCircleColor;
    //大圓圈顏色
    private int mLargeCircleColor;
    //外圓圈顏色
    private int mOutCircleColor;

    //動畫
    private AnimatorSet mAimationSet;
    private PropertyValuesHolder mValueScaleX;
    private PropertyValuesHolder mValueScaleY;
    private PropertyValuesHolder mValuesScale;
    //小圓移動路徑
    private Path mCirclePath;

    private LinearLayout mCircleContainer;
    private CircleView mOutCircleView;
    private CircleView mSmallCircleView;
    private CircleView mLargeCircleView;
    private List<CircleView> mCircleViews;

    //當前預設的位置
    private int mFocusPosition;
    private int mCount;


    public AnimationView(Context context) {
        this(context, null);
        mContext = context;
    }

    public AnimationView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
        mContext = context;
    }


    public AnimationView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        mContext = context;
        TypedArray ta = context.obtainStyledAttributes(attrs, R.styleable.AnimationView);
        mSmallCircleColor = ta.getColor(R.styleable.AnimationView_smallCircleColor, getResources().getColor(R.color.colorAccent));
        mLargeCircleColor = ta.getColor(R.styleable.AnimationView_largeCircleColor, getResources().getColor(R.color.colorPrimary));
        mOutCircleColor = ta.getColor(R.styleable.AnimationView_outCircleColor, getResources().getColor(android.R.color.holo_orange_light));
        ta.recycle();
        //初始化佈局
        View rootView = LayoutInflater.from(getContext()).inflate(R.layout.bg_animationview, this);
        mCircleContainer = (LinearLayout) rootView.findViewById(R.id.ll_container);
        mOutCircleView = (CircleView) rootView.findViewById(R.id.out_circle2);
        mOutCircleView.setRadis(OUT_CIRCLE_RADIS);
        //設定背景大圓顏色
        View containerWrapper = rootView.findViewById(R.id.wrapper);
        mOutCircleView.setColor(mOutCircleColor);
        GradientDrawable shape = (GradientDrawable) containerWrapper.getBackground();
        shape.setColor(mOutCircleColor);

        mValueScaleX = PropertyValuesHolder.ofFloat("scaleX", 1, 0.8f, 1);
        mValueScaleY = PropertyValuesHolder.ofFloat("scaleY", 1, 0.8f, 1);
        mValuesScale = PropertyValuesHolder.ofFloat("scaleY", 1, 0.5f, 1);

        mCirclePath = new Path();
        mCircleViews = new ArrayList<CircleView>();

    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        super.onLayout(changed, l, t, r, b);
        mLargeCircleView = mCircleViews.get(mFocusPosition);
        mOutCircleView.setCenter(mLargeCircleView.getCenter());
    }

    public void setCount(int count, int focus) {
        if (count < 2) {
            return;
        }
        if (focus > count || focus < 0) {
            return;
        }
        mFocusPosition = focus;
        mCount = count;
        /** 1:建立圓
         * 2：往linearlayout動態新增圓
         * */
        mCircleContainer.removeAllViews();
        mCircleViews.clear();
        //左邊放小圓
        for (int i = 0; i < focus; i++) {
            addSmallCircle();
        }
        //中間大圓
        addLargeCircle();
        //右邊小圓
        for (int i = focus + 1; i < count; i++) {
            addSmallCircle();
        }
    }

    private void addLargeCircle() {
        CircleView largeCircle = CreateCircle(TYPE_LARGE);
        mCircleViews.add(largeCircle);
        mCircleContainer.addView(largeCircle);
    }

    private void addSmallCircle() {
        CircleView smallCircle = CreateCircle(TYPE_SMALL);
        mCircleViews.add(smallCircle);
        mCircleContainer.addView(smallCircle);
    }

    public void moveRight() {
        if (mAimationSet != null && mAimationSet.isRunning()) {
            return;
        }
        move(true);
    }

    public void moveLeft() {
        if (mAimationSet != null && mAimationSet.isRunning()) {
            return;
        }
        move(false);
    }

    private void move(boolean toRight) {
        mLargeCircleView = mCircleViews.get(mFocusPosition);
        final int nextPos = getNextPosition(toRight);
        if (nextPos < 0) {
            return;
        }
        mSmallCircleView = mCircleViews.get(nextPos);

        //計算移動
        float largeCircleX = toRight ? mSmallCircleView.getX() - (mLargeCircleView.getWidth() - mSmallCircleView.getWidth()) : mSmallCircleView.getX();
        float smallCircleX = toRight ? mLargeCircleView.getX() : mLargeCircleView.getX() + (mLargeCircleView.getWidth() - mSmallCircleView.getWidth());
        float outCircleX = toRight ? mSmallCircleView.getX() - (mOutCircleView.getWidth() - mSmallCircleView.getWidth()) : mSmallCircleView.getX();
        //l argeCircleView動畫 X平移 XY縮放

        PropertyValuesHolder pvhX = PropertyValuesHolder.ofFloat("X", mLargeCircleView.getX(), largeCircleX);
        ObjectAnimator largeCircleAnim = ObjectAnimator.ofPropertyValuesHolder(mLargeCircleView, pvhX, mValueScaleX, mValueScaleY);
        //2 outCircleView動畫 X平移 XY縮放
        pvhX = PropertyValuesHolder.ofFloat("X", mOutCircleView.getX(), outCircleX);
        ObjectAnimator outCircleAnim = ObjectAnimator.ofPropertyValuesHolder(mOutCircleView, pvhX, mValueScaleX, mValueScaleY);
        //3 smallCircleView動畫 XY縮放 Path移動
        PointF center = mSmallCircleView.getCenter();
        PointF endCenter = new PointF(center.x - (mSmallCircleView.getX() - smallCircleX), center.y);
        mCirclePath.reset();
        mCirclePath.moveTo(center.x, center.y);
        //貝塞爾曲線
        mCirclePath.quadTo((center.x + endCenter.x) / 2, (center.y + endCenter.y) / 2 + 1.5f * dp2px(30), endCenter.x, endCenter.y);
        ObjectAnimator smallCircleAnim = ObjectAnimator.ofObject(mSmallCircleView, "Center", null, mCirclePath);
        ObjectAnimator smallCircleAnim2 = ObjectAnimator.ofPropertyValuesHolder(mSmallCircleView, mValuesScale);

        mAimationSet = new AnimatorSet();
        mAimationSet.play(largeCircleAnim).with(outCircleAnim).with(smallCircleAnim).with(smallCircleAnim2);
        mAimationSet.setInterpolator(new AccelerateDecelerateInterpolator());
        mAimationSet.setDuration(1000);
        mAimationSet.addListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animation) {

            }

            @Override
            public void onAnimationEnd(Animator animation) {
                swapCircle(mFocusPosition, nextPos);
                mFocusPosition = nextPos;

            }

            @Override
            public void onAnimationCancel(Animator animation) {

            }

            @Override
            public void onAnimationRepeat(Animator animation) {

            }
        });
        mAimationSet.start();
    }

    void swapCircle(int position1, int position2) {
        CircleView tmp = mCircleViews.get(position1);
        mCircleViews.set(position1, mCircleViews.get(position2));
        mCircleViews.set(position2, tmp);
    }

    private int getNextPosition(boolean toRight) {
        int next = mFocusPosition;
        if (toRight) {
            next = next + 1;
        } else {
            next = next - 1;
        }
        if (next < 0 || next >= mCount) {
            next = -1;
        }
        return next;
    }


    private CircleView CreateCircle(int type) {
        CircleView circle = new CircleView(mContext);
        LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
        params.weight = 1;
        params.gravity = Gravity.CENTER_VERTICAL;
        switch (type) {
            case TYPE_SMALL:
                params.height = params.width = SMALL_CIRCLE_RADIS * 2;
                circle.setColor(mSmallCircleColor);
                circle.setRadis(SMALL_CIRCLE_RADIS);
                break;
            case TYPE_LARGE:
                params.height = params.width = LARGE_CIRCLE_RADIS * 2;
                circle.setColor(mLargeCircleColor);
                circle.setRadis(LARGE_CIRCLE_RADIS);
                break;
            case TYPE_OUTER:
                params.height = params.width = OUT_CIRCLE_RADIS * 2;
                circle.setColor(mOutCircleColor);
                circle.setRadis(OUT_CIRCLE_RADIS);
                break;
            default:
                break;
        }
        circle.setLayoutParams(params);
        return circle;
    }

    private int dp2px(int dp) {
        return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, getResources().getDisplayMetrics());
    }

    private int sp2px(int sp) {
        return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, sp, getResources().getDisplayMetrics());
    }
}

package com.example.administrator.myapplication.customview;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.PointF;
import android.util.AttributeSet;
import android.view.View;

/**
 * Created by Administrator on 2016/9/14.
 */
public class CircleView extends View {
    private Context mContext;

    private int mCircleColor;
    private float mCircleRadis;
    private float mCenterX;
    private float mCenterY;

    private int mWidth;
    private int mHeight;

    private Paint mCirclePaint;

    public CircleView(Context context) {
        this(context, null);
        mContext = context;
    }

    public CircleView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
        mContext = context;
    }

    public CircleView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        mContext = context;
        initPaint();
    }

    private void initPaint() {
        mCirclePaint = new Paint();
        mCirclePaint.setAntiAlias(true);
        mCirclePaint.setStyle(Paint.Style.FILL_AND_STROKE);
        mCirclePaint.setStrokeWidth(1);
        mCirclePaint.setColor(mCircleColor);
    }

    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        super.onLayout(changed, left, top, right, bottom);
        mCenterX = (right - left) / 2;
        mCenterY = (bottom - top) / 2;
        mCircleRadis = Math.min(mCenterX, mCenterY);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.drawCircle(mCenterX, mCenterY, mCircleRadis - 5, mCirclePaint);
    }

    public void setColor(int color) {
        mCirclePaint.setColor(color);
        invalidate();
    }


    public void setRadis(float radis) {
        mCircleRadis = radis;
        invalidate();
    }

    //那中心點
    public PointF getCenter() {
        return new PointF(getX() + getWidth() / 2, getY() + getHeight() / 2);
    }

    public void setCenter(float cx, float cy) {
        setX(cx - getWidth() / 2);
        setY(cy - getHeight() / 2);
    }

    public void setCenter(PointF point) {
        setCenter(point.x, point.y);
        postInvalidate();
    }

    public float getRadis() {
        return mCircleRadis;
    }

}

Android自定義View阻尼動畫&貝塞爾曲線的實現

效果圖：直接上程式碼啦：package com.example.administrator.myapplication.customview; import android.animation.Animator; import android.animation.Anim

Android自定義View進階 - 貝塞爾曲線

Path之貝塞爾曲線作者微博: @GcsSloop 【本系列相關文章】在

025.自定義View中應用貝塞爾曲線

之前一直看QQ的未讀訊息拖拽消失設計得很好，我一直覺得那個設計很好，他們的UI是真心強，於是，我也一直想寫個一樣的玩意來玩玩。最近剛好在複習View相關的知識，就拿這個來練手，下面先來看實現的效果圖：這是我希望實現的效果，這個效果的實現在第二個圖能看出一點端倪。這裡面的曲線繪製，

自定義view，貝塞爾曲線實現水波紋效果的動畫

作為一名碼農，除了用基本的姿勢去搬磚，還應該get一些炫酷的技能，用高逼格的姿態去搬磚。而貝塞爾曲線無疑是炫酷技能之一。簡介： Bézier curve(貝塞爾曲線)是應用於二維圖形應用程式的數學曲線。曲線定義：起始點、終止點（也稱錨點）、控制點。通過調整控

Android自定義View——貝塞爾曲線實現水波紋進度球

效果圖原理分析首先需要了解的水波紋實現效果，可以在部落格的自定義View專題找到，其實現原理如下利用貝塞爾曲線繪製螢幕外和螢幕內的sin曲線利用path將sin曲線的左下角和右下角連線起來成為一塊區域通過不斷的平移sin曲線，然後平移完

android自定義view --視差動畫

一轉眼又到週末，發現部落格居然兩個月都沒更新了，在不寫點兒什麼，真的就說不過去。前面有寫過一篇自定義view 主要寫的是為原生的控制元件新增自定義的屬性，其基本原理就是在程式碼中為原生的控制元件外面包一層自定義的控制元件，從而使系統能認識我們自定義的屬性，最終達到控制原生控制元件的

從零開始學Android自定義View之動畫系列——屬性動畫（3）

屬性動畫對補間動畫進行了很大幅度的改進，之前補間動畫可以做到的屬性動畫也能做到，補間動畫做不到的現在屬性動畫也可以做到了。因此，今天我們就來學習一下屬性動畫的高階用法，看看如何實現一些補間動畫所無法實現的功能。 ValueAnimator的高階用法補間

Android自定義View教你一步一步實現即刻點贊效果

前言今天朋友看了HenCoder的自定義View後說，HenCoder對自定義View講的不錯。實踐中仿寫即刻的點贊你有思路嗎，你不實現一下？二話不說，看了朋友手機效果，對他說：實現不難，用到了位移，縮放，漸變動畫和自定義View的基礎用法，好，那我實現一下，剛好加深對自定義View的理解。素材準備

Android自定義View之仿QQ側滑選單實現

最近，由於正在做的一個應用中要用到側滑選單，所以通過查資料看視訊，學習了一下自定義View，實現一個類似於QQ的側滑選單，順便還將其封裝為自定義元件，可以實現類似QQ的側滑選單和抽屜式側滑選單兩種選單。下面先放上效果圖：我們這裡的側

android高階動畫——貝塞爾曲線

Android高階動畫所有程式碼簡介：貝塞爾曲線是計算機圖形學中相當重要的引數曲線。可以用數學公式來描述一段曲線。用途：1、貝塞爾曲線可以幫助我們在二維平面內用平滑的曲線畫出各種圖形。 2、同時也可以給動畫提供一個平滑的曲線運動路徑。 android中我們通過Path可

Android自定義 view之圖片裁剪從設計到實現

android圖片剪下是常用的功能，因為部落格開發的是SDK不涉及到activity，所以就需要自定義裁剪功能，參閱了網上的大部分資料後，在github上一個封裝好的裁剪庫cropper，正好符合要求，本著拿來主義的思想，直接把原始碼clone嵌入到專案裡，然後

貝塞爾曲線實現的購物車添加商品動畫效果

right map 繪制開始 enter 監聽 idg 過程 protected 效果圖如下： 1.activity_main.xml <?xml version="1.0" encoding="utf-8"?> <RelativeLayout xm

Android貝塞爾曲線實現水波紋的效果

前兩天朋友找我實現一個水波紋的效果，因為這塊一直沒做過，所以花了一上午時間研究一下，參考了網上的一些方法，得知Android還有Path.quadTo()這麼一個方法。話不多說，程式碼如下： public class MyView extends View implem

一個精美的跳動小球—手把手教你用貝塞爾曲線實現一個酷炫跳動動畫。

前言介紹手把手教你用貝塞爾曲線實現一個精美的跳動的小球。正文效果展示：說點題外話一開始呢，我就想實現一個這樣的效果，於是就新建了一個專案開始擼，結果中間嘗試了幾種實現方案都不是很理想，也有一些條件未能實現就停止開發了，後面又去惡補了一下相關知識，突然在某一天的某一刻的某一瞬間靈感來了

unity 實現物體沿指定的平滑曲線移動（通過貝塞爾曲線實現）

在實際專案開發中，為了實現某種動畫或者特效，策劃都會要求讓物體實現沿編輯的軌跡進行移動，今天這裡就講一下如何讓物體沿可編輯的路線進行移動，這裡主要是通過貝塞爾曲線實現。首先要了解貝塞爾曲線的基礎知識及原理，具體可參考改連結：這裡的思路就是首先就是把關鍵節點儲存起來

Path使用--二階貝塞爾曲線實現水波效果

上面這個效果是使用Path繪製二階貝塞爾曲線實現的；二階貝塞爾曲線涉及到三個點，起始點、拐點、終點，而拐點有決定著曲線的形狀；下面這張圖大致展示了二階貝塞爾曲線： A點是起始點，C點是終點，B點是拐點，當然根據繪製的需求，B是變動的，繪製出來的曲線也就

react-native-art畫二次貝塞爾曲線實現

1、關於react-native ART庫的使用，目前網上能搜到的少之又少，簡書上的一篇react-native-art 繪圖入門，從基本上講解了一下react-native-art的使用方法，但是隻是簡單的橫豎曲線的繪製，但專案中有一個需求就是繪製網速的速率曲線，（專案

Android 自定義View高階特效，神奇的貝塞爾曲線

初始化引數 private static final String TAG = "BIZIER"; private static final int LINEWIDTH = 5; private static final int POINTWIDTH = 10; private Context mContex

Android自定義view進階-- 神奇的貝塞爾曲線

上一篇介紹了自定義view需要知道的基本函式。新開一篇獻給借給我vpn的深圳_奮鬥小哥。轉載請註明出處：http://blog.csdn.net/wingichoy/article/details/50492828 今天給大家介紹一個非常神奇的曲線，貝塞爾曲線。相信大

Android 自定義Path貝塞爾曲線View實踐——旋轉的花朵

開發十年，就只剩下這套架構體系了！ >>>

Android自定義View阻尼動畫&貝塞爾曲線的實現

相關推薦