本帅由于最近项目需要一种类似中国电信首页这样的特效，于是我就去下载了一个看了一下，还不错。我艹又在这扯犊子干哈，别tm浪灰我时间S比，代你们说了哈

首先看看中国电信首页(其实还有其他特效，不错这个app)

中国电信首页

没做过啊，刚开始自己想的是自定义一个布局里面装子控件按照圆形来排列，然后旋转这个布局，想着是没毛病啊，但是我这个人技术不咋地，自己敲估计是敲不出来了，先看看人家怎么写的吧，然后我们同事说这个就是旋转木马特效啊，我靠“旋转木马”感觉瞬间就高大上了

于是我就找了一下旋转木马的特效 找到如下这种的

旋转木马式

如果只需要这个的就不用往下看了，毕竟时间就是代码，代码就是钱啊

该项目的链接：非常方便的引用 去吧

然后感觉不对啊我要的洗过也没这么复杂啊

于是我就找到了这个东西，圆形的菜单，那咱们先看看他的真身是啥

就是这个

这个妖怪呢可以说是旋转，交换(两个点相互交换)，事件监听那是样样精通啊

那么只需要这个东西的慢走不送

好吧，那看一下我修改后的妖孽吧

这啥玩意儿啊

好吧 开始我的搬运工表演

第一个就不说了，贼猛

第二个如果不想去下载的直接copy吧

这就是一个自定义VIew RoundSpinView.java

