[Android] Android 锁屏实现与总结（三）

上接：

Android 锁屏实现与总结（二）

系列文章链接如下：

[Android] Android 锁屏实现与总结（一）

[Android] Android 锁屏实现与总结（二）

[Android] Android 锁屏实现与总结（三）

代码文件地址：

https://github.com/wukong1688/Android-BaseLockScreen

3、按键的屏蔽

当自定义锁屏页最终出现在手机上时，我们希望它像系统锁屏页那样屹立不倒，所有的按键都不能触动它，只有通过划屏或者指纹才能解锁，因此有必要对按键进行一定程度上的屏蔽。针对只有虚拟按键的手机，我们可以通过隐藏虚拟按键的方式部分解决这个问题。但是当用户在锁屏页底部滑动，隐藏后的虚拟按键还是会滑出，而且如果用户是物理按键的话就必须进行屏蔽了。需要重写Activity的onBackPressed()方法即可。

public boolean onKeyDown(int keyCode, KeyEvent event) {
        int key = event.getKeyCode();
        switch (key) {
            case KeyEvent.KEYCODE_BACK: {
                return true;
            }
            case KeyEvent.KEYCODE_MENU: {
                return true;
            }
        }
        return super.onKeyDown(keyCode, event);
    }

Home键与Recent键的点击事件是在framework层进行处理的，因此onKeyDown()与dispatchKeyEvent()都捕获不到点击事件。关于这两个按键的屏蔽方法，网上相关的资料有很多，有的用到了反射，有的通过改变Window的标志位和Type等，总的来说这些方法只对部分android版本有效，有的则完全无法编译通过。其实这么做的目的无非是为了实现一个纯粹的锁屏页，但是这种做法容易造成锁屏页的异常崩溃，我们要满足的是用户在锁屏页的快捷操作，Home键和Recent键无关痛痒，基本可以不管。

4、滑屏解锁

做完以上几步，当屏幕熄灭后，再打开屏幕就能够看到我们的自定义锁屏页了。接下来要实现划屏解锁。

实现滑屏解锁的类LockScreenView.java：

package com.jack.applockscreen.activity;

import android.app.Activity;

import android.content.Context;

import android.graphics.Canvas;

import android.graphics.Color;

import android.graphics.Paint;

import android.graphics.Paint.Align;

import android.graphics.Paint.Style;

import android.graphics.Point;

import android.graphics.drawable.BitmapDrawable;

import android.graphics.drawable.Drawable;

import android.support.v4.view.ViewConfigurationCompat;

import android.text.TextPaint;

import android.util.AttributeSet;

import android.view.Display;

import android.view.MotionEvent;

import android.view.View;

import android.view.ViewConfiguration;

import android.view.WindowManager;

import com.jack.applockscreen.R;

/**

 * 解锁按钮控件

 *

 * @author chenglei

 */

public class LockScreenView extends View {

    private int mWidth;

    private int mHeight;

    private int mScreenWidth;

    private int mScreenHeight;

    private WindowManager mWindowManager;

    private Display mDisplay;

    private float mTouchPadRadius;

    private float mTouchPadBorderWidthNormal;

    private float mTouchPadBorderWidthPressed;

    private Paint mPaintNormal;

    private TextPaint mTextPaint;

    private Paint mBackgroundPaint;

    private Point mTouchPadCenter = new Point();

    private int mTouchSlop;

    private int mStartX;

    private int mCurrX;

    private int mOffectX;

    private boolean mCanMove;

    private Drawable mDrawableLeft;

    private Drawable mDrawableRight;

    private Drawable mDrawableCenter;

    private String mTextLeft;

    private String mTextRight;

    private Point mTargetDrawableLeftPosition = new Point();

    private Point mTargetDrawableRightPosition = new Point();

    private Point mTargetTextLeftPosition = new Point();

    private Point mTargetTextRightPosition = new Point();

    private float mDensity;

    private static final float TOUCH_PAD_BORDER_WIDTH_NORMAL = ;

    private static final float TOUCH_PAD_BORDER_WIDTH_PRESSED = ;

    private static final float TARGET_DRAWABLE_PADDING = ;

    private static final float TARGET_TEXT_SIZE = ;

    private static final int STATE_TRIGGER_NONE = ;

    private static final int STATE_TRIGGER_LEFT = ;

    private static final int STATE_TRIGGER_RIGHT = ;

