Android 实现旋转键盘的例子

最新推荐文章于 2022-06-14 16:06:43 发布
最新推荐文章于 2022-06-14 16:06:43 发布
阅读量1.6k 收藏 2
点赞数
分类专栏： Android 文章标签： 算法 布局 boolean Android menu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qqMCY/article/details/11918329
版权
本文通过实例代码介绍了Android中如何实现旋转键盘的功能，包括关键类DJItemImageView、DJRotateRelativeLayout和DJRotateMenuView的详细讲解，配合示例图展示了旋转键盘的效果。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >



效果图



单个图片的类

DJItemImageView.java

package com.ldci.djrotatemenuforandroid;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.graphics.drawable.BitmapDrawable;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.RelativeLayout;


public class DJItemImageView extends RelativeLayout implements OnClickListener{

	public ImageView imageView;
	
	public DJItemImageView(Context context) {
		super(context);
		//this.setBackgroundColor(Color.GREEN);

		
		
		//设置该布局的属性
		RelativeLayout.LayoutParams lp1 = new RelativeLayout.LayoutParams(LayoutParams.WRAP_CONTENT,LayoutParams.WRAP_CONTENT);
		lp1.addRule(RelativeLayout.CENTER_HORIZONTAL);
		lp1.addRule(RelativeLayout.CENTER_VERTICAL);
	
		
		
		// TODO Auto-generated constructor stub
		imageView = new ImageView(context);
		imageView.setRotation(180);
		
		
		Bitmap bitmap = ((BitmapDrawable)getResources().getDrawable(R.drawable.ui_navi_course_in)).getBitmap();
		
		//设置图片的属性
		RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(bitmap.getWidth(), bitmap.getHeight());
		//RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
		
	
		lp.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
		
		lp.addRule(RelativeLayout.CENTER_VERTICAL);
		
		
		imageView.setLayoutParams(lp);
		
		//imageView.setImageBitmap(bitmap);
		
		imageView.setOnClickListener(this);
		

		this.addView(imageView);
		
	//	lp1.width = bitmap.getWidth() * 3;
	//	lp1.height = bitmap.getHeight();
		this.setLayoutParams(lp1);


		
	}

	
	
	
	public void setImageTag(int tagId) {
		imageView.setId(tagId);
		Log.i("image", "imageItem tag" + tagId);
	}
	
	
	
	
	
	public void djsetImageResources(int imageId) {
		Bitmap bitmap = ((BitmapDrawable)getResources().getDrawable(imageId)).getBitmap();
		imageView.setImageBitmap(bitmap);
		
	}
	
	
	
	
	
	@Override
	public void onClick(View v) {
		
		Log.i("image", "1111111111111111111111111111" + v.getId());
		// TODO Auto-generated method stub
		switch (v.getId()) {
		case 1001:
			Log.i("image", "1111111111111111111111111111");
			break;

		case 1002:
			Log.i("image", "222222222222222222222222222222");
			break;
		case 1003:
			Log.i("image", "33333333333333333333333333333");
			break;
			
		case 1004:
			Log.i("image", "444444444444444444444444444");
			break;
			
		case 1005:
			Log.i("image", "5555555555555555555555555555");
			break;
			
		case 1006:
			Log.i("image", "66666666666666666666666666");
			break;
			
		case 10000:
			Log.i("image", "777777777777777777777");
			break;
			
			
			
		default:
			break;
		}
		
	}
	

}


6个图片的第一次集合类

DJRotateRelativeLayout.java

package com.ldci.djrotatemenuforandroid;

import java.util.ArrayList;

import android.R.integer;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.graphics.drawable.BitmapDrawable;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.RelativeLayout.LayoutParams;

public class DJRotateRelativeLayout extends RelativeLayout{

	private int imageIdsDefault[] = {R.drawable.ui_navi_home,R.drawable.ui_navi_feature,R.drawable.ui_navi_course,R.drawable.ui_navi_listen,R.drawable.ui_navi_play,R.drawable.ui_navi_more};
	
	
	
	private int imageIdsIn[] = {R.drawable.ui_navi_home_in,R.drawable.ui_navi_feature_in,R.drawable.ui_navi_course_in,R.drawable.ui_navi_listen_in,R.drawable.ui_navi_play_in,R.drawable.ui_navi_more_in};
	
