Android自定义锁屏的实现

        最近研究了一下锁屏，要实现锁屏大体的实现思路是自定义一个后台service监听手机屏幕开关事件，监听到屏幕关闭的时候替换系统锁屏并调用自定义的锁屏界面，自定义锁屏界面需要屏蔽返回键和home键，以及屏蔽状态栏下拉。

        系统屏幕开关的时候会发出相应的广播，我们可以接收对应的广播来调用自己的锁屏界面。屏幕开关的时候会发出以下两个广播事件。

android.intent.action.SCREEN_ON

android.intent.action.SCREEN_OFF

替换系统锁屏要调用KeyguardManager类相应方法去解除屏幕锁定,这里需要在配置文件中添加

权限配置

屏蔽系统锁屏代码

mKeyguardManager= (KeyguardManager) context.getSystemService(Context.KEYGUARD_SERVICE);

mKeyguardLock= mKeyguardManager.newKeyguardLock("");

mKeyguardLock.disableKeyguard();

以下是自定义service代码，service中动态注册了监听屏幕开关事件

public class LockService extends Service {
	private String TAG = "LockService";
	private Intent zdLockIntent = null;

	@Override
	public IBinder onBind(Intent arg0) {
		return null;
	}

	public void onCreate() {
		super.onCreate();
		zdLockIntent = new Intent(LockService.this, ShowLockActivity.class);
		zdLockIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
		/* 注册广播 */
		IntentFilter mScreenOnFilter = new IntentFilter("android.intent.action.SCREEN_ON");
		LockService.this.registerReceiver(mScreenOnReceiver, mScreenOnFilter);

		/* 注册广播 */
		IntentFilter mScreenOffFilter = new IntentFilter("android.intent.action.SCREEN_OFF");
		LockService.this.registerReceiver(mScreenOffReceiver, mScreenOffFilter);
	}

	public void onDestroy() {
		Log.i(TAG, "----------------- onDestroy------");
		super.onDestroy();
		this.unregisterReceiver(mScreenOnReceiver);
		this.unregisterReceiver(mScreenOffReceiver);
		// 在此重新启动,使服务常驻内存
		startService(new Intent(this, LockService.class));
	}

	private KeyguardManager mKeyguardManager = null;
	private KeyguardManager.KeyguardLock mKeyguardLock = null;
	// 屏幕变亮的广播,我们要隐藏默认的锁屏界面
	private BroadcastReceiver mScreenOnReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
			if (intent.getAction().equals("android.intent.action.SCREEN_ON")) {
				Log.i(TAG, "----------------- android.intent.action.SCREEN_ON------");
			}
		}
	};

	// 屏幕变暗/变亮的广播 ， 我们要调用KeyguardManager类相应方法去解除屏幕锁定
	private BroadcastReceiver mScreenOffReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
			String action = intent.getAction();
			if (action.equals("android.intent.action.SCREEN_OFF") || action.equals("android.intent.action.SCREEN_ON")) {
				mKeyguardManager = (KeyguardManager) context.getSystemService(Context.KEYGUARD_SERVICE);
				mKeyguardLock = mKeyguardManager.newKeyguardLock("");
				mKeyguardLock.disableKeyguard();
				startActivity(zdLockIntent);
			}
		}
	};
}

LockLayer.java这个类用来屏蔽状态啦下拉和home键的

public class LockLayer {
	private Activity mActivty;
	private WindowManager mWindowManager;
	private View mLockView;
	private LayoutParams mLockViewLayoutParams;
	private boolean isLocked;
	// 这个值具体用于实现全屏
	private final static int FLAG_APKTOOL_VALUE = 1280;

	public LockLayer(Activity act) {
		mActivty = act;
		init();
	}

	private void init() {
		isLocked = false;
		mWindowManager = mActivty.getWindowManager();
		mLockViewLayoutParams = new LayoutParams();
		mLockViewLayoutParams.width = LayoutParams.MATCH_PARENT;
		mLockViewLayoutParams.height = LayoutParams.MATCH_PARENT;
		// 这一行实现屏蔽Home
		mLockViewLayoutParams.type = LayoutParams.TYPE_SYSTEM_ERROR;
		mLockViewLayoutParams.flags = FLAG_APKTOOL_VALUE;
	}