    private int mTouchPadTriggerState = STATE_TRIGGER_NONE;

    private OnTriggerListener mOnTriggerListener;

    private Drawable mDotsLeft;

    private Drawable mDotsRight;

    public LockScreenView(Context context) {

        this(context, null, );

    }

    public LockScreenView(Context context, AttributeSet attrs) {

        this(context, attrs, );

    }

    public LockScreenView(Context context, AttributeSet attrs, int defStyle) {

        super(context, attrs, defStyle);

        init();

    }

    private void init() {

        mWindowManager = ((Activity) getContext()).getWindowManager();

        mDisplay = mWindowManager.getDefaultDisplay();

        mScreenWidth = mDisplay.getWidth();

        mScreenHeight = mDisplay.getHeight();

//        mTouchPadBorderWidthNormal = DensityUtil.dip2px(getContext(), 8);

//        mTouchPadBorderWidthPressed = DensityUtil.dip2px(getContext(), 2);

        mDensity = getResources().getDisplayMetrics().density;

        mTouchPadBorderWidthNormal = TOUCH_PAD_BORDER_WIDTH_NORMAL * mDensity;

        mTouchPadBorderWidthPressed = TOUCH_PAD_BORDER_WIDTH_PRESSED * mDensity;

        final ViewConfiguration configuration = ViewConfiguration.get(getContext());

        mTouchSlop = ViewConfigurationCompat.getScaledPagingTouchSlop(configuration);

        mDrawableCenter = getResources().getDrawable(R.mipmap.ic_launcher);

        mDotsLeft = getResources().getDrawable(R.mipmap.keyguaid_dots_left);

        mDotsRight = getResources().getDrawable(R.mipmap.keyguaid_dots_right);

        initNormalPaint();

        initTextPaint();

    }

    private void initNormalPaint() {

        mPaintNormal = new Paint();

        mPaintNormal.setFlags(Paint.ANTI_ALIAS_FLAG);

        mPaintNormal.setColor(Color.WHITE);

        mPaintNormal.setStyle(Style.STROKE);

        mPaintNormal.setStrokeWidth(mTouchPadBorderWidthNormal);

        mBackgroundPaint = new Paint();

        mBackgroundPaint.setColor(Color.parseColor("#66000000"));

    }

    private void initTextPaint() {

        mTextPaint = new TextPaint(TextPaint.ANTI_ALIAS_FLAG);

        mTextPaint.setColor(Color.WHITE);

        mTextPaint.setTextAlign(Align.CENTER);

        mTextPaint.setTextSize(TARGET_TEXT_SIZE * mDensity);

    }

    @Override

    protected void onDraw(Canvas canvas) {

        drawBackground(canvas);

        drawDots(canvas);

        drawTouchPad(canvas);

        drawTargetDrawablesAndTexts(canvas);

    }

    private void drawBackground(Canvas canvas) {

        canvas.drawRect(, mHeight / , mWidth, mHeight *  / , mBackgroundPaint);

    }

    private void drawDots(Canvas canvas) {

        if (!mTouchDown) {

            BitmapDrawable dotsLeft = (BitmapDrawable) mDotsLeft;

            BitmapDrawable dotsRight = (BitmapDrawable) mDotsRight;

            canvas.drawBitmap(dotsLeft.getBitmap(),

                    mWidth /  - mDotsLeft.getIntrinsicWidth() / ,

                    mHeight /  - mDotsLeft.getIntrinsicHeight() / ,

                    mPaintNormal);

            canvas.drawBitmap(dotsRight.getBitmap(),

                    mWidth *  /  - mDotsRight.getIntrinsicWidth() / ,

                    mHeight /  - mDotsRight.getIntrinsicHeight() / ,

                    mPaintNormal);

        }

    }

    private void drawTouchPad(Canvas canvas) {

        BitmapDrawable bd = (BitmapDrawable) mDrawableCenter;

        if (mTouchDown) {

            canvas.drawCircle(mTouchPadCenter.x, mTouchPadCenter.y, mDrawableCenter.getIntrinsicWidth() - , mPaintNormal);

        } else {

            canvas.drawBitmap(bd.getBitmap(),

                    mTouchPadCenter.x - mDrawableCenter.getIntrinsicWidth() / ,

                    mTouchPadCenter.y - mDrawableCenter.getIntrinsicHeight() / ,

                    mPaintNormal);

            canvas.drawCircle(mTouchPadCenter.x, mTouchPadCenter.y, mDrawableCenter.getIntrinsicWidth() - , mPaintNormal);

        }

    }