	private ArrayList<DJItemImageView> djArrayList;
	
	

	
	
	public DJRotateRelativeLayout(Context context) {
		super(context);
		// TODO Auto-generated constructor stub
		//初始化一个数字
		djArrayList = new ArrayList<DJItemImageView>();
		

		
		
		this.setBackgroundColor(Color.TRANSPARENT);
		
RelativeLayout.LayoutParams bglp = new RelativeLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
		
		bglp.addRule(RelativeLayout.CENTER_HORIZONTAL);
		bglp.addRule(RelativeLayout.CENTER_VERTICAL);
		this.setLayoutParams(bglp);
		//this.setOnTouchListener(this);
		
		ImageView bgImageViewimageView = new ImageView(context);
		bgImageViewimageView.setLayoutParams(bglp);
		
		
		Bitmap bgbitmap = ((BitmapDrawable)getResources().getDrawable(R.drawable.ui_navi_bg)).getBitmap();
		bgImageViewimageView.setImageBitmap(bgbitmap);
		this.addView(bgImageViewimageView);
		
		
		
		
		RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
	//	lp.addRule(CENTER_VERTICAL);
		
		this.setLayoutParams(lp);

		
		for (int i = 1; i < 7; i++) {
			
			DJItemImageView djItemImageView = new DJItemImageView(context);
			djItemImageView.setRotation(240- (60 * i));
			djArrayList.add(djItemImageView);
			
			int tagItem = i + 1000;
			djItemImageView.setImageTag(tagItem);
			
			djItemImageView.djsetImageResources(imageIdsDefault[i - 1]);
			
			
			
			System.out.println(tagItem);
			
			
			this.addView(djItemImageView);
		}
		
		
		
		
		
		
		
		
		
		
		
		
		
	}
	
	public void changeImageDefaultResources(int imageId) {
		
		DJItemImageView inDjItemImageView = djArrayList.get(imageId);
		inDjItemImageView.djsetImageResources(imageIdsDefault[imageId]);
	}
	

	
	public void  changeImageResoures(int imageId) {
		System.out.println(imageId);
		DJItemImageView inDjItemImageView = djArrayList.get(imageId);
		inDjItemImageView.djsetImageResources(imageIdsIn[imageId]);

	}
	
	
	
	
	
}

处理旋转功能的类

DJRotateMenuView.java

package com.ldci.djrotatemenuforandroid;




import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.graphics.PointF;
import android.graphics.drawable.BitmapDrawable;
import android.widget.AbsoluteLayout;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.RelativeLayout.LayoutParams;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.animation.Animation;
import android.view.animation.TranslateAnimation;
import android.view.animation.Animation.AnimationListener;
import android.view.animation.RotateAnimation;

public class DJRotateMenuView extends RelativeLayout implements AnimationListener,OnClickListener{
	
	
	//角度
	private double angle;
	//旋转角度
	private double rotate;
	//现在的角度
	private double nowDegress;
 	private double  previousDegress;
	//计算角度变化的数据
	private double degressNum;
	//按钮间的夹角
	private double djDegressBtn;
	//当前的角度
	private double currentDegree;
	
	//屏幕的宽
	private float winSizeWidth;
	//高
	private float winSizeHeight;
	
	private boolean selectBoolean;
	
	//上一次触摸点的坐标
	private PointF previousPointF;
	
	//目标位置
	private float destinationAngle;
	
	private int previousimageId;
	
	private int currentImageId = 0;
	
	private int previousImageNum = 90;
	
	//private ImageView btnImageView;

	//private TranslateAnimation translateAnimation;
	
	//private RotateAnimation rotateAnimation;
	
	
	
// private	boolean calBool = true;
	//中心的点坐标  。。。。。临时 设置的屏幕中心
	PointF centerPointF;
	//当前计算机1秒钟的计算能力
	int myComputerCalculate = 0;
	