	public synchronized void lock() {
		if (mLockView != null && !isLocked) {
			mWindowManager.addView(mLockView, mLockViewLayoutParams);
		}
		isLocked = true;
	}

	public synchronized void unlock() {
		if (mWindowManager != null && isLocked) {
			mWindowManager.removeView(mLockView);
		}
		isLocked = false;
	}

	public synchronized void setLockView(View v) {
		mLockView = v;
	}
}

RoundSpinView.java 自定义锁屏界面

public class RoundSpinView extends View {
	private String TAG = "RoundSpinView";
	
	private Activity act;
	private Context ctx;
	
	private Paint mPaint = new Paint();
	
	// 图片列表列表
	private BigStone[] mStones;
	// 中心点stone
	private BigStone centerStones;
	// 数目
	private static final int STONE_COUNT = 4;
	// 圆心坐标
	private int mPointX = 0, mPointY = 0;
	// 半径
	private int mRadius = 0;
	// 每两个点间隔的角度
	private int mDegreeDelta;
	// 
	private Bitmap lockscre_pressed_bit ;
	private Bitmap lockscreen_normal_bit;
	private Bitmap select_bg_bit;

	private int[] normal_img = { R.drawable.ic_lockscreen_message_normal, R.drawable.ic_lockscreen_unlock_normal, R.drawable.ic_lockscreen_phone_normal, R.drawable.ic_tab_theme_normal };
	private int[] select_img = { R.drawable.ic_lockscreen_message_activated, R.drawable.ic_lockscreen_unlock_activated, R.drawable.ic_lockscreen_phone_activated, R.drawable.ic_tab_theme_selected };
	private Bitmap[] normal_img_bitmap = new Bitmap[STONE_COUNT];
	private Bitmap[] select_img_bitmap = new Bitmap[STONE_COUNT];
	
	public RoundSpinView(Context context,Activity act, int px, int py, int radius) {
		super(context);
		this.ctx = context;
		this.act = act;
		init(px, py, radius);
	}

	public RoundSpinView(Context context, AttributeSet attrs, int defStyle) {
		super(context, attrs, defStyle);
	}

	public RoundSpinView(Context context, AttributeSet attrs) {
		super(context, attrs);
	}

	public RoundSpinView(Context context) {
		super(context);
	}

	public void init(int px, int py, int radius) {
		mPaint.setColor(Color.WHITE);
		mPaint.setStrokeWidth(0);
		mPaint.setAntiAlias(true);
		mPaint.setStyle(Style.STROKE);
		
		lockscre_pressed_bit = BitmapFactory.decodeResource(getResources(), R.drawable.lockscre_pressed);
		lockscreen_normal_bit = BitmapFactory.decodeResource(getResources(), R.drawable.lockscreen_normal);
		select_bg_bit = BitmapFactory.decodeResource(getResources(), R.drawable.template_checkbox_normal);
		for (int index = 0; index < STONE_COUNT; index++) {
			normal_img_bitmap[index] = BitmapFactory.decodeResource(getResources(), normal_img[index]);
			select_img_bitmap[index] = BitmapFactory.decodeResource(getResources(), select_img[index]);
		}
		
		setBackgroundResource(R.drawable.bg1);

		mPointX = px / 2;
		mPointY = py / 3 * 2;
		mRadius = radius;

		setupStones();
		computeCoordinates();
	}

	/**
	 * 初始化每个点
	 */
	private void setupStones() {
		mStones = new BigStone[STONE_COUNT];
		BigStone stone;
		int angle = 0;
		mDegreeDelta = 360 / STONE_COUNT;

		centerStones = new BigStone();
		centerStones.angle = angle;
		centerStones.x = mPointX;
		centerStones.y = mPointY;

		for (int index = 0; index < STONE_COUNT; index++) {
			stone = new BigStone();
			stone.angle = angle;
			angle += mDegreeDelta;

			mStones[index] = stone;
		}
	}


	/**
	 * 计算每个点的坐标
	 */
	private void computeCoordinates() {
		BigStone stone;
		for (int index = 0; index < STONE_COUNT; index++) {
			stone = mStones[index];
			stone.x = mPointX + (float) ((mRadius + select_bg_bit.getWidth()/2) * Math.cos(stone.angle * Math.PI / 180));
			stone.y = mPointY + (float) ((mRadius + select_bg_bit.getHeight()/2) * Math.sin(stone.angle * Math.PI / 180));
			stone.bitmap = normal_img_bitmap[index];
			stone.angle = computeCurrentAngle(stone.x, stone.y);
		}
	}

