Android 手势密码开启状态设置

  Android手势密码开启状态实现方案

前言：相信朋友们对于手势密码的设置和验证已经了解了，不清楚的可参考https://github.com/zhiyongshuangquan/gestures

基本源码下载验证处理

   开启验证状态分两种：点击home键退出界面和屏幕解锁状态

  一：点击home直接退出app

  点击home键退出app也就是当前app进程没有finsh掉，直接退出，下次进入还是会直接进入当前app的退出状态，开启广播监听当前home键的状态，进行监听。

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.util.Log;


/**
 * Home键监听封装
 *
 * @author xufuchao
 */
public class HomeWatcher {


    static final String TAG = "HomeWatcher";
    private Context mContext;
    private IntentFilter mFilter;
    private OnHomePressedListener mListener;
    private InnerRecevier mRecevier;


    // 回调接口
    public interface OnHomePressedListener {
        public void onHomePressed();


        public void onHomeLongPressed();
    }


    public HomeWatcher(Context context) {
        mContext = context;
        mFilter = new IntentFilter(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
    }


    /**
     * 设置监听
     *
     * @param listener
     */
    public void setOnHomePressedListener(OnHomePressedListener listener) {
        mListener = listener;
        mRecevier = new InnerRecevier();
    }


    /**
     * 开始监听，注册广播
     */
    public void startWatch() {
        if (mRecevier != null) {
            mContext.registerReceiver(mRecevier, mFilter);
        }
    }


    /**
     * 停止监听，注销广播
     */
    public void stopWatch() {
        if (mRecevier != null) {
            mContext.unregisterReceiver(mRecevier);
        }
    }


    /**
     * 广播接收者
     */
    class InnerRecevier extends BroadcastReceiver {
        final String SYSTEM_DIALOG_REASON_KEY = "reason";
        final String SYSTEM_DIALOG_REASON_GLOBAL_ACTIONS = "globalactions";
        final String SYSTEM_DIALOG_REASON_RECENT_APPS = "recentapps";
        final String SYSTEM_DIALOG_REASON_HOME_KEY = "homekey";


        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (action.equals(Intent.ACTION_CLOSE_SYSTEM_DIALOGS)) {
                String reason = intent.getStringExtra(SYSTEM_DIALOG_REASON_KEY);
                if (reason != null) {
                    Log.e(TAG, "action:" + action + ",reason:" + reason);
                    if (mListener != null) {
                        if (reason.equals(SYSTEM_DIALOG_REASON_HOME_KEY)) {
                            // 短按home键
                            mListener.onHomePressed();
                        } else if (reason
                                .equals(SYSTEM_DIALOG_REASON_RECENT_APPS)) {
                            // 长按home键
                            mListener.onHomeLongPressed();
                        }
                    }
                }
            }
        }
    }
}

上述方法用于监听用户点击home键状态，调用方法如下，在oncreate里面开启广播调用监听：

HomeWatcher  mHomeWatcher = new HomeWatcher(this);
        mHomeWatcher.setOnHomePressedListener(new HomeWatcher.OnHomePressedListener() {
            @Override
            public void onHomePressed() {
                SharedPreferencesUtil.saveData(Basecactivity.this, "gesflag", true);
            }


            @Override
            public void onHomeLongPressed() {
            }
        });
        mHomeWatcher.startWatch();//开启广播

在ondetory里面取消广播

二：进行监听用户锁屏状态

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.PowerManager;




/**
 * 用于获取当前屏幕当前状态
 */
public class ScreenListener {


    private Context mContext;
    private ScreenBroadcastReceiver mScreenReceiver;
    private ScreenStateListener mScreenStateListener;


    public ScreenListener(Context context) {
        mContext = context;
        mScreenReceiver = new ScreenBroadcastReceiver();
    }


    /**
     * screen状态广播接收者
     */
    private class ScreenBroadcastReceiver extends BroadcastReceiver {
        private String action = null;


        @Override
        public void onReceive(Context context, Intent intent) {
            action = intent.getAction();
            if (Intent.ACTION_SCREEN_ON.equals(action)) { // 开屏
                mScreenStateListener.onScreenOn();
            } else if (Intent.ACTION_SCREEN_OFF.equals(action)) { // 锁屏
                mScreenStateListener.onScreenOff();
            } else if (Intent.ACTION_USER_PRESENT.equals(action)) { // 解锁
                mScreenStateListener.onUserPresent();
            }
        }
    }


    /**
     * 开始监听screen状态
     *
     * @param listener
     */
    public void begin(ScreenStateListener listener) {
        mScreenStateListener = listener;
        registerListener();
        //getScreenState();
    }


