浮动菜单

效果图：　

　　　　　　　　　　　　　　　　　

1、菜单栏类

/**
 * 1.该控件必须包含3个及以上子控件
 * 2.第一个子控件表示浮动菜单的母菜单，剩余的作为浮动控件的子菜单
 * 3.子菜单和母菜单之间的距离可以修改 RADIUS 的值
 */
public class FloatingMenu extends ViewGroup {
    // 子菜单和母菜单图标距离
    private final static int RADIUS = 400;
    // 当前菜单状态
    private MenuStatu currentStatu = MenuStatu.STATU_CLOSE;

    // 菜单状态枚举
    public enum MenuStatu {
        STATU_OPEN, STATU_CLOSE
    }

    /**
     * 子菜单被点击回调接口
     */
    public interface OnItemMenuClickListener {
        void onItemMenuClick(View view, int position);
    }
    // 子菜单被点击回调接口
    private OnItemMenuClickListener onItemMenuClickListener;
    public void setOnItemMenuClickListener(OnItemMenuClickListener onItemMenuClickListener) {
        this.onItemMenuClickListener = onItemMenuClickListener;
    }
    public FloatingMenu(Context context) {
        super(context);
    }
    public FloatingMenu(Context context, AttributeSet attrs) {
        super(context, attrs);
    }
    public FloatingMenu(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int childCount = getChildCount();

        if (childCount < 3)
            throw new IllegalStateException("当前控件的孩子控件至少需要3个");

        measureChildren(widthMeasureSpec, heightMeasureSpec);
        int tempWidth = getChildAt(1).getMeasuredWidth();
        int tempHeight = getChildAt(childCount - 1).getMeasuredHeight();
        setMeasuredDimension(RADIUS + tempWidth, RADIUS + tempHeight);
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        if (changed) {
            int measuredWidth = getMeasuredWidth();
            int measuredHeight = getMeasuredHeight();
            int childCount = getChildCount();
            // 计算每2个子菜单之间的角度值
            float averageAngle = 90 / (childCount - 1 - 1);

            for (int i = 0; i < childCount; i++) {
                final View childAt = getChildAt(i);
                int childWidth = childAt.getMeasuredWidth();
                int childHeight = childAt.getMeasuredHeight();

                // 第一个子控件是母菜单
                if (i == 0) {
                    int left = measuredWidth - childWidth;
                    int top = measuredHeight - childHeight;
                    childAt.layout(left, top, measuredWidth, measuredHeight);

                    childAt.setOnClickListener(new OnClickListener() {
                        @Override
                        public void onClick(View v) {
                            changeStatuAnim(300);
                        }
                    });
                } else { // 其余的为子菜单
                    final int temp = i;
                    // 计算每一个子菜单的位置
                    float calAngle = (i - 1) * averageAngle;
                    double centerX = RADIUS * Math.cos(Math.PI / 180 * calAngle);
                    double centerY = RADIUS * Math.sin(Math.PI / 180 * calAngle);
                    int left = (int) (measuredWidth - centerX - childWidth);
                    int top = (int) (measuredHeight - centerY - childHeight);
                    int right = (int) (measuredWidth - centerX);
                    int bottom = (int) (measuredHeight - centerY);
                    childAt.layout(left, top, right, bottom);

                    childAt.setVisibility(View.GONE);

                    childAt.setOnClickListener(new OnClickListener() {
                        @Override
                        public void onClick(View v) {
                            if (onItemMenuClickListener != null) {
                                onItemMenuClickListener.onItemMenuClick(childAt, temp);
                            }
                            clickItemAnim(temp);
                        }
                    });
                }
            }
        }
    }

    /**
     * 点击子菜单时的动画效果
     *
     * @param position
     */
    private void clickItemAnim(int position) {
        for (int i = 1; i < getChildCount(); i++) {
            View childAt = getChildAt(i);
            if (i == position) {
                childAt.startAnimation(toBig());
            } else {
                childAt.startAnimation(toSmall());
            }
            childAt.setVisibility(GONE);
        }
        changeStatu();
    }

