可以无限循环，自动旋转，停靠的3D旋转布局控件

分享一个看着不错的效果，看效果图：gitHub地址：https://github.com/dalong982242260/LoopRotarySwitch

效果如上图：

代码实现步骤：

1、首先确定这是一个自定义View，再有就是是一个ViewGroup，那么必须继承Layout（线性相对都可以）

2、需要收拾操作，要使用GestureDetector（手势检测）

3、很明显选择是动画效果，使用ValueAnimation

4、计算旋转的角度，执行动画效果

代码里边都添加了注释，就不细说了。

下边就看代码：

package com.example.looprotaryswitchlibrary.view;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.ListIterator;

import android.animation.Animator;
import android.animation.Animator.AnimatorListener;
import android.animation.ValueAnimator;
import android.animation.ValueAnimator.AnimatorUpdateListener;
import android.annotation.SuppressLint;
import android.content.Context;
import android.os.Message;
import android.util.AttributeSet;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.View;
import android.view.animation.DecelerateInterpolator;
import android.widget.RelativeLayout;

@SuppressLint("NewApi")
public class LoopRotarySwitchView extends RelativeLayout{
	private Context mContext;//上下文
	private GestureDetector mGestureDetector; //手势操作
	private float angle;		//旋转的角度
	private List<View> views = new ArrayList<View>();//子view列表
	private int size; //子控件个数
	private OnItemClickListener mItemClickListener;
	private OnItemSelcetListener mItemSelcetListener;
	private OnLoopViewTouchListener mLoopViewTouchListener;
	private boolean isCanCilckListener = false;  //是否可以点击
	private int selectPosition; //现在所选择的item
	private float last_angle; //最后的角度，用来记录上一次取消touch之后的角度
	private final static int LoopR = 200;
	private float r =  LoopR;
	private float multiple = .8f; //倍数，view之间的比例
	private float distance = multiple * r;  //子view之间的距离
	private boolean touching = false;//判断是否手指在touch
	private float distancX ;//在x轴上边移动的距离
	private float limitX = 30; //滑动的阀值，用来判段能不能点击
	
	private ValueAnimator restAnimator = null;//复位动画
	private ValueAnimator roAnimator = null;//旋转动画
	private boolean isAuto = false;
	private boolean isLeftToRightScroll = true; //默认自动滚动是从右往左
	private AutoScrollHandler mHandler = new AutoScrollHandler(){
		void scroll() {
			if (size != 0) {//判断自动滑动从那边开始
				int perAngle = 0;
				if (isLeftToRightScroll) {
					perAngle = 360 /size;
				}else {
					perAngle = -360/size;
				}
				if (angle == 360) {
					angle = 0f;
				}
				AnimRotationTo(angle + perAngle, null);
			}
		};
	};
	/**
	 * 构造方法
	 * @param context
	 * @param attrs
	 * @param defStyle
	 */
	public LoopRotarySwitchView(Context context, AttributeSet attrs,
			int defStyle) {
		super(context, attrs, defStyle);
		init(context);
	}
	/**
	 * 构造方法
	 * @param context
	 * @param attrs
	 */
	public LoopRotarySwitchView(Context context, AttributeSet attrs) {
		super(context, attrs);
		init(context);
	}
	/**
	 * 构造方法
	 * @param context
	 */
	public LoopRotarySwitchView(Context context) {
		super(context);
		init(context);
	}

	public void init(Context context){
		this.mContext = context;
	
		mGestureDetector = new GestureDetector(mContext, getGestureController());//创建手势对象
	}
	/**
	 * 手势操作改变angle
	 * @return
	 */
	private GestureDetector.SimpleOnGestureListener getGestureController(){
		
		return new GestureDetector.SimpleOnGestureListener(){
			@Override
			public boolean onScroll(MotionEvent e1, MotionEvent e2,
					float distanceX, float distanceY) {
				angle += distanceX/views.size(); //计算滑动的角度
				initView();
				return true;
			}
		};
	}
	