	/**
	 * 计算坐标点与圆心直径的角度
	 * 
	 * @param x
	 * @param y
	 * @return
	 */
	private int computeCurrentAngle(float x, float y) {
		float distance = (float) Math.sqrt(((x - mPointX) * (x - mPointX) + (y - mPointY) * (y - mPointY)));
		int degree = (int) (Math.acos((x - mPointX) / distance) * 180 / Math.PI);
		if (y < mPointY) {
			degree = -degree;
		}
		return degree;
	}

	private boolean isPressLock = false;// 标记是否按住中心锁图片

	@Override
	public boolean dispatchTouchEvent(MotionEvent event) {
		float x, y;
		int action = event.getAction();
		switch (action) {
		case MotionEvent.ACTION_DOWN:
			x = event.getX();
			y = event.getY();
			isPressLock = isPressLockPic(x, y);
			setIsVisible(isPressLock);
			invalidate();
			break;
		case MotionEvent.ACTION_MOVE:
			x = event.getX();
			y = event.getY();
			// 算出当前坐标和圆心的距离
			centerStones.angle = computeCurrentAngle(x, y);
			if (isPressLock) {
				centerStones.bitmap = lockscre_pressed_bit;
				computeCoordinates();
				if (getDistance(x, y) <= mRadius) {
					centerStones.x = x;
					centerStones.y = y;
				} else {// 大于直径时根据角度算出坐标
					centerStones.x = mPointX + (float) ((mRadius) * Math.cos(centerStones.angle * Math.PI / 180));
					centerStones.y = mPointY + (float) ((mRadius) * Math.sin(centerStones.angle * Math.PI / 180));
					if (centerStones.angle <= (mStones[0].angle + 15) && centerStones.angle >= (mStones[0].angle - 15)) {
						mStones[0].bitmap = select_img_bitmap[0];
						centerStones.bitmap = select_bg_bit;
						centerStones.x = mStones[0].x;
						centerStones.y = mStones[0].y;
					}
					if (centerStones.angle <= (mStones[1].angle + 15) && centerStones.angle >= (mStones[1].angle - 15)) {
						mStones[1].bitmap = select_img_bitmap[1];
						centerStones.bitmap = select_bg_bit;
						centerStones.x = mStones[1].x;
						centerStones.y = mStones[1].y;
					}
					if (centerStones.angle <= (mStones[2].angle + 15) && centerStones.angle >= (mStones[2].angle - 15)) {
						mStones[2].bitmap = select_img_bitmap[2];
						centerStones.bitmap = select_bg_bit;
						centerStones.x = mStones[2].x;
						centerStones.y = mStones[2].y;
					}
					if (centerStones.angle <= (mStones[3].angle + 15) && centerStones.angle >= (mStones[3].angle - 15)) {
						mStones[3].bitmap = select_img_bitmap[3];
						centerStones.bitmap = select_bg_bit;
						centerStones.x = mStones[3].x;
						centerStones.y = mStones[3].y;
					}
				}
				invalidate();
			}
			break;

		case MotionEvent.ACTION_UP:
			//处理Action_Up事件：  判断是否解锁成功，成功则结束我们的Activity ；否则 ，缓慢回退该图片。
			handleActionUpEvent(event);
			break;
		}
		return true;
	}
	
	private void handleActionUpEvent(MotionEvent event){
		boolean islocksuc = false;// 是否解锁成功
		float x = event.getX();
		float y = event.getY();
		centerStones.angle = computeCurrentAngle(x, y);
		if (getDistance(x, y) >= mRadius) {
			if (centerStones.angle <= (mStones[0].angle + 15) && centerStones.angle >= (mStones[0].angle - 15) && mStones[0].isVisible) {
				islocksuc = true;
				Log.i(TAG,"解锁-短信 跳转到短信界面");
				act.finish();
			}
			if (centerStones.angle <= (mStones[1].angle + 15) && centerStones.angle >= (mStones[1].angle - 15) && mStones[1].isVisible) {
				islocksuc = true;
				Log.i(TAG,"解锁-解锁");
				act.finish();
			}
			if (centerStones.angle <= (mStones[2].angle + 15) && centerStones.angle >= (mStones[2].angle - 15) && mStones[2].isVisible) {
				islocksuc = true;
				Log.i(TAG,"解锁-电话 跳转到电话界面");
				act.finish();
			}
			if (centerStones.angle <= (mStones[3].angle + 15) && centerStones.angle >= (mStones[3].angle - 15) && mStones[3].isVisible) {
				islocksuc = true;
				Log.i(TAG,"解锁-相机 跳转到相机界面");
				act.finish();
			}
		} 
		if(!islocksuc) { // 未解锁成功
			backToCenter();
		}
	}
	
	
	//回退动画时间间隔值 
	private static int BACK_DURATION = 20 ;   // 20ms
    //水平方向前进速率
	private static float VE_HORIZONTAL = 0.8f ;  //0.1dip/ms
	private Handler mHandler =new Handler ();
	