packagechege.zycf.com.testroate.view;
importandroid.content.Context;
importandroid.content.res.TypedArray;
importandroid.graphics.Bitmap;
importandroid.graphics.BitmapFactory;
importandroid.graphics.Canvas;
importandroid.graphics.Color;
importandroid.graphics.DashPathEffect;
importandroid.graphics.Paint;
importandroid.graphics.PaintFlagsDrawFilter;
importandroid.graphics.PathEffect;
importandroid.graphics.Rect;
importandroid.os.Handler;
importandroid.os.Message;
importandroid.util.AttributeSet;
importandroid.util.Log;
importandroid.view.GestureDetector;
importandroid.view.GestureDetector.SimpleOnGestureListener;
importandroid.view.MotionEvent;
importandroid.view.View;
importchege.zycf.com.testroate.R;
/**
* 圆盘式的view
*
*@authorboy
*
*/
public classRoundSpinViewextendsView {
privatePaintmPaint=newPaint();
privatePaintFlagsDrawFilterpfd;
private intstartMenu;//菜单的第一张图片的资源id
// stone列表
privateBigStone[]mStones;
// 数目
private static final intSTONE_COUNT=20;
// 圆心坐标
private intmPointX=0,mPointY=0;
// 半径
private intmRadius=0;
// 每两个点间隔的角度
private intmDegreeDelta;
private intmenuRadius;// 菜单的半径
private intmCur= -1;// 正在被移动的menu;
private boolean[]quadrantTouched;//对每个象限触摸情况的记录
// Touch detection
privateGestureDetectormGestureDetector;
privateonRoundSpinViewListenermListener;//自定义事件监听器
private final static intTO_ROTATE_BUTTON=0;//旋转按钮；
privateHandlerhandler=newHandler(){
public voidhandleMessage(Message msg) {
switch(msg.what) {
caseTO_ROTATE_BUTTON:
floatvelocity = Float.parseFloat(msg.obj.toString());
rotateButtons(velocity/75);
velocity /=1.0666F;
newThread(newFlingRunnable(velocity)).start();
break;
default:
break;
}
};
};
public interfaceonRoundSpinViewListener{
public voidonSingleTapUp(intposition);//监听每个菜单的单击事件
}
publicRoundSpinView(Context context,AttributeSet attrs) {
super(context,attrs);
if(attrs!=null){
TypedArray a = getContext().obtainStyledAttributes(attrs,
R.styleable.RoundSpinView);
startMenu= a.getResourceId(R.styleable.RoundSpinView_menuStart,0);
}
pfd=newPaintFlagsDrawFilter(0,Paint.ANTI_ALIAS_FLAG|Paint.FILTER_BITMAP_FLAG);
mPaint.setColor(Color.WHITE);
mPaint.setStrokeWidth(2);
mPaint.setAntiAlias(true);//消除锯齿
mPaint.setStyle(Paint.Style.STROKE);//绘制空心圆
PathEffect effects =newDashPathEffect(new float[]{5,5,5,5},1);
mPaint.setPathEffect(effects);
quadrantTouched=new boolean[] {false, false, false, false, false};
mGestureDetector=newGestureDetector(getContext(),
newMyGestureListener());
setupStones();
}
@Override
protected voidonMeasure(intwidthMeasureSpec, intheightMeasureSpec) {
//TODO Auto-generated method stub
super.onMeasure(widthMeasureSpec,heightMeasureSpec);
mPointX=this.getMeasuredWidth()/2;
mPointY=this.getMeasuredHeight()/2;
//初始化半径和菜单半径
// mRadius = mPointX-mPointX/5;
// 修改过的
mRadius=600;
mPointY=mPointX-200;
menuRadius= (int)(mPointX/5.5);
//修改过的
computeCoordinates();
}
/**
* 初始化每个点
*/
private voidsetupStones() {
mStones=newBigStone[STONE_COUNT];
BigStone stone;
intangle =270;
mDegreeDelta=360/STONE_COUNT;
for(intindex =0;index
stone =newBigStone();
if(angle >=360) {
angle -=360;
}else if(angle <0){
angle +=360;
}
stone.angle= angle;
stone.bitmap= BitmapFactory.decodeResource(getResources(),
startMenu+ index %3);//修改过的
angle +=mDegreeDelta;
mStones[index] = stone;
}
}
/**
* 重新计算每个点的角度
*/
private voidresetStonesAngle(floatx, floaty) {
intangle = computeCurrentAngle(x,y);
Log.d("RoundSpinView","angle:"+ angle);
for(intindex =0;index
mStones[index].angle= angle;
angle +=mDegreeDelta;
}
}
/**
* 计算每个点的坐标
*/
private voidcomputeCoordinates() {
BigStone stone;
for(intindex =0;index
stone =mStones[index];
stone.x=mPointX
+ (float) (mRadius* Math.cos(Math.toRadians(stone.angle)));
stone.y=mPointY
+ (float) (mRadius* Math.sin(Math.toRadians(stone.angle)));
}
}
/**
* 计算某点的角度
*
*@paramx
*@paramy
*@return
*/
private intcomputeCurrentAngle(floatx, floaty) {
floatdistance = (float) Math
.sqrt(((x -mPointX) * (x -mPointX) + (y -mPointY)
* (y -mPointY)));
intdegree = (int) (Math.acos((x -mPointX) / distance) *180/ Math.PI);
if(y
degree = -degree;
}
Log.d("RoundSpinView","x:"+ x +",y:"+ y +",degree:"+ degree);
returndegree;
}
private doublestartAngle;
@Override
public booleandispatchTouchEvent(MotionEvent event) {
// resetStonesAngle(event.getX(), event.getY());
// computeCoordinates();
// invalidate();
intx,y;
if(event.getAction() == MotionEvent.ACTION_DOWN) {
x = (int) event.getX();
y = (int) event.getY();
mCur= getInCircle(x,y);
if(mCur== -1) {
startAngle= computeCurrentAngle(x,y);
}
}else if(event.getAction() == MotionEvent.ACTION_MOVE) {
x = (int) event.getX();
y = (int) event.getY();
if(mCur!= -1) {
mStones[mCur].x= x;
mStones[mCur].y= y;
invalidate();
}else{
doublecurrentAngle = computeCurrentAngle(x,y);
rotateButtons(startAngle- currentAngle);
startAngle= currentAngle;
}
}else if(event.getAction() == MotionEvent.ACTION_UP) {
x = (int) event.getX();
y = (int) event.getY();
if(mCur!= -1) {
computeCoordinates();
intcur = getInCircle(x,y);
if(cur !=mCur&& cur != -1) {
intangle =mStones[mCur].angle;
mStones[mCur].angle=mStones[cur].angle;
mStones[cur].angle= angle;
}
computeCoordinates();
invalidate();
mCur= -1;
}
}
// set the touched quadrant to true
quadrantTouched[getQuadrant(event.getX() -mPointX,
mPointY- event.getY())] =true;
mGestureDetector.onTouchEvent(event);
return true;
}
private classMyGestureListenerextendsSimpleOnGestureListener {
@Override
public booleanonFling(MotionEvent e1,MotionEvent e2, floatvelocityX,
floatvelocityY) {
// get the quadrant of the start and the end of the fling
intq1 =getQuadrant(e1.getX() -mPointX,mPointY- e1.getY());
intq2 =getQuadrant(e2.getX() -mPointX,mPointY- e2.getY());
// the inversed rotations
if((q1 ==2&& q2 ==2&& Math.abs(velocityX) < Math
.abs(velocityY))
|| (q1 ==3&& q2 ==3)
|| (q1 ==1&& q2 ==3)
|| (q1 ==4&& q2 ==4&& Math.abs(velocityX) > Math
.abs(velocityY))
|| ((q1 ==2&& q2 ==3) || (q1 ==3&& q2 ==2))
|| ((q1 ==3&& q2 ==4) || (q1 ==4&& q2 ==3))
|| (q1 ==2&& q2 ==4&&quadrantTouched[3])
|| (q1 ==4&& q2 ==2&&quadrantTouched[3])) {
// CircleLayout.this.post(new FlingRunnable(-1
// * (velocityX + velocityY)));
newThread(newFlingRunnable(velocityX+velocityY)).start();
}else{
// the normal rotation
// CircleLayout.this
// .post(new FlingRunnable(velocityX + velocityY));
newThread(newFlingRunnable(-(velocityX+velocityY))).start();
}
return true;
}
@Override
public booleanonSingleTapUp(MotionEvent e) {
intcur = getInCircle((int)e.getX(),(int)e.getY());
if(cur!=-1){
if(mListener!=null){
mListener.onSingleTapUp(cur);
}
// Toast.makeText(getContext(), "position:"+cur, 0).show();
return true;
}
return false;
}
}
private classFlingRunnableimplementsRunnable{
private floatvelocity;
publicFlingRunnable(floatvelocity){
this.velocity= velocity;
}
@Override
public voidrun() {
//TODO Auto-generated method stub
if(Math.abs(velocity)>=200){
Message message = Message.obtain();
message.what=TO_ROTATE_BUTTON;
message.obj=velocity;
handler.sendMessage(message);
}
}
}
/**
*@returnThe selected quadrant.
*/
private static intgetQuadrant(doublex, doubley) {
if(x >=0) {
returny >=0?1:4;
}else{
}
returny >=0?2:3;
}
/*
* 旋转菜单按钮
*/
private voidrotateButtons(doubledegree) {
for(inti =0;i
mStones[i].angle-= degree;
if(mStones[i].angle<0) {
mStones[i].angle+=360;
}else if(mStones[i].angle>=360){
mStones[i].angle-=360;
}
}
computeCoordinates();
invalidate();
}
@Override
public voidonDraw(Canvas canvas) {
//画一个白色的圆环
canvas.drawCircle(mPointX,mPointY,mRadius,mPaint);
//将每个菜单画出来
for(intindex =0;index
if(!mStones[index].isVisible)
continue;
drawInCenter(canvas,mStones[index].bitmap,mStones[index].x,
mStones[index].y);
}
}
/**
* 把中心点放到中心处
*
*@paramcanvas
*@parambitmap
*@paramleft
*@paramtop
*/
private voiddrawInCenter(Canvas canvas,Bitmap bitmap, floatleft,
floattop) {
Rect dst =newRect();
dst.left= (int) (left -menuRadius);
dst.right= (int) (left +menuRadius);
dst.top= (int) (top -menuRadius);
dst.bottom= (int) (top +menuRadius);
canvas.setDrawFilter(pfd);
canvas.drawBitmap(bitmap, null,dst,mPaint);
}
private intgetInCircle(intx, inty) {
for(inti =0;i
BigStone stone =mStones[i];
intmx = (int) stone.x;
intmy = (int) stone.y;
if(((x - mx) * (x - mx) + (y - my) * (y - my))
*menuRadius) {
returni;
}
}
return-1;
}
public voidsetOnRoundSpinViewListener(onRoundSpinViewListener listener){
this.mListener= listener;
}
classBigStone {
// 图片
Bitmapbitmap;
// 角度
intangle;
// x坐标
floatx;
// y坐标
floaty;
// 是否可见
booleanisVisible=true;
}
}

自定义属性里面 attrs

使用和监听

就是这个鬼

这两个东西我合在了一起，源码稍后为大家附上，请骚等各位大爷。大妹子

嘿嘿 传上去了 我的git去吧