	@Override
	protected void onSizeChanged(int w, int h, int oldw, int oldh) {
		super.onSizeChanged(w, h, oldw, oldh);
		//进行控件界面的初始化
		
		initView();
		if (isAuto) {
			mHandler.sendEmptyMessageDelayed(AutoScrollHandler.messageId, mHandler.scroll_interval);
		}
	}
	private void initView() {
		int width = getWidth();
		for (int i = 0; i < views.size(); i++) {
			float x0 = (float)Math.sin(Math.toRadians(angle + 180 - i * 360 / size)) * r;
			float y0 = (float)Math.cos(Math.toRadians(angle + 180 - i * 360 / size)) * r;
			float  scale0 = (distance - y0) / (distance + r);//计算子view之间的比例，可以看到distance越大的话 比例越小，也就是大小就相差越小
			views.get(i).setScaleX(scale0);//对view进行缩放
			views.get(i).setScaleY(scale0);//对view进行缩放
			views.get(i).setX(width /2 + x0 - views.get(i).getWidth() /2); //设置他的坐标
		}
		List<View > arr = new ArrayList<View>();
		for (int i = 0; i < views.size(); i++) {
			arr.add(views.get(i));
			views.get(i).setTag(i);
		}
		
		sortList(arr);
		postInvalidate();
	}
	//對子View 排序，然后根据变化选中是否重绘,这样是为了实现view 在显示的时候来控制当前要显示的是哪三个view，可以改变排序看下效果
	@SuppressWarnings("unchecked")
	private <T> void sortList(List<View> arr) {
		
		@SuppressWarnings("rawtypes")
		Comparator comparator = new SortComparator();
	    T[] array = arr.toArray((T[]) new Object[arr.size()]);
	   
		Arrays.sort(array, comparator);
		 int i = 0;
	        ListIterator<T> it = (ListIterator<T>) arr.listIterator();
	        while (it.hasNext()) {
	            it.next();
	            it.set(array[i++]);
	        }
		for (int j = 0; j < arr.size(); j++) {
			arr.get(j).bringToFront();
		}
	}
	@Override
	protected void onLayout(boolean changed, int l, int t, int r, int b) {
		super.onLayout(changed, l, t, r, b);
		//对容器中的子view放置位置
		if (changed) {
			checkChildView();
			
			if (mItemSelcetListener != null) {
				isCanCilckListener = true;
				mItemSelcetListener.onSelect(selectPosition, views.get(selectPosition));
			}
			Ranimation();//子view初始化动画
		}
	}
	public void Ranimation(){
		Ranimation(1f, r);
	}
	public void Ranimation(boolean fromZeroToR){
		if (fromZeroToR) {
			Ranimation(1f, LoopR);
		}else {
			Ranimation(LoopR, 1f);
		}
	}
	public void Ranimation(float from, float to) {
		roAnimator = ValueAnimator.ofFloat(from,to);
		roAnimator.addUpdateListener(new AnimatorUpdateListener() {
			
			@Override
			public void onAnimationUpdate(ValueAnimator animation) {
				r = (Float)animation.getAnimatedValue();
				initView();
			}
		});
		
		roAnimator.setInterpolator(new DecelerateInterpolator());
		roAnimator.setDuration(2000);
		roAnimator.start();
		
	}
	public void checkChildView(){
		for (int i = 0; i < views.size(); i++) {//先清空views里边可能存在的view防止重复
			views.remove(i);
		}
		final int count = getChildCount(); //获取子View的个数
		size = count;
		
		for (int i = 0; i < count; i++) {
			View view = getChildAt(i); //获取指定的子view
			final int position = i;
			views.add(view);
			view.setOnClickListener(new OnClickListener() {
				
				@Override
				public void onClick(View v) {
					//对子view添加点击事件
					if (position != calculateItem()) {//
						setSelectItem(position);;
					}else {
						if (isCanCilckListener && mItemClickListener != null) {
							mItemClickListener.onItemClick(position, views.get(position));
						}
					}
				}
			});
			
		}
		
	}
	/**
	 * 设置所选中的item
	 * @param selectItem
	 */
	public void setSelectItem(int selectItem){
		if (selectItem >= 0) {
			float corner = 0;
			if (getSelectPosition() == 0) {
				if (selectItem == views.size() - 1) {
					corner = angle - (360 / size);
				}else {
					corner = angle +(360 / size);
				}
			}else if (getSelectPosition() == views.size() - 1) {
				if (selectItem == 0) {
					corner = angle + (360 / size);
				}else {
					corner = angle - (360 /size);
				}
			}else {
				
				if (selectItem > getSelectPosition()) {
					corner = angle +(360 /size);
				}else {
					corner = angle - (360 /size);
				}
			}
			
			float position = 0 ;
			float per = 360 /size;
			if (corner < 0) {
				per = -per;
			}
			
			float minValue = (int)(corner /per) * per;
			float maxValue = (int)(corner / per) * per;
			if (corner >= 0) {
				if (corner - last_angle > 0) {
					position = maxValue;
				}else {
					position = minValue;
				}
			}else {
				if (corner - last_angle < 0) {
					position = maxValue;
				}else {
					position = minValue;
				}
			}
			if (size > 0) {//旋转动画
				AnimRotationTo(position, null);
			}
		}
	}
	public float getAngle() {
		return angle;
	}
	public void setAngle(float angle) {
		this.angle = angle;
	}
	public void setmItemClickListener(OnItemClickListener mItemClickListener) {
		this.mItemClickListener = mItemClickListener;
	}
	public void setmItemSelcetListener(OnItemSelcetListener mItemSelcetListener) {
		this.mItemSelcetListener = mItemSelcetListener;
	}
	public void setmLoopViewTouchListener(
			OnLoopViewTouchListener mLoopViewTouchListener) {
		this.mLoopViewTouchListener = mLoopViewTouchListener;
	}
	/**
	 * 计算现在选中item
	 * @return
	 */
	public int calculateItem(){
		return (int)(angle / ( 360 / size)) % size;
	}