	private void backToCenter() {
		mHandler.postDelayed(BackDragImgTask, BACK_DURATION);
	}
	
	//通过延时控制当前绘制bitmap的位置坐标
	private Runnable BackDragImgTask = new Runnable(){
		public void run(){
			//一下次Bitmap应该到达的坐标值
			if(centerStones.x>=mPointX){
				centerStones.x = centerStones.x - BACK_DURATION * VE_HORIZONTAL;
				if(centerStones.xmPointX){
					centerStones.x = mPointX;
				}
			} 
			centerStones.y = mPointY + (float) ((centerStones.x-mPointX) * Math.tan(centerStones.angle * Math.PI / 180));
			
			invalidate();//重绘		
			boolean shouldEnd = getDistance(centerStones.x, centerStones.y) <= 8 ;			
			if(!shouldEnd)
			    mHandler.postDelayed(BackDragImgTask, BACK_DURATION);
			else { //复原初始场景
				centerStones.x = mPointX;
				centerStones.y = mPointY;
				isPressLock = false;
				setIsVisible(isPressLock);
				invalidate();
			}				
		}
	};

	/**
	 * 获取坐标点与圆心直径的距离
	 * @param x
	 * @param y
	 * @return
	 */
	private float getDistance(float x, float y) {
		float distance = (float) Math.sqrt(((x - mPointX) * (x - mPointX) + (y - mPointY) * (y - mPointY)));
		return distance;
	}

	/**
	 * 判断手指按下的时候是否按住中心锁图片
	 * 
	 * @param x
	 * @param y
	 * @return
	 */
	private boolean isPressLockPic(float x, float y) {
		float l = centerStones.x - centerStones.bitmap.getWidth() / 2;
		float r = centerStones.x + centerStones.bitmap.getWidth() / 2;
		float t = centerStones.y - centerStones.bitmap.getHeight() / 2;
		float b = centerStones.y + centerStones.bitmap.getHeight() / 2;
		if (x >= l && x <= r && y >= t && y <= b) {
			return true;
		}
		return false;
	}

	@Override
	public void onDraw(Canvas canvas) {
		if (isPressLock) {// 手指按下状态
			canvas.drawCircle(mPointX, mPointY, mRadius, mPaint);// 画圆
			drawInCenter(canvas, centerStones.bitmap, centerStones.x, centerStones.y);// 画中心锁图片
			for (int index = 0; index < STONE_COUNT; index++) {
				if (!mStones[index].isVisible)
					continue;
				drawInCenter(canvas, mStones[index].bitmap, mStones[index].x, mStones[index].y);
			}
		} else {
			centerStones.bitmap = lockscreen_normal_bit;
			drawInCenter(canvas, centerStones.bitmap, centerStones.x, centerStones.y);// 画中心锁图片
		}
	}

	/**
	 * 把中心点放到中心处
	 * 
	 * @param canvas
	 * @param bitmap
	 * @param left
	 * @param top
	 */
	void drawInCenter(Canvas canvas, Bitmap bitmap, float left, float top) {
		canvas.drawBitmap(bitmap, left - bitmap.getWidth() / 2, top - bitmap.getHeight() / 2, null);
	}
	
	private void setIsVisible(boolean isVisible){
		for (int index = 0; index < STONE_COUNT; index++) {
			mStones[index].isVisible = isVisible;
		}
	}

	class BigStone {
		// 图片
		public Bitmap bitmap;
		// 角度
		public int angle;
		// x坐标
		public float x;
		// y坐标
		public float y;
		// 是否可见
		public boolean isVisible = false;
	}
}