	private DJRotateRelativeLayout djRotateRelativeLayout;
	
	
	public DJRotateMenuView(Context context,float tempWidth,float tempHeight) {
		super(context);
	//	this.setBackgroundColor(Color.BLUE);
		this.winSizeWidth = tempWidth;
		this.winSizeHeight = tempHeight;
		this.centerPointF = new PointF(this.winSizeWidth / 2, this.winSizeHeight / 2);
		
		previousimageId = 0;
		djDegressBtn = 360 / 6;

		
//		AbsoluteLayout.LayoutParams new_params = new AbsoluteLayout.LayoutParams((int)this.winSizeWidth, (int)this.winSizeHeight, (int)this.winSizeWidth, (int)this.winSizeHeight / 2);
		
		djRotateRelativeLayout  = new DJRotateRelativeLayout(context);
//		djRotateRelativeLayout.setLayoutParams(new_params);
		
		this.addView(djRotateRelativeLayout);
	//	djRotateRelativeLayout.setRotation(120);
		
		
		
		
		//设置图片
		djRotateRelativeLayout.changeImageResoures((int)(djRotateRelativeLayout.getRotation() / djDegressBtn));
		
		degressNum = 0;
		
		
//		btnImageView = new ImageView(context);
//		btnImageView.setId(987654);
//		btnImageView.setOnClickListener(this);
//		
//		Bitmap btnBitmap = ((BitmapDrawable)getResources().getDrawable(R.drawable.ui_navi_triangle)).getBitmap();
//		RelativeLayout.LayoutParams btnlp = new RelativeLayout.LayoutParams(btnBitmap.getWidth(),btnBitmap.getHeight());
//		btnImageView.setImageBitmap(btnBitmap);
//		btnlp.addRule(RelativeLayout.CENTER_HORIZONTAL);
//		btnlp.addRule(RelativeLayout.CENTER_VERTICAL);
//		//btnlp.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
//	
//		btnImageView.setLayoutParams(btnlp);
//		this.addView(btnImageView);
		//btnlp.alignWithParent = false;
		
		
		
		
		
		
		
		

	

	}

	public void djTouchBegin(PointF touchPointF) {

		double distance = djDistance(touchPointF, this.centerPointF);
	//获取当前图片ID
		
		
		
		System.out.println("distance " + distance);
		
	}
	
	public void djTouchMove(PointF touchPointF) {
		
		PointF previousLocationF = previousPointF;
		//角度差
		PointF previousCGP = djCgpSub(previousLocationF, centerPointF);
		
		double previousVector = djToAngle(previousCGP);
		
		previousDegress = dj_Radians_To_Degrees(previousVector);
		
		PointF nowLocation = touchPointF;
		PointF nowCGP = djCgpSub(nowLocation, centerPointF);
		
		double nowVector = djToAngle(nowCGP);
		nowDegress = dj_Radians_To_Degrees(nowVector);
		
		//在这里判断角度
	
		angle = -(nowDegress - previousDegress);
		currentDegree = djRotateRelativeLayout.getRotation();
		
		//degressNum += angle;
		
		
		angle += currentDegree;
		
		
	
		
		djSetRotate(angle);
		
		
		
		
		
		//djChangeImageView();
		
		
		
	}
	
	
	public void djChangeImageView() {
		
		
		float tempCurrentAngle =  djRotateRelativeLayout.getRotation();
		
		
		System.out.println("tempCurrentAngle" + tempCurrentAngle);
		
		
		double currentAngle = djRotateRelativeLayout.getRotation();
		double currentSub;
		 currentSub = currentAngle / djDegressBtn;
		 int temp = (int)currentSub;
		 
		 currentSub = currentAngle -djDegressBtn * temp;
		 if (currentSub > 0) 
		 {
			if (temp != previousImageNum) {
				if (currentSub > djDegressBtn / 2) {
					currentImageId += 1;
				}
			} 
			 
			
		}else if (currentSub < 0) {
			
			if (temp != previousImageNum) {
				currentImageId -= 1;
			}
			
			
			
		}
		 previousImageNum = temp;
		 
		 if (currentImageId < 0) {
			currentImageId += 6;
		}
		 
		 
		 
		
//		if (tempCurrentAngle > 0) {
//			
//			tempCurrentAngle += djDegressBtn / 2;
//		}
//		else if(tempCurrentAngle < 0){
//			tempCurrentAngle -= djDegressBtn / 2;
//		}
//		int btnTypeNum = (int)((tempCurrentAngle + djDegressBtn / 2) / (djDegressBtn));
//		btnTypeNum = (int)tempCurrentAngle / (int)djDegressBtn;
//		
//		float currentSub = tempCurrentAngle - (float)djDegressBtn * btnTypeNum;
//		

		
		
//		System.out.println("btnTypeNum" + btnTypeNum);

//		//btnTypeNum = 6-btnTypeNum;
//		System.out.println("btnTypeNum" + btnTypeNum);

		
		
	}
	