	public int getSelectPosition() {
		return selectPosition;
	}
	
	public float getR() {
		return r;
	}
	public LoopRotarySwitchView setR(float r) {
		this.r = r;
		distance = multiple * r;
		return this;
		
	}
	private  boolean onTouch(MotionEvent event){
		
		if (event.getAction() == MotionEvent.ACTION_DOWN) {
			last_angle = angle ;
			touching = true;
		}
		boolean sc = mGestureDetector.onTouchEvent(event);
		if (sc) {
			this.getParent().requestDisallowInterceptTouchEvent(true);
		}
		if (event.getAction() == MotionEvent.ACTION_UP || event.getAction() == MotionEvent.ACTION_CANCEL) {
			touching = false;
			restPosition();//重置
			return true;
			
		}
		return true;
	}
	
	private void restPosition() {
		if (size == 0) {
			return ;
		}
		
		float position = 0;
		float per = 360 /size;
		if (angle < 0) {
			per = -per;
		}
		
		float minValue = (int)(angle / per) * per;
		float maxValue = (int)(angle / per) * per + per;
		if (angle > 0) {
			if (angle -last_angle > 0) {
				position = maxValue;
			}else {
				position = minValue;
			}
			
		}else {
			if (angle - last_angle > 0) {
				position  = maxValue;
			}else {
				position = minValue;
			}
		}
		
		AnimRotationTo(position,null);
	}
	/**
	 * 动画
	 * @param position
	 * @param object
	 */
	private void AnimRotationTo(float position, final Runnable runnable) {
		if (angle == position) {//如果相同说明不需要旋转
			return;
		}
		restAnimator = ValueAnimator.ofFloat(angle,position);
		restAnimator.setInterpolator(new DecelerateInterpolator());//设置旋转减速插值器
		restAnimator.setDuration(300);
		restAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
			
			@Override
			public void onAnimationUpdate(ValueAnimator animation) {
				if (touching == false) {
					angle = (Float)animation.getAnimatedValue();
					initView();
				}
			}
		});
		
		restAnimator.addListener(new AnimatorListener() {
			
			@Override
			public void onAnimationStart(Animator animation) {
				
			}
			
			@Override
			public void onAnimationRepeat(Animator animation) {
				
			}
			
			@Override
			public void onAnimationEnd(Animator animation) {
				if (touching == false) {
					selectPosition = calculateItem();
				}
				if (mItemSelcetListener != null) {
					mItemSelcetListener.onSelect(selectPosition, views.get(selectPosition));
				}
			}
			
			@Override
			public void onAnimationCancel(Animator animation) {
				
			}
		});
		
		if (runnable != null) {
			restAnimator.addListener(new AnimatorListener() {
				
				@Override
				public void onAnimationStart(Animator animation) {
					
				}
				
				@Override
				public void onAnimationRepeat(Animator animation) {
					
				}
				
				@Override
				public void onAnimationEnd(Animator animation) {
					runnable.run();
				}
				
				@Override
				public void onAnimationCancel(Animator animation) {
					// TODO Auto-generated method stub
					
				}
			});
		}
		restAnimator.start();
		
	}
	@Override
	public boolean onTouchEvent(MotionEvent event) {
		if (mLoopViewTouchListener != null) {
			mLoopViewTouchListener.onTouch(event);
		}
		isCanClickListener(event);
		return true;
	}
	
	@Override
	public boolean dispatchTouchEvent(MotionEvent ev) {
		onTouch(ev);
		if (mLoopViewTouchListener != null) {
			mLoopViewTouchListener.onTouch(ev);
		}
		isCanClickListener(ev);
		return super.dispatchTouchEvent(ev);
	}
	
	public void isCanClickListener(MotionEvent event){
		switch (event.getAction()) {
		case MotionEvent.ACTION_DOWN:
			distancX = event.getX();
			if (isAuto) {
				mHandler.removeMessages(AutoScrollHandler.messageId);
			}
			
			break;
		case MotionEvent.ACTION_CANCEL:
		case MotionEvent.ACTION_UP:
			if (isAuto) {
				mHandler.sendEmptyMessageDelayed(AutoScrollHandler.messageId,  mHandler.scroll_interval);
			}
			if (event.getX() - distancX > limitX || distancX - event.getX() > limitX) {
				isCanCilckListener = false;
			}else{
				isCanCilckListener = true;
			}
			break;
		case MotionEvent.ACTION_MOVE:
			
			break;

		default:
			break;
		}
		
	}
	/**
	 * 自动滚动
	 */
	public void AutoScroll() {
		angle  = angle + (360/size);
		initView();
	}
	public boolean isAuto() {
		return isAuto;
	}
	public void setAuto(boolean isAuto) {
		this.isAuto = isAuto;
	}
	public boolean isLeftScroll() {
		return isLeftToRightScroll;
	}
	public void setLeftScroll(boolean isLeftToRightScroll) {
		this.isLeftToRightScroll = isLeftToRightScroll;
	}
	
	public void setScrollInterval(long time){
		if (mHandler != null) {
			mHandler.setScroll_interval(time);
		}
	}
}