    private void drawTargetDrawablesAndTexts(Canvas canvas) {

        if (mDrawableLeft != null) {

            BitmapDrawable bd = (BitmapDrawable) mDrawableLeft;

            canvas.drawBitmap(

                    bd.getBitmap(),

                    mTargetDrawableLeftPosition.x - mDrawableLeft.getIntrinsicWidth() / ,

                    mTargetDrawableLeftPosition.y - mDrawableLeft.getIntrinsicHeight() / ,

                    mPaintNormal);

        }

        if (mDrawableRight != null) {

            BitmapDrawable bd = (BitmapDrawable) mDrawableRight;

            canvas.drawBitmap(

                    bd.getBitmap(),

                    mTargetDrawableRightPosition.x - mDrawableRight.getIntrinsicWidth() / ,

                    mTargetDrawableRightPosition.y - mDrawableRight.getIntrinsicHeight() / ,

                    mPaintNormal);

        }

        if (mTextLeft != null) {

            canvas.drawText(mTextLeft, mTargetTextLeftPosition.x, mTargetTextLeftPosition.y, mTextPaint);

        }

        if (mTextRight != null) {

            canvas.drawText(mTextRight, mTargetTextRightPosition.x, mTargetTextRightPosition.y, mTextPaint);

        }

    }

    @Override

    public boolean performClick() {

        return super.performClick();

    }

    private boolean mTouchDown = false;

    @Override

    public boolean onTouchEvent(MotionEvent event) {

        switch (event.getAction()) {

            case MotionEvent.ACTION_DOWN:

                mStartX = (int) event.getX();

                if (mStartX > mTouchPadCenter.x - mTouchPadRadius && mStartX < mTouchPadCenter.x + mTouchPadRadius) {

                    mPaintNormal.setStrokeWidth(mTouchPadBorderWidthPressed);

                    mTouchDown = true;

                    invalidate();

                } else {

                    return false;

                }

                break;

            case MotionEvent.ACTION_MOVE:

                mCurrX = (int) event.getX();

//            mOffectX = mCurrX - mStartX;

//

//            if (!mCanMove && Math.abs(mOffectX) < mTouchSlop) {

//                return false;

//            } else {

//                mCanMove = true;

//                if (mOffectX > mTouchSlop) {

//                    mOffectX += mTouchSlop;

//                } else if (mOffectX < -mTouchSlop) {

//                    mOffectX -= mTouchSlop;

//                }

//            }

                mStartX = mCurrX;

                if (mDrawableRight != null && mCurrX < mWidth *  /  /*mTargetDrawableLeftPosition.x + mDrawableRight.getIntrinsicWidth() * 2.5*/) {

                    mTouchPadCenter.set(mTargetDrawableLeftPosition.x, mTargetDrawableLeftPosition.y);

                    mTouchPadTriggerState = STATE_TRIGGER_LEFT;

                } else if (mDrawableRight != null && mCurrX > mWidth *  /  /*mTargetDrawableRightPosition.x - mDrawableRight.getIntrinsicWidth() * 2.5*/) {

                    mTouchPadCenter.set(mTargetDrawableRightPosition.x, mTargetDrawableRightPosition.y);

                    mTouchPadTriggerState = STATE_TRIGGER_RIGHT;

                } else {

                    mTouchPadCenter.x = mCurrX;

                    mTouchPadCenter.set(mTouchPadCenter.x + mOffectX, mTouchPadCenter.y);

                    mTouchPadTriggerState = STATE_TRIGGER_NONE;

                }

                invalidate();

                break;

            case MotionEvent.ACTION_UP:

                mCanMove = false;

                if (STATE_TRIGGER_NONE == mTouchPadTriggerState) {

                    mTouchPadCenter.set(mWidth / , mHeight / );

                    //mPaintNormal.setStrokeWidth(mTouchPadBorderWidthNormal);

                    mTouchDown = false;

                    invalidate();

                } else if (STATE_TRIGGER_LEFT == mTouchPadTriggerState) {

                    if (mOnTriggerListener != null) {

                        mOnTriggerListener.onTriggerLeft();

                    }

                } else if (STATE_TRIGGER_RIGHT == mTouchPadTriggerState) {

                    if (mOnTriggerListener != null) {

                        mOnTriggerListener.onTriggerRight();

                    }

                }

                break;

        }

        return true;

    }