	public void djTouchEnd(float touchX,float touchY) {
		calculateDegress();
		//djChangeImageView();
	}
	
	
	public void calculateDegress() {
		
		double currentAngle = djRotateRelativeLayout.getRotation();
		double currentSub;
		 currentSub = currentAngle / djDegressBtn;
		 int temp = (int)currentSub;
		 
		 currentSub = currentAngle -djDegressBtn * temp;
		 
		 System.out.println("currentSub =  " + currentSub);
		if (currentSub > 0) {
			
			if (currentSub > djDegressBtn / 2) {
				currentSub  = djDegressBtn - currentSub;
				
			}
			else if (currentSub < djDegressBtn / 2) {
				currentSub = -currentSub;
			}
		}
		else if (currentSub < 0) {
			
			if (currentSub > -djDegressBtn / 2) {
				currentSub = - currentSub;
			}
			else if (currentSub < - djDegressBtn / 2) {
				currentSub = -djDegressBtn - currentSub;
			}
			
			
		} 
		
		
		djSetRotateAnimation(currentSub);
		
	}
	
	
	
	
	
	@Override
	public boolean onTouchEvent(MotionEvent event) {
		// TODO Auto-generated method stub
		float tempTouchX = event.getX();
		float tempTouchY = event.getY();
		
		PointF pointF = new PointF(tempTouchX, tempTouchY);
		
		
		
		switch (event.getAction()) {
		case MotionEvent.ACTION_DOWN:
			djTouchBegin(pointF);
			previousPointF = pointF;
			
			
			
			break;
		case MotionEvent.ACTION_MOVE:
			
			djTouchMove(pointF);
			previousPointF = pointF;
			break;
		case MotionEvent.ACTION_UP:
			djTouchEnd(tempTouchX, tempTouchY);
			
			
			break;

		default:
			break;
		}
		
		return true;
	}
	
	
	
	public void djSetRotateAnimation(double angle) {
		
		float tempCurrentAngle = djRotateRelativeLayout.getRotation();
		destinationAngle = tempCurrentAngle + (float)angle;
		//destinationAngle = tempCurrentAngle + (float)30.0000;
		System.out.println("tempCurrentAngle" + tempCurrentAngle + "destinationAngle" + destinationAngle );

		RotateAnimation	 rotateAnimation = new RotateAnimation((float)0.0,(float)angle,Animation.RELATIVE_TO_SELF,0.5f,Animation.RELATIVE_TO_SELF,0.5f);
			
			

			rotateAnimation.setAnimationListener(this);
			rotateAnimation.setDuration(600);
			rotateAnimation.setFillAfter(true);
			rotateAnimation.setFillBefore(true);
			rotateAnimation.setFillEnabled(true);
			rotateAnimation.setDetachWallpaper(true);
		
		
		
		djRotateRelativeLayout.startAnimation(rotateAnimation);
		
		
	}

	
	
//	public void getMyComputerCalculate() {
//		
//		Timer timer = new Timer();
//		timer.schedule(new TimerTask() {
//			
//			@Override
//			public void run() {
//				// TODO Auto-generated method stub
//				calBool = true;
//			}
//		}, 1);
//		
//		
//		while (true) {
//			myComputerCalculate++;
//			if (calBool) {
//				break;
//			}
//		}
//		
//		
//
//	}
	
	
	public void djSetRotate(double degress) {
		
		float tempDegress = (float)degress;
		
		
		
		djRotateRelativeLayout.setRotation(tempDegress);
		
	}
	
	
//	public void djRotateTo(double angle,float delay) {
//		double rotateTo = angle;
//		double currentAngle = djRotateRelativeLayout.getRotation();
//		double subAngle = rotateTo - currentAngle ;
//		double perAngle = subAngle / (double)myComputerCalculate * delay;
//		System.out.println(perAngle);
//		for(int i = 0 ; i< myComputerCalculate;i++)
//		{
//			
//			djRotateRelativeLayout.setRotation( ((float)currentAngle+ ((float)perAngle * i)));
//		}
//		
//		djRotateRelativeLayout.setRotation((float)rotateTo);
//	}
	
	
	
	
	
	
		double dj_Degrees_To_Radians(double angle) {
		return angle * 0.01745329252f;	
	}
		double dj_Radians_To_Degrees(double angle){
		return angle * 57.29577951f;
	}
		