</pre><pre code_snippet_id="1651394" snippet_file_name="blog_20160418_3_3380648" name="code" class="java">

监听器接口类：

package com.example.looprotaryswitchlibrary.view;

import android.view.View;

public interface OnItemClickListener {
	void onItemClick(int position,View view);
}

package com.example.looprotaryswitchlibrary.view;

import android.view.View;

public interface OnItemSelcetListener {
	void onSelect(int position, View View);
}

package com.example.looprotaryswitchlibrary.view;

import android.view.MotionEvent;

public interface OnLoopViewTouchListener {
	void onTouch(MotionEvent event);
}

自定义排序算法

package com.example.looprotaryswitchlibrary.view;

import java.util.Comparator;
import android.annotation.SuppressLint;
import android.view.View;

public class SortComparator implements Comparator<View>{
	
	@SuppressLint("NewApi")
	@Override
	public int compare(View lhs, View rhs) {
		int result = 0;
		
		result = (int)(1000 * lhs.getScaleX() - 1000 * rhs.getScaleX());
		return result;
	}

}

自动滑动Handler回调：

package com.example.looprotaryswitchlibrary.view;

import android.os.Handler;
import android.os.Message;

public abstract class AutoScrollHandler extends Handler{
	
	 long  scroll_interval = 3000;//自动滚动时间间隔，默认值
	final static int messageId = 1000;
	@Override
	public void handleMessage(Message msg) {
		// TODO Auto-generated method stub
		
		int what = msg.what;
		switch (what) {
		case messageId:
			scroll();
			sendMessage();
			break;

		default:
			break;
		}
		super.handleMessage(msg);
	}
	public long getScroll_interval() {
		return scroll_interval;
	}
	public void setScroll_interval(long scroll_interval) {
		this.scroll_interval = scroll_interval;
	}

	public void sendMessage(){
		removeMessages(messageId);
		sendEmptyMessageDelayed(messageId,scroll_interval);
	}
	abstract void scroll();

}

主要代码就是这么多。

Demo下载地址：http://download.csdn.net/detail/u012808234/9494457