    @Override

    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

        int widthMode = MeasureSpec.getMode(widthMeasureSpec);

        int heightMode = MeasureSpec.getMode(heightMeasureSpec);

        int widthSize = MeasureSpec.getSize(widthMeasureSpec);

        int heightSize = MeasureSpec.getSize(heightMeasureSpec);

        if (widthMode == MeasureSpec.EXACTLY) {

            // Parent has told us how big to be. So be it.

            mWidth = widthSize;

        } else {

            mWidth = mScreenWidth;

            // Check against our minimum width

            mWidth = Math.max(mWidth, getSuggestedMinimumWidth());

            if (widthMode == MeasureSpec.AT_MOST) {

                mWidth = Math.min(widthSize, mWidth);

            }

        }

        if (heightMode == MeasureSpec.EXACTLY) {

            mHeight = heightSize;

        } else {

            mHeight = mScreenHeight / ;

            // Check against our minimum width

            mHeight = Math.max(mHeight, getSuggestedMinimumHeight());

            if (heightMode == MeasureSpec.AT_MOST) {

                mHeight = Math.min(heightSize, mHeight);

            }

        }

        setMeasuredDimension(mWidth, mHeight);

        mTouchPadRadius = mDrawableCenter.getIntrinsicWidth();

        mTouchPadCenter.set(mWidth / , mHeight / );

        mTargetDrawableLeftPosition.set((int) (TARGET_DRAWABLE_PADDING * mDensity), mHeight / );

        mTargetDrawableRightPosition.set((int) (mWidth - TARGET_DRAWABLE_PADDING * mDensity), mHeight / );

        mTargetTextLeftPosition.set((int) (TARGET_DRAWABLE_PADDING * mDensity), (int) (mHeight /  -  * mDensity));

        mTargetTextRightPosition.set((int) (mWidth - TARGET_DRAWABLE_PADDING * mDensity), (int) (mHeight /  -  * mDensity));

    }

    public void setTargetDrawablesAndTexts(Drawable drawableLeft, Drawable drawableRight, String textLeft, String textRight) {

        mDrawableLeft = drawableLeft;

        mDrawableRight = drawableRight;

        mTextLeft = textLeft;

        mTextRight = textRight;

        invalidate();

    }

    public void setTargetDrawablesAndTexts(int drawableLeftId, int drawableRightId, String textLeft, String textRight) {

        mDrawableLeft = drawableLeftId >  ? getResources().getDrawable(drawableLeftId) : null;

        mDrawableRight = drawableRightId >  ? getResources().getDrawable(drawableRightId) : null;

        mTextLeft = textLeft;

        mTextRight = textRight;

        invalidate();

    }

    public interface OnTriggerListener {

        public void onTriggerLeft();

        public void onTriggerRight();

    }

    public void setOnTriggerListener(OnTriggerListener l) {

        mOnTriggerListener = l;

    }

}

很多朋友私下问我代码文件的位置，这里也贴出来分享给大家！

Github地址：

https://github.com/wukong1688/Android_BaseLockScreen

本博客地址： wukong1688

本文原文地址：https://www.cnblogs.com/wukong1688/p/10725092.html

转载请著名出处！谢谢~~

[Android] Android 锁屏实现与总结（三）的更多相关文章