		double djDistance(PointF v1,PointF v2)
		{
			double tempX = v1.x - v2.x;
			double tempY = v1.y - v2.y; 
			
			return Math.sqrt(tempX * tempX + tempY * tempY);
			
		}
	 
		PointF djCgpSub(PointF v1,PointF v2)
		{
			PointF temPointF = new PointF(v1.x - v2.x, v1.y - v2.y);
			return temPointF;
		}
		
		double djToAngle(PointF vF)
		{
			return Math.atan2(vF.x, vF.y);
		}
		
		public void adjustAngleByAnimation() {
			System.out.println("djRotateRelativeLayout.getRotation()" + djRotateRelativeLayout.getRotation());
			
			
		//	djRotateRelativeLayout.startAnimation(animation);
			
			
			djRotateRelativeLayout.setRotation(destinationAngle);
			djRotateRelativeLayout.clearAnimation();
			
			
			
	
			
			
			
			//currentImageId = (int)djRotateRelativeLayout.getRotation() / (int)djDegressBtn;

			
			
			if (destinationAngle / 360 < 1) {
				int desNum = (int)destinationAngle / 360;
				destinationAngle -= 360 * desNum;
			}
			
			currentImageId = (int)destinationAngle / (int)djDegressBtn;
			
			
				if (currentImageId < 0) {
					currentImageId += 6;
					if (currentImageId < 0) {
						currentImageId += 6;
					}

			}
				
				System.out.println("currentImageId" + currentImageId);
			
			
			
			System.out.println("currentImageId" + currentImageId);
			
			//设置图片
			djRotateRelativeLayout.changeImageResoures(currentImageId);
			
			if (currentImageId != previousimageId) {
				djRotateRelativeLayout.changeImageDefaultResources(previousimageId);
			}
			
			previousimageId = currentImageId;
			
			
			
			
			
			//变换图片
//djChangeImageView();
		}

		@Override
		public void onAnimationEnd(Animation animation) {
			// TODO Auto-generated method stub
			
			if (600 == animation.getDuration()) {
				adjustAngleByAnimation();
			}
			if (650 == animation.getDuration()) {
				
				djRotateRelativeLayout.clearAnimation();
			}
			
			
			
		}

		@Override
		public void onAnimationRepeat(Animation animation) {
			// TODO Auto-generated method stub
			
		}

		@Override
		public void onAnimationStart(Animation animation) {
			// TODO Auto-generated method stub
			
		}

		@Override
		public void onClick(View v) {
			// TODO Auto-generated method stub
			
			
//			switch (v.getId()) {
//			case 987654:
//				if (calBool) {
//					TranslateAnimation	translateAnimation = new TranslateAnimation(Animation.RELATIVE_TO_PARENT,0, Animation.RELATIVE_TO_PARENT,0.5f,Animation.RELATIVE_TO_PARENT, 0, Animation.RELATIVE_TO_PARENT, 0);
//					translateAnimation.setDuration(650);
//					
//					translateAnimation.setFillAfter(true);
//					djRotateRelativeLayout.startAnimation(translateAnimation);
//					calBool = false;
//				
//				}
//				else {
//					TranslateAnimation	translateAnimation = new TranslateAnimation(Animation.RELATIVE_TO_PARENT,0.5f, Animation.RELATIVE_TO_PARENT,0f,Animation.RELATIVE_TO_PARENT, 0, Animation.RELATIVE_TO_PARENT, 0);
//					translateAnimation.setDuration(650);
//					
//					translateAnimation.setFillAfter(true);
//					djRotateRelativeLayout.startAnimation(translateAnimation);
//					calBool = true;
//					
//					
//				}
//				
//				
//				
//				break;
//
//			default:
//				break;
//			}
		}
		
		
	


}


一个绝对布局的类 ，调整位置
DJRotateAbsoluteView.java 