    /**
     * 变小，变透明
     */
    private Animation toSmall() {
        AnimationSet animationSet = new AnimationSet(true);
        AlphaAnimation alphaAnimation = new AlphaAnimation(1, 0);
        ScaleAnimation scaleAnimation = new ScaleAnimation(1, 0, 1, 0, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
        animationSet.setDuration(200);
        animationSet.addAnimation(alphaAnimation);
        animationSet.addAnimation(scaleAnimation);
        return animationSet;
    }

    /**
     * 变大，变透明
     *
     * @return
     */
    private Animation toBig() {
        AnimationSet animationSet = new AnimationSet(true);
        AlphaAnimation alphaAnimation = new AlphaAnimation(1, 0);
        ScaleAnimation scaleAnimation = new ScaleAnimation(1, 3, 1, 3, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
        animationSet.setDuration(200);
        animationSet.addAnimation(alphaAnimation);
        animationSet.addAnimation(scaleAnimation);
        return animationSet;
    }

    /**
     * 子菜单状态改变动画效果
     *
     * @param durationMillis 动画执行时间
     */
    private void changeStatuAnim(int durationMillis) {
        int childCount = getChildCount();
        for (int i = 1; i < childCount; i++) {
            final View view = getChildAt(i);

            float jiao = 90 / (childCount - 1 - 1);
            float jiJiao = (i - 1) * jiao;
            float toX = (float) (RADIUS * Math.cos(Math.PI / 180 * jiJiao));
            float toY = (float) (RADIUS * Math.sin(Math.PI / 180 * jiJiao));

            AnimationSet animationSet = new AnimationSet(true);
            RotateAnimation rotateAnim = new RotateAnimation(
                    0, 360, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
            TranslateAnimation translateAnimation;
            AlphaAnimation alphaAnimation;
            // 根据子菜单状态实现不同的动画效果
            if (!isOpen()) {
                translateAnimation = new TranslateAnimation(toX, 0, toY, 0);
                alphaAnimation = new AlphaAnimation(0, 1);
            } else {
                translateAnimation = new TranslateAnimation(0, toX, 0, toY);
                alphaAnimation = new AlphaAnimation(1, 0);
            }

            // 注意先添加旋转动画，再添加平移动画
            animationSet.addAnimation(rotateAnim);
            animationSet.addAnimation(translateAnimation);
            animationSet.addAnimation(alphaAnimation);
            animationSet.setDuration(durationMillis);
            animationSet.setAnimationListener(new Animation.AnimationListener() {
                @Override
                public void onAnimationStart(Animation animation) {

                }

                @Override
                public void onAnimationEnd(Animation animation) {
                    if (currentStatu == MenuStatu.STATU_OPEN) {
                        view.setVisibility(View.VISIBLE);
                    } else {
                        view.setVisibility(View.GONE);
                    }
                }

                @Override
                public void onAnimationRepeat(Animation animation) {

                }
            });
            view.startAnimation(animationSet);
        }
        changeStatu();
    }

    /**
     * 改变状态
     */
    private void changeStatu() {
        currentStatu = (currentStatu == MenuStatu.STATU_OPEN) ? MenuStatu.STATU_CLOSE : MenuStatu.STATU_OPEN;
    }

    /**
     * 对外暴露的方法，关闭子菜单
     */
    public void closeMenu() {
        changeStatuAnim(300);
    }

    /**
     * 判断是否打开子菜单
     *
     * @return
     */
    public boolean isOpen() {
        return currentStatu == MenuStatu.STATU_OPEN;
    }
}

 2、布局文件

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <com.example.dell.floatmenudemo.weight.FloatingMenu
        android:id="@+id/floating"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true"
        android:layout_alignParentRight="true"
        android:layout_marginBottom="50dp"
        android:layout_marginRight="50dp">

        <!--第一个子控件表示母菜单-->
        <ImageView
            android:id="@+id/imageViewSwitch"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignParentLeft="true"
            android:layout_alignParentStart="true"
            android:layout_alignParentTop="true"
            android:src="@mipmap/ic_launcher" />

        <!--其余的控件表示子菜单-->
        <ImageView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:src="@mipmap/ic_launcher_round" />

        <ImageView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:src="@mipmap/ic_launcher_round" />

        <ImageView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:src="@mipmap/ic_launcher_round" />

        <ImageView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:src="@mipmap/ic_launcher_round" />

        <ImageView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:src="@mipmap/ic_launcher_round" />

        <ImageView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:src="@mipmap/ic_launcher_round" />
    </com.example.dell.floatmenudemo.weight.FloatingMenu>

</RelativeLayout>

 3、 activity

package com.example.dell.floatmenudemo;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Toast;

import com.example.dell.floatmenudemo.weight.FloatingMenu;
public class MainActivity extends AppCompatActivity {
    private FloatingMenu floating;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        floating = (FloatingMenu) findViewById(R.id.floating);
        initFloatingMenu();
    }
    /**
     * 初始化浮动菜单控件
     */
    private void initFloatingMenu() {
        floating.setOnItemMenuClickListener(new FloatingMenu.OnItemMenuClickListener() {
            @Override
            public void onItemMenuClick(View view, int position) {
                Toast.makeText(MainActivity.this, "子菜单 - " + position, Toast.LENGTH_SHORT).show();
            }
        });
    }
}

 4、 还可以编写 横竖的菜单栏 ，效果如下：

                                            

代码如下：

package com.example.dell.floatmenudemo.weight;

import android.content.Context;
import android.graphics.Camera;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.AlphaAnimation;
import android.view.animation.Animation;
import android.view.animation.AnimationSet;
import android.view.animation.RotateAnimation;
import android.view.animation.ScaleAnimation;
import android.view.animation.TranslateAnimation;

public  class  FloatingActionsMenu extends ViewGroup{
    private static final String TAG = "FloatingActionsMenu";
 //  子控件之间的距离
public   final  static  int DISTANCE = 20;
 // 枚举 菜单栏的状态
public  enum  MenuStatus{STATUS_OPEN,STATUS_CLOSE}
// 当前状态
private  MenuStatus currentStatus = MenuStatus.STATUS_CLOSE;
// 子菜单点击回调接口
    public interface  OnItemMenuClickListener{
        void  onItemMenuClick(View view,int position);// 此方法内对点击作出响应，需实例化
}
//  调用接口封装到方法
    private  OnItemMenuClickListener onItemMenuClickListener;
    public void setOnItemMenuClickListener(OnItemMenuClickListener onItemMenuClickListener){
        this.onItemMenuClickListener = onItemMenuClickListener;
    }
    public FloatingActionsMenu(Context context) {
        super(context);
    }
    public FloatingActionsMenu(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

        //计算 menu 大小
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            int childCount = getChildCount();
            if (childCount<3)throw  new IllegalStateException("当前控件至少需要三个子控件");
            measureChildren(widthMeasureSpec,heightMeasureSpec);
            int tempWidth = getChildAt(0).getMeasuredWidth();
            int tempHeight = getChildAt(0).getMeasuredHeight();

            setMeasuredDimension(tempWidth,(tempHeight+DISTANCE)*childCount);
    }
    // 计算控件位置
    //     changed   是否可以改变
    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        if(changed){
            int measureWidth  = getMeasuredWidth();
            int measureHeidth  = getMeasuredHeight();
            int childCount = getChildCount();
            for(int i = 0 ;i<childCount;i++){
                final  View childAt = getChildAt(i);
                int childWidth = childAt.getMeasuredWidth();
                int childHeight = childAt.getMeasuredHeight();
                // 第一个子控件是菜单栏开关
                if (i==0){
                    int left = 0;
                    int top = (childCount-1-i)*(DISTANCE+childHeight);
                    int right = left+childWidth;
                    int bottom = top+childHeight;
                childAt.layout(left,top,right,bottom);
                childAt.setOnClickListener(new OnClickListener() {
                    @Override
                    public void onClick(View view) {
                        changeStatuAnim(300);
                    }
                });
                }else {
                    // 其余的为 子控件按钮
                    final  int temp = i;
                    int left = 0;
                    int top = (childCount-1-i)*(DISTANCE+childHeight);
                    int right = left+childWidth;
                    int bottom = top+childHeight;
                    childAt.layout(left,top,right,bottom);
                    childAt.setVisibility(View.GONE);
                    childAt.setOnClickListener(new OnClickListener() {
                        @Override
                        public void onClick(View view) {
                            if (onItemMenuClickListener!=null){
                                onItemMenuClickListener.onItemMenuClick(childAt,temp);
                            }
                            clickItemAnim(temp);
                        }
                    });
                }
            }
        }
    }

    /**
     *    点击子菜单时的动画效果
     */
    private void clickItemAnim(int position){
        for (int i=1;i<getChildCount();i++){
            View childAt = getChildAt(i);
            if (i==position){
//                childAt.startAnimation(toBig());
                childAt.startAnimation(rotateAroundY());// Y轴旋转
            }
            childAt.setVisibility(GONE);
        }
        changeStatu();
    }

    /**
     *   变小，变透明
     * @return
     */
    private Animation toSmall(){
        AnimationSet animationSet = new AnimationSet(true);
        AlphaAnimation alphaAnimation = new AlphaAnimation(1,0);// 透明
        animationSet.setDuration(200);// 200 毫秒
        animationSet.addAnimation(alphaAnimation);
        return  animationSet;
    }
    /**
     *    变大,变透明
     */
    private  Animation toBig(){
        AnimationSet animationSet = new AnimationSet(true);
        AlphaAnimation alphaAnimation = new AlphaAnimation(1,0);// 透明
        animationSet.addAnimation(alphaAnimation);
        ScaleAnimation scaleAnimation = new ScaleAnimation(1,3,1,3,Animation.RELATIVE_TO_SELF,0.5f,Animation.RELATIVE_TO_SELF,0.5f);// 变大
        animationSet.setDuration(200);// 200 毫秒
        return  animationSet;
    }
    /**
     *  绕Y 轴旋转
     */
    private  Animation rotateAroundY(){
          RotateToYAnimation rotateToYAnimation = new RotateToYAnimation();
          rotateToYAnimation.setRepeatCount(1);
          return  rotateToYAnimation;
    }
    /**
     *
     *    子菜单状态改变动画效果
     */
    private  void changeStatuAnim(int durationMillis){
        int childCount = getChildCount();
        for (int i = 0;i<childCount;i++){
            final View view = getChildAt(i);
            int toX = 0;
            int toY = (i-1)*view.getHeight()+DISTANCE*i;
            if (i==0){
                //  do something
            }else {

                AnimationSet animationSet = new AnimationSet(true);
                animationSet.setDuration(300);
                RotateAnimation rotateAnimation = new RotateAnimation(0,360,Animation.RELATIVE_TO_SELF,0.5f,Animation.RELATIVE_TO_SELF,0.5f);
                TranslateAnimation translateAnimation;
                AlphaAnimation alphaAnimation;
                // 根据不同的子菜单状态实现不同的效果
                if (!isopen()){
                    translateAnimation = new TranslateAnimation(toX,0,toY,0);
                    alphaAnimation = new AlphaAnimation(0,1);
//                    currentStatus = MenuStatus.STATUS_OPEN;
                }else {
                    translateAnimation = new TranslateAnimation(0,toX,0,toY);
                    alphaAnimation = new AlphaAnimation(1,0);
//                    currentStatus = MenuStatus.STATUS_CLOSE;

                }
                //  先添加旋转 在添加 平移
                animationSet.addAnimation(rotateAnimation);
                animationSet.addAnimation(translateAnimation);
                animationSet.addAnimation(alphaAnimation);
                animationSet.setAnimationListener(new Animation.AnimationListener() {
                    @Override
                    public void onAnimationStart(Animation animation) {

                    }

                    @Override
                    public void onAnimationEnd(Animation animation) {
                        if (currentStatus == MenuStatus.STATUS_OPEN){
                            view.setVisibility(VISIBLE);
                        }else {

                            view.setVisibility(View.GONE);
                        }
                    }
                    @Override
                    public void onAnimationRepeat(Animation animation) {

                    }
                });
                view.startAnimation(animationSet);
            }
        }
        changeStatu();
    }
/**
 *   改变状态
 */
    private  void  changeStatu(){
        currentStatus = (currentStatus== MenuStatus.STATUS_OPEN)?MenuStatus.STATUS_CLOSE:MenuStatus.STATUS_OPEN;
    }

    /**
     *   对外暴露的方法  关闭子菜单
     */

    public  void  closeMenu(){changeStatuAnim(300);}
    /**
     * 判断是否打开  子菜单
     */
    public  boolean isopen(){return  currentStatus==MenuStatus.STATUS_OPEN;}
 }

其中用到 沿Y轴为轴旋转的动画，代码如下：

　　　　

package com.example.dell.floatmenudemo.weight;

import android.graphics.Camera;
import android.graphics.Matrix;
import android.view.animation.Animation;
import android.view.animation.DecelerateInterpolator;
import android.view.animation.Transformation;

/**

 调用代码
 RotateToYAnimation  rotateToYAnimation = new RotateToYAnimation();
 rotateToYAnimation.setRepeatCount(Animation.INFINITE); //翻转无数次
 view.startAnimation(rotateToYAnimation);

 */

public class RotateToYAnimation extends Animation{
private Camera camera = new Camera();
private int centerX ;
private int centerY;

    /**
     *   获取坐标  定义动画时间
     * @param width
     * @param height
     * @param parentWidth
     * @param parentHeight
     */
    @Override
    public void initialize(int width, int height, int parentWidth, int parentHeight) {
        super.initialize(width, height, parentWidth, parentHeight);
        // 获取中心点坐标
        centerX = width/2;
        centerY = width/2;
        //  动画执行时间
        setDuration(200);
        // 内插器
        setInterpolator(new DecelerateInterpolator());
    }

    /**
     *
     *    旋转角度
     * @param interpolatedTime
     * @param t
     */
    @Override
    protected void applyTransformation(float interpolatedTime, Transformation t) {
            final Matrix matrix = t.getMatrix();
            camera.save();
            //  旋转中心是Y轴  可自行设置
            camera.rotateY(360*interpolatedTime);
            //  把 摄像头  加在变换 矩阵上
        camera.getMatrix(matrix);
        //  设置翻转  中心点
        matrix.preTranslate(-centerX,centerY);
        matrix.postTranslate(centerX,centerY);
        camera.restore();
    }
}