Android逆向之旅---Android中锁屏密码算法解析以及破解方案
一.前言最近玩王者荣耀,下载了一个辅助样本,结果被锁机了,当然破解它很简单,这个后面会详细分析这个样本,但是因为这个样本引发出的欲望就是解析Android中锁屏密码算法,然后用一种高效的方式制作锁机 ...
Android忘记锁屏密码如何进入手机？
Android忘记锁屏密码如何进入手机? 1.关闭手机 2.进入recovery模式(即恢复模式,记住不是挖煤模式.进入恢复模式不同手机有不同方法,三星的话安主页键,关机键和音量+(或-键), ...
Android一键锁屏源码
APK下载源程序下载锁屏流程如下(参考于Android一键锁屏开发全过程[源码][附图]) 源码参考于一键锁屏源码一共有2个Java文件: package com.example.onekey ...
【腾讯Bugly干货分享】浅谈Android自定义锁屏页的发车姿势
本文来自于腾讯bugly开发者社区,非经作者同意,请勿转载,原文地址:http://dev.qq.com/topic/57875330c9da73584b025873 一.为什么需要自定义锁屏页锁屏 ...
浅谈 Android 自定义锁屏页的发车姿势
作者:blowUp,原文链接:http://mp.weixin.qq.com/s?__biz=MzA3NTYzODYzMg==&mid=2653577446&idx=2&sn= ...
浅谈Android自定义锁屏页的发车姿势
一.为什么需要自定义锁屏页锁屏作为一种黑白屏时代就存在的手机功能,至今仍发挥着巨大作用,特别是触屏时代的到来,锁屏的功用被发挥到了极致.多少人曾经在无聊的时候每隔几分钟划开锁屏再关上,孜孜不倦,其酸 ...
Android定时锁屏功能实现（AlarmManager定时部分）
菜鸟入坑记——第一篇关键字:AlarmManager 一.AlarmManager简介: 参考网址:https://www.jianshu.com/p/8a2ce9d02640 参考网 ...
android开发锁屏真正的锁屏，是go锁屏那种。
想做个锁屏界面很久了,最近一周,历经千辛万苦,越过种种挫折,终于完美实现了这一要求,在此将锁屏思路分享出来. 注意:这不是什么一键锁屏,是类似“go锁屏”那样的锁屏界面. 准备:本程序共需要两个ac ...
Android LockScreen (锁屏弹窗)
在要弹窗的Activity需要进行以下设置,才可以在锁屏状态下弹窗 @Override protected void onCreate(Bundle savedInstanceState) { fin ...
Android一键锁屏APP
题记: 这个app完全是拾人牙慧,作为练手用的,其实没有什么原创的东西.当然,博客还是我自己写的,记录下来,对自己也算是一种成长吧. 转载请注明原文地址: http://www.cnblogs.com ...

随机推荐

SQLServer之创建辅助XML索引
创建辅助XML索引使用 CREATE INDEX (Transact-SQL)Transact-SQL DDL 语句可创建辅助 XML 索引并且可指定所需的辅助 XML 索引的类型. 创建辅助 XM ...
2星|《IT真相》：日本咨询师面对美国云服务的发展，对日本IT业哀其不争
IT真相-打通IT与商务的通路 I 作者是日本管理咨询师,对日本的IT和金融业了解比较多.书的内容是:作者看到美国的云服务发展壮大,日本IT业没能抓住机会,对日本IT业做了一些批评,比如不思进取,不了 ...
HO6 Condo Insurance Policy
The HO6 insurance Policy is the most common type of policy used to insure town homes and condos in t ...
DB2 因版本问题 Reorg 出错解决办法
call Sysproc.admin_cmd('REORG TABLE MY_TABLE_NAME');
Ambari与Kerberos 集成
Kerberos 介绍 Kerberos 是一个网络认证的框架协议,其设计的初衷便是通过密钥系统为 Client 和 Server 应用程序之间提供强大的认证服务.在使用 Kerberos 认证的集群 ...
php7 的yum源
yum源默认的版本太低了,手动安装有一些麻烦,想采用Yum更新安装的可以使用下面的方案: 1.检查当前安装的PHP包 yum list installed | grep php 如果有安装的PHP包, ...
面试3——java集合类总结（Set）
Set 集合和List一样,继承Collection接口,不同的是Set中不能包含重复的元素,无序,并且最多只能允许一个null值.Set常见的实现类有:HashSet.TreeSet和Linked ...
JS 灵活使用 console 调试
前言: Web 开发中最常用的调试就是 console.log(),console 除了本身 log() 方法外,还有其他很多方法. console.log() console.log() 有许多意 ...
小小知识点（四）——MATLAB如何画等高线图和线性规划约束方程
MATLAB程序: figure contourf(x,y,data) % 画等高线 hold on plot(x,y(x)) %画线性规划约束方程1 hold on plot(y,x(y)) %画线 ...
使用FaceNet 图像相识度对比
1. 模型结构:

[Android] Android 锁屏实现与总结 （三）

[Android] Android 锁屏实现与总结 （三）的更多相关文章

随机推荐

热门专题

[Android] Android 锁屏实现与总结（三）

[Android] Android 锁屏实现与总结（三）的更多相关文章