package com.ldci.djrotatemenuforandroid;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.drawable.BitmapDrawable;
import android.util.DisplayMetrics;
import android.widget.AbsoluteLayout;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.AbsoluteLayout.LayoutParams;

public class DJRotateAbsoluteView extends AbsoluteLayout{

	
	public DJRotateAbsoluteView(Context context,int width,int height) {
		super(context);
		// TODO Auto-generated constructor stub
		
		AbsoluteLayout.LayoutParams djlp = new AbsoluteLayout.LayoutParams(width, height, width/ 2, 0);
		
		
		DJRotateMenuView djRotateMenuView = new DJRotateMenuView(context, width, height);
		djRotateMenuView.setLayoutParams(djlp);
		
		this.addView(djRotateMenuView);
	}

}

DJRotateMenu.java 

package com.ldci.djrotatemenuforandroid;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.drawable.BitmapDrawable;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.animation.Animation;
import android.view.animation.Animation.AnimationListener;
import android.view.animation.TranslateAnimation;
import android.widget.ImageView;
import android.widget.RelativeLayout;

public class DJRotateMenu extends RelativeLayout implements OnClickListener,AnimationListener{

	
	
	private ImageView btnImageView;
	
	 private	boolean calBool = true;
	
	private DJRotateAbsoluteView djRotateAbsoluteView;
	
	public DJRotateMenu(Context context,int width,int height) {
		super(context);
		// TODO Auto-generated constructor stub
		djRotateAbsoluteView = new DJRotateAbsoluteView(context, width, height);
		
		this.addView(djRotateAbsoluteView);
		
		
		
		
		btnImageView = new ImageView(context);
		btnImageView.setId(987654);
		btnImageView.setOnClickListener(this);
		
		Bitmap btnBitmap = ((BitmapDrawable)getResources().getDrawable(R.drawable.ui_navi_triangle)).getBitmap();
		RelativeLayout.LayoutParams btnlp = new RelativeLayout.LayoutParams(btnBitmap.getWidth(),btnBitmap.getHeight());
		btnImageView.setImageBitmap(btnBitmap);
		btnlp.addRule(RelativeLayout.CENTER_HORIZONTAL);
		btnlp.addRule(RelativeLayout.CENTER_VERTICAL);
		btnlp.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
	
		btnImageView.setLayoutParams(btnlp);
		this.addView(btnImageView);
		
		
	}



	@Override
	public void onClick(View v) {
		// TODO Auto-generated method stub
		switch (v.getId()) {
		case 987654:
			if (calBool) {
				TranslateAnimation	translateAnimation = new TranslateAnimation(Animation.RELATIVE_TO_PARENT,0f, Animation.RELATIVE_TO_PARENT,0.5f,Animation.RELATIVE_TO_PARENT, 0, Animation.RELATIVE_TO_PARENT, 0);
				translateAnimation.setDuration(650);
			//	translateAnimation.setAnimationListener(this);
				translateAnimation.setFillAfter(true);
				djRotateAbsoluteView.startAnimation(translateAnimation);
				calBool = false;
			
			}
			else {
				TranslateAnimation	translateAnimation = new TranslateAnimation(Animation.RELATIVE_TO_PARENT,0.5f, Animation.RELATIVE_TO_PARENT,0f,Animation.RELATIVE_TO_PARENT, 0, Animation.RELATIVE_TO_PARENT, 0);
				translateAnimation.setDuration(650);
				//translateAnimation.setAnimationListener(this);
				translateAnimation.setFillAfter(true);
				djRotateAbsoluteView.startAnimation(translateAnimation);
				calBool = true;
				
				
			}
			
			
			
			break;

		default:
			break;
		}
	}



	@Override
	public void onAnimationEnd(Animation animation) {
		// TODO Auto-generated method stub
		djRotateAbsoluteView.clearAnimation();
		
	}



	@Override
	public void onAnimationRepeat(Animation animation) {
		// TODO Auto-generated method stub
		
	}



	@Override
	public void onAnimationStart(Animation animation) {
		// TODO Auto-generated method stub
		
	}

}


测试一下我们的程序
MainActivity.java 

package com.ldci.djrotatemenuforandroid;