    /**
     * 首次调用屏幕是否获取当前screen状态
     * （此方法重要）
     */
    private void getScreenState() {
        PowerManager manager = (PowerManager) mContext
                .getSystemService(Context.POWER_SERVICE);
        if (manager.isScreenOn()) {
            if (mScreenStateListener != null) {
                mScreenStateListener.onScreenOn();
            }
        } else {
            if (mScreenStateListener != null) {
                mScreenStateListener.onScreenOff();
            }
        }
    }


    /**
     * 停止screen状态监听
     */
    public void unregisterListener() {
        mContext.unregisterReceiver(mScreenReceiver);
    }


    /**
     * 启动screen状态广播接收器
     */
    private void registerListener() {
        IntentFilter filter = new IntentFilter();
        filter.addAction(Intent.ACTION_SCREEN_ON);
        filter.addAction(Intent.ACTION_SCREEN_OFF);
        filter.addAction(Intent.ACTION_USER_PRESENT);
        mContext.registerReceiver(mScreenReceiver, filter);
    }


    public interface ScreenStateListener {// 返回给调用者屏幕状态信息


        public void onScreenOn();


        public void onScreenOff();


        public void onUserPresent();
    }
}

上述方法用于监听用户锁屏键状态，调用方法如下，在oncreate里面开启广播调用监听：

ScreenListener screen = new ScreenListener(this);
        screen.begin(new ScreenListener.ScreenStateListener() {
            @Override
            public void onScreenOn() {
                SharedPreferencesUtil.saveData(Basecactivity.this, "screenFlag", true);
            }


            @Override
            public void onScreenOff() {
                SharedPreferencesUtil.saveData(Basecactivity.this, "screenFlag", false);
            }


            @Override
            public void onUserPresent() {
            }
        });

在onrestart方法里面进行判断是否跳转验证手势密码界面

/**
     * 手势密码两种状态（点击home键和手机屏幕状态进行判定）
     */
    @Override
    protected void onRestart() {
        super.onRestart();
        if (actflag) {
            boolean gesflag = (boolean) SharedPreferencesUtil.getData(Basecactivity.this, "gesflag", false);
            boolean editFlag = (boolean) SharedPreferencesUtil.getData(Basecactivity.this, "editFlag", false);
            boolean screenFlag = (boolean) SharedPreferencesUtil.getData(Basecactivity.this, "screenFlag", false);
            if (editFlag) {
                if (gesflag || screenFlag) {
                    IntentUtil.startActivity(Basecactivity.this, GestureVerifyActivity.class);
                }
            }
        }
    }

在ondestrory里面进行取消广播操作：

protected void onDestroy() {
        super.onDestroy();
        if (actflag) {
            screen.unregisterListener();
            mHomeWatcher.stopWatch();
        }
    }

存储本地工具类为：

import android.content.Context;
import android.content.SharedPreferences;
//用于设置SharedPreferences进行封装


public class SharedPreferencesUtil {
    //存储的sharedpreferences文件名
    private static final String FILE_NAME = "test";


    /**
     * 保存数据到文件
     *
     * @param context
     * @param key
     * @param data
     */
    public static void saveData(Context context, String key, Object data) {


        String type = data.getClass().getSimpleName();
        SharedPreferences sharedPreferences = context
                .getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);
        SharedPreferences.Editor editor = sharedPreferences.edit();


        if ("Integer".equals(type)) {
            editor.putInt(key, (Integer) data);
        } else if ("Boolean".equals(type)) {
            editor.putBoolean(key, (Boolean) data);
        } else if ("String".equals(type)) {
            editor.putString(key, (String) data);
        } else if ("Float".equals(type)) {
            editor.putFloat(key, (Float) data);
        } else if ("Long".equals(type)) {
            editor.putLong(key, (Long) data);
        }


        editor.commit();
    }


    /**
     * 从文件中读取数据
     *
     * @param context
     * @param key
     * @param defValue
     * @return
     */
    public static Object getData(Context context, String key, Object defValue) {


        String type = defValue.getClass().getSimpleName();
        SharedPreferences sharedPreferences = context.getSharedPreferences
                (FILE_NAME, Context.MODE_PRIVATE);


        //defValue为为默认值，如果当前获取不到数据就返回它
        if ("Integer".equals(type)) {
            return sharedPreferences.getInt(key, (Integer) defValue);
        } else if ("Boolean".equals(type)) {
            return sharedPreferences.getBoolean(key, (Boolean) defValue);
        } else if ("String".equals(type)) {
            return sharedPreferences.getString(key, (String) defValue);
        } else if ("Float".equals(type)) {
            return sharedPreferences.getFloat(key, (Float) defValue);
        } else if ("Long".equals(type)) {
            return sharedPreferences.getLong(key, (Long) defValue);
        }


        return null;
    }


}