import android.os.Bundle;
import android.R.integer;
import android.app.Activity;
import android.graphics.Color;
import android.util.DisplayMetrics;
import android.view.Menu;
import android.widget.RelativeLayout;
import android.widget.RelativeLayout.LayoutParams;

public class MainActivity extends Activity {

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		
	
		
		DisplayMetrics dMetrics = new DisplayMetrics();
		getWindowManager().getDefaultDisplay().getMetrics(dMetrics);
		int width = dMetrics.widthPixels;
		int height = dMetrics.heightPixels - 125;
		
		System.out.println("==========" + height);
		

		//调用时只用这个方法就OK
		DJRotateMenu djRotateMenu = new DJRotateMenu(this, width, height);
		
		setContentView(djRotateMenu);
		
		
		
	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		// Inflate the menu; this adds items to the action bar if it is present.
		getMenuInflater().inflate(R.menu.main, menu);
		return true;
	}

}

本文完！！




利用Android自定义View实现转盘旋转的效果
canchew的专栏
05-29 2万+
Android的自定义View为开发者定义和使用个性化的View提供了很好的支持，想要使用自己定义的View，需要继承View类，并重写构造函数和onDraw（）函数。onDraw函数在界面刷新时会被调用，通过线程控制可以实现动画的效果，这里提供一个用自定义View实现的类似幸运转盘的例子。一、自定义的转盘Viewpackage com.test.www;import androi
android 方向键控制,Android中控制软键盘的方法总结
weixin_39890431的博客
05-26 490
Android开发中，对键盘的控制是家常便饭。我们一般通过两种方式控制键盘的行为，一种是在Activity中配置相关属性，另一种是直接调用系统提供的方法。AndroidManifest中配置AndroidManifest文件的Activity中有一个名为android:windowSoftInputMode的属性，通过配置该属性可以实现对软键盘行为的一些控制。这个属性有有以下可配置的值stateU...
【AOSP】Android AOSP 输入法使用时在屏幕旋转的时候发生声音
Leif_dong的专栏
06-14 652
android AOSP
Android控制软键盘拉起
a253664942的专栏
04-18 1664
在安卓中经常会出现输入框被软键盘遮罩的情况：使用如下代码即可解决 new Handler().postDelayed(new Runnable() { public void run() { // TODO Auto-generated method stub
Android EditView与软键盘相关
Raleigh
09-21 799
一、自动弹出软键盘 Timer timer=new Timer();          timer.schedule(new TimerTask() {                     public void run() {                  InputMethodManager inputMethodManager=(InputMethodManager) getS
Android屏幕方向及键盘状态
GhostFromHeaven的专栏
08-20 1035
Configuration config = getResources().getConfiguration();       if (config.orientation == Configuration.ORIENTATION_LANDSCAPE){               //横屏，比如 480x320     }else if(config.orientation == C
Android获取屏幕方向及键盘状态的小例子
09-05
在Android应用开发中，了解设备的屏幕方向和键盘状态是非常重要的。这可以帮助开发者根据设备的当前设置优化用户体验，比如调整布局、控制显示内容或者处理键盘弹出时的交互。以下是对给定标题和描述中涉及知识点的...
Android 图片特效如何实现及总结
09-01
在这个例子中，`onKeyDown()`方法处理键盘输入，根据按键改变`matrix`的状态，然后在`onDraw()`方法中，通过`canvas.concat(matrix)`应用变换并绘制图片。 总的来说，Android平台提供了丰富的图像处理功能，通过...
OSG中模型的平移，旋转，缩放例子实现
jk24680的博客
10-14 1440
1.若要实现变换，先创建变换矩阵节点（MatrixTransform），在变换矩阵中实现相应空间变换。 2.再将模型节点放入变换矩阵中（这时变换矩阵会根据自己已经设定好的变换处理加入的节点） 3.最后将变换矩阵节点放入根节点中，从而渲染。 #include <osgDB/ReadFile> #include <osgViewer/Viewer> #include <osg/Node> #include <osg/MatrixTransform> voi
Android-app.rar
09-08
Android例子源码图片旋转缩放加盖水印透明倾斜扭曲处理 Android例子源码实现Windows8风格的Dialog Android例子源码强大的listview效果集合项目 Android例子源码模仿IOS音乐的可拖动导航栏功能 Android例子源码模仿...
android 软键盘弹出移动view 键盘监听兼容横竖屏切换
小木子102
12-24 1168
这几天项目有个需求，就是当输入框输入的时候，需要把界面听上去腾出键盘位置，不然键盘挡住界面，然后查找了各种方法：网上大多介绍android:windowSoftInputMode嵌套ScrollView综合使用来实现，然后搞了一下，确没能实现功能(参考：http://blog.youkuaiyun.com/lingdianalex/article/details/52411317) 后来找了其他方法： 在
android输入法横向,Android输入法编辑器适用于横向但不是纵向
weixin_33476149的博客
05-26 199
屏幕顶部的背景使用以下主题，并且应该是透明的。在肖像模式下，背景变黑。有时候甚至不会发生，背景保持透明。为了测试这一点，我使用TED文本编辑器应用程序。正如我所说的，在TED的肖像模式下背景变黑。我编写了自己的活动，其中包含多行文本输入字段，在此活动中，背景可以正确显示。在另一个示例中，当我尝试撰写新电子邮件时，我的Gmail应用程序中的背景在肖像模式下变为白色。Android输入法编辑器适用于横...
android三种自定义软键盘demo
05-18
demo内容介绍https://blog.youkuaiyun.com/wozuihaole/article/details/80364296
android 整个页面方向,Android页面方向、角度及旋转小结
weixin_34965737的博客
05-25 588
Android页面方向、角度及旋转小结手上的项目原本设计之初是基于手机竖屏的，但由于近期某些订制版本需要适配横屏和默认横屏设备，因此对页面的朝向和角度获取要进行一些研究。其中也踩了不少坑，这里拿出来给大家乐呵乐呵。从传感器角度讲起通常，我们会使用OrientationEventListener来获取传感器角度，其一般用法如下：new OrientationEventListener(this, S...
Android：UI设置-横竖屏转换、输入法键盘相关设置
weixin_33755554的博客
11-22 460
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 publiccla...
android系统默认的弹窗,Android中的各种弹窗实现
weixin_29285605的博客
05-26 1884
8种机械键盘轴体对比本人程序员，要买一个写代码的键盘，请问红轴和茶轴怎么选？在 Android 中实现弹出层方式很多，下面介绍几种常用的1.通过FrameLayout模拟弹出层优点：实现简单，布局也比较好写缺点：位置在上下左右比较好，其他复杂的布局要写大量的点击事件来阻止点击向下传递比如实现下面的效果：android:layout_width="match_parent"android:layo...
Delphi技术实现旋转立方体效果的体绘制
例如，可以为立方体添加材质和光照效果，或者创建一个交互式环境，用户可以通过键盘或鼠标来控制立方体的旋转和视图的变化。 ### 标签解析 - **delphi_cube**: 指的是利用Delphi语言实现的立方体模型或项目。 - **...
Android View 完美实现EditText 在软键盘上边的示例
u013252110的博客
11-21 1620
此方法基于PopupWindow,适合需要回复内容时响应点击事件，打开软键盘，编辑框在软键盘上部。 优点，编辑框使用CleanEdittext,监听输入状态来更改回复按钮颜色，添加title等。 先展示效果 点击评论打开软键盘，编辑框在软键盘上部，点击其他区域消失收起软键盘： 1.BaseSelectPopupWindow 的代码。 ? 1 2 3 ...
Android APP禁止旋转和软键盘的控制
Nancy的博客
03-23 2197
AndroidManifest.xml中修改案例<!-- screenOrientation portrait 限制此页面数竖屏显示 --> <!-- screenOrientation landscape 限制此页面横屏显示 --> <!-- windowSoftInputMode stateUnspecified：软键盘的状态并没有指定，系统将选择一个合适的状态或依赖于主题的设置
Android中通过按键旋转屏幕
linux嵌入式驱动软件开发
02-24 6971
<br /><br />Q5有个功能，通过长按menu按键，可以旋转屏幕方向（0°或者90°），这个功能有时蛮有用的，下面来看看是如何实现的：<br />1 修改按键处理程序<br />frameworks/policies/base/phone/com/android/internal/policy/impl/PhoneWindowManager.java<br />函数<br />    public boolean interceptKeyTi(WindowState win, int code, i
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

杜甲同学

感谢打赏，我会继续努力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值