android基础--屏幕锁

九宫格 PIN密码 密码锁屏

     自从：API Level 8 (Android 2.2) 开始， Android提供了DevicePolicyManager类， 可以让你的应用程序也能执行屏幕锁定等操作，以下程序中会用到的锁定屏幕的操作类中要使用的对象有以下三个：

DevicePolicyManager

这是设备管理的主类。通过它可以实现屏幕锁定、屏幕亮度调节、出厂设置等功能。

DeviceAdminReceiver

该类继承自 BroadcastReceiver 。 从源码可以看到，其实就是实现了一个OnReceive方法，该方法中根据不同的Action，执行相应的操作。 比如，如果激活成功，那么Action就是ACTION_DEVICE_ADMIN_ENABLED， 据此调用 onEnabled 方法。

DeviceAdminInfo  设备信息

比如:

DeviceAdminReceiver.USES_POLICY_FORCE_LOCK , 这个就是本次要用的”强制锁定屏幕”的权限. 不过这些权限一般都直接通过XML文件来定义。 稍后你就会看到。

Android手机中手机屏幕的锁定方式有以下几种 ：

点击第一个按钮会跳到权限提醒页面，如图所示：

上面这个页面只是提醒你你要激活的所有设备权限，点击激活后会跳回首页，再去点击系统锁使用时，就达到咱们的目的啦，

在全局配置文件里面配置，不然报错的，添加以下代码：

<receiver
        android:name=".AdminReceiver"
        android:description="@string/description"
        android:label="@string/labelValue"
        android:permission="android.permission.BIND_DEVICE_ADMIN" >
              <meta-data
                    android:name="android.app.device_admin"
                    android:resource="@xml/lockourscreen"
                   />
        <intent-filter>
            <action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
        </intent-filter>
</receiver>

完整的代码：

主类：

import android.app.Activity;
import android.app.admin.DevicePolicyManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
/**
* @Title: DevicePolicyManagerDemoActivity.java
* @Description: 屏幕锁测试
*/
public class DevicePolicyManagerDemoActivity extends Activity
{
    private Button startPermissionBtn;
    private Button stopPermissionBtn;
    private Button sysLockBtn;
    private DevicePolicyManager dpm;
    private ComponentName componentName ;
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState)
   {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        //初始化
        init();
    }
    /**
    * 初始化实现
    */
    private void init(){
        //资源声明定位
        startPermissionBtn = (Button)findViewById(R.id.button1);
        stopPermissionBtn = (Button)findViewById(R.id.button2);
        sysLockBtn = (Button)findViewById(R.id.button3);
        startPermissionBtn.setOnClickListener(listener);
        stopPermissionBtn.setOnClickListener(listener);
        sysLockBtn.setOnClickListener(listener);
        //取得系统服务
        dpm  = (DevicePolicyManager)getSystemService(Context.DEVICE_POLICY_SERVICE);
        componentName = new ComponentName(this, AdminReceiver.class);
    }
    /**
    * 按钮监听器的实现,在实现监听的时候不要在一个分支里面写太多逻辑处理
    * 分支只负责分支，不负责处理，要处理的话可以模块化，处理函数抽出去就可以了
    */
    private OnClickListener listener = new OnClickListener()
   {
        @Override
        public void onClick(View v)
       {
            //以下是三个按钮分别处理的事件实现
            switch (v.getId())
          {
            case R.id.button1:
                //开启设备权限
                startDeviceManager();
                break;
            case R.id.button2:
                //停止设备权限
                stopDeviceManager();
                break;
            case R.id.button3:
                //调用系统锁
                sysLock();
                break;
            default:
                break;
            }
        }
    };
    /**
    * 启动设备管理权限
    */
    private void startDeviceManager()
   {
        //添加一个隐式意图，完成设备权限的添加
        //这个Intent (DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN)跳转到 权限提醒页面
       //并传递了两个参数EXTRA_DEVICE_ADMIN 、 EXTRA_ADD_EXPLANATION
        Intent intent = new Intent(DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN);
        //权限列表
        //EXTRA_DEVICE_ADMIN参数中说明了用到哪些权限，
        intent.putExtra(DevicePolicyManager.EXTRA_DEVICE_ADMIN, componentName);
        //描述(additional explanation)
        //EXTRA_ADD_EXPLANATION参数为附加的说明
        intent.putExtra(DevicePolicyManager.EXTRA_ADD_EXPLANATION, "咿呀咿呀哟");
        startActivityForResult(intent, 0);
      }
    /**
    * 禁用设备管理权限方法实现
    */
    private void stopDeviceManager()
   {
        Log.i("XXXX","------ unActiveManage ------");
        boolean active = dpm.isAdminActive(componentName);
        if (active) {
            dpm.removeActiveAdmin(componentName);
        }
    }
    /**
    * 调用系统锁方法实现
    */
    private void sysLock()
   {
        boolean active = dpm.isAdminActive(componentName);
        if (active) {
            dpm.lockNow();
        }
    }
}

接收类：

import android.app.admin.DeviceAdminReceiver;
import android.app.admin.DevicePolicyManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;
import android.widget.Toast;
public class AdminReceiver extends DeviceAdminReceiver
{
    @Override
    public DevicePolicyManager getManager(Context context)
   {
        Log.i("XXXX", "调用了getManager()方法");
        return super.getManager(context);
    }
    @Override
    public ComponentName getWho(Context context)
   {
        Log.i("XXXX", "调用了getWho()方法");
        return super.getWho(context);
    }
    /**
    * 禁用
    */
    @Override
    public void onDisabled(Context context, Intent intent)
   {
        Log.i("XXXX", "调用了onDisabled()方法");
        Toast.makeText(context, "禁用设备管理", Toast.LENGTH_SHORT).show();
        super.onDisabled(context, intent);
    }
    @Override
    public CharSequence onDisableRequested(Context context, Intent intent) {
        Log.i("XXXX", "调用了onDisableRequested()方法");
        return super.onDisableRequested(context, intent);
    }
    /**
    * 激活
    */
    @Override
    public void onEnabled(Context context, Intent intent) {
        Log.i("XXXX", "调用了onEnabled()方法");
        Toast.makeText(context, "启动设备管理", Toast.LENGTH_SHORT).show();
        super.onEnabled(context, intent);
    }
    @Override
    public void onPasswordChanged(Context context, Intent intent) {
        Log.i("XXXX", "调用了onPasswordChanged()方法");
        super.onPasswordChanged(context, intent);
    }
    @Override
    public void onPasswordFailed(Context context, Intent intent) {
        Log.i("XXXX", "调用了onPasswordFailed()方法");
        super.onPasswordFailed(context, intent);
    }
    @Override
    public void onPasswordSucceeded(Context context, Intent intent) {
        Log.i("XXXX", "调用了onPasswordSucceeded()方法");
        super.onPasswordSucceeded(context, intent);
    }
    @Override
    public void onReceive(Context context, Intent intent) {
        Log.i("XXXX", "调用了onReceive()方法");
        super.onReceive(context, intent);
    }
    @Override
    public IBinder peekService(Context myContext, Intent service) {
        Log.i("XXXX", "调用了peekService()方法");
        return super.peekService(myContext, service);
    }
}

权限文件lockourscreen.xml：

<?xml version="1.0" encoding="UTF-8"?>
<device-admin
  xmlns:android="http://schemas.android.com/apk/res/android">
    <uses-policies>
        <!-- 强行锁定 -->
        <force-lock />
        <!--  因为今天我们只讲下简单的，所以其它的权限，先暂时注释掉咯，有兴趣的朋友们可以打开自己试下-->
            <!-- 清除所有数据（恢复出厂设置）-->
.              <wipe-data />
.              <!-- 重置密码 -->
.              <reset-password />
.              <!-- 限制密码选择-->
.              <limit-password />
.              <!-- 监控登录尝试 -->
.              <watch-login />
.
.     </uses-policies>
. </device-admin>

全局配置文件：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.xxxxx.yyy"
    android:versionCode="1"
    android:versionName="1.0" >
    <uses-sdk android:minSdkVersion="15" />
    <application
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name" >
        <activity
            android:name=".DevicePolicyManagerDemoActivity"
            android:label="欢迎交流" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <receiver
            android:name=".AdminReceiver"
            android:description="@string/description"
            android:label="@string/labelValue"
            android:permission="android.permission.BIND_DEVICE_ADMIN"
            >
            <meta-data
                android:name="android.app.device_admin"
                android:resource="@xml/lockourscreen"/>
.             <intent-filter>
.                 <action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
.             </intent-filter>
.
.         </receiver>
.     </application>
.
. </manifest>

密码锁：

九宫格锁：

主控制类：

import android.app.Activity;
import android.app.admin.DevicePolicyManager;
import android.content.Intent;
mport android.content.SharedPreferences;
import android.os.Bundle;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.LinearLayout;
mport android.widget.Spinner;
import android.widget.TextView;
/**
* @Title: PolicySetupActivity.java
* @Description: 屏幕锁
*/
public class PolicySetupActivity extends Activity {
    private static final int REQ_ACTIVATE_DEVICE_ADMIN = 10;
    private static final String SCREEN_ID_KEY = "LAYOUT_ID";
    /**存储配置信息的SP文件名*/
    private static final String APP_PREF = "APP_PREF";
    /**有未知屏幕ID时返回此标识*/
  private static final int UNKNOWN_SCREEN_ID = -1;
    /**声明组件*/
    private Spinner mPasswordQualityInputField;
    private EditText mPasswordLengthInputField;
    private EditText mPasswordMinUppercaseInputField;
    /**获取配置操作类对象*/
    private Policy mPolicy;
    /**当前屏幕ID*/
    private int mCurrentScreenId;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mPolicy = new Policy(this);
    }
    @Override
    protected void onResume() {
        super.onResume();
        /**获取本地SP文件中屏幕锁的配置信息*/
        SharedPreferences prefs = getSharedPreferences(APP_PREF, MODE_PRIVATE);
        final int savedScreenId = prefs.getInt(SCREEN_ID_KEY, UNKNOWN_SCREEN_ID);
        /**如果获取到的ID为空,则跳转到设置页*/
        if (savedScreenId == UNKNOWN_SCREEN_ID || !mPolicy.isAdminActive()) {
            setScreenContent(R.layout.activity_policy_setup);
           /**跳转到配置详情页*/
        } else {
            setScreenContent(savedScreenId);
        }
    }
  /**
    * 设置屏幕方法实现,详细的可以自己看下官方文档
    * @param screenId
    */
    private void setScreenContent(final int screenId) {
        /**记录当前屏幕ID，并预先存入本地SP配置文件中*/
        mCurrentScreenId = screenId;
        setContentView(mCurrentScreenId);
        getSharedPreferences(APP_PREF, MODE_PRIVATE).edit().putInt(SCREEN_ID_KEY, mCurrentScreenId).commit();
        switch (mCurrentScreenId) {
           case R.layout.activity_policy_setup:
               initPolicySetupScreen();
               initNavigation();
               break;
           case R.layout.activity_view_policy:
               initViewPolicyScreen();
               initNavigation();
               break;
           }
       }
    /**
    * 关闭页面时将当前配置写入本地SP文件中
    */
    @Override
    protected void onPause() {
        super.onPause();
        if (mCurrentScreenId == R.layout.activity_policy_setup) {
           writePolicy();
       }
    }
  @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (requestCode == REQ_ACTIVATE_DEVICE_ADMIN && resultCode == RESULT_OK) {
            // User just activated the application as a device administrator.
            setScreenContent(mCurrentScreenId);
        } else {
            super.onActivityResult(requestCode, resultCode, data);
        }
    }
    /**
    * 重载返回键方法,如果已当前屏幕为已设置密码页,则展示详情
    */
    @Override
    public void onBackPressed() {
        if (mCurrentScreenId == R.layout.activity_view_policy) {
            setScreenContent(R.layout.activity_policy_setup);
            return;
        }
        super.onBackPressed();
    }
    /**
    * 初始化化设置页
    */
    private void initPolicySetupScreen() {
        mPasswordQualityInputField = (Spinner) findViewById(R.id.policy_password_quality);
        mPasswordLengthInputField = (EditText) findViewById(R.id.policy_password_length);
        mPasswordMinUppercaseInputField = (EditText) findViewById(R.id.policy_password_uppercase);
        ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource(this,
R.array.password_types, android.R.layout.simple_spinner_item);
        adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
        mPasswordQualityInputField.setAdapter(adapter);
        mPasswordQualityInputField.setOnItemSelectedListener(
           new AdapterView.OnItemSelectedListener() {
               public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) {
                   LinearLayout passwordMinUppercaseView =(LinearLayout) findViewById(R.id.password_uppercase_view);
                   // The minimum number of upper case field is only applicable for password
                   // qualities: alpha, alphanumeric, or complex.
                   if (pos > 2)
                       passwordMinUppercaseView.setVisibility(View.VISIBLE);
                   else
                       passwordMinUppercaseView.setVisibility(View.GONE);
               }
               public void onNothingSelected(AdapterView<?> parent) {}
        });
        /**阅读先前配置的相关信息*/
        mPolicy.readFromLocal();
        mPasswordQualityInputField.setSelection(mPolicy.getPasswordQuality());
        if (mPolicy.getPasswordLength() > 0) {
            mPasswordLengthInputField.setText(String.valueOf(mPolicy.getPasswordLength()));
        } else {
            mPasswordLengthInputField.setText("");
        }
        if (mPolicy.getPasswordMinUpperCase() > 0) {
            mPasswordMinUppercaseInputField.setText(String.valueOf(mPolicy.getPasswordMinUpperCase()));
        } else {
            mPasswordMinUppercaseInputField.setText("");
        }
    }
    /**
    * 初始化查看详情页
    */
    private void initViewPolicyScreen() {
        TextView passwordQualityView = (TextView) findViewById(R.id.policy_password_quality);
        TextView passwordLengthView = (TextView) findViewById(R.id.policy_password_length);
        // Read previously saved policy and populate on the UI.
        mPolicy.readFromLocal();
        int passwordQualitySelection = mPolicy.getPasswordQuality();
        passwordQualityView.setText(getResources().getStringArray(R.array.password_types)[passwordQualitySelection]);
        passwordLengthView.setText(String.valueOf(mPolicy.getPasswordLength()));
        if (passwordQualitySelection > 2) {
            LinearLayout passwordMinUppercaseView =(LinearLayout) findViewById(R.id.password_uppercase_view);
            passwordMinUppercaseView.setVisibility(View.VISIBLE);
            ((TextView)findViewById(R.id.policy_password_uppercase)).setText(String.valueOf(mPolicy.getPasswordMinUpperCase()));
        }
    }
    /**
    * 设置导航信息
    */
    private void initNavigation() {
        if (!mPolicy.isAdminActive()) {
            // Activates device administrator.
            setupNavigation(R.string.setup_message_activate,R.string.setup_action_activate,mActivateButtonListener);
        } else if (mCurrentScreenId == R.layout.activity_policy_setup) {
            setupNavigation(
                   R.string.setup_message_set_policy,
                    R.string.setup_action_set_policy,
                    new View.OnClickListener() {
                        public void onClick(View view) {
                            writePolicy();
                            mPolicy.configurePolicy();
                            setScreenContent(R.layout.activity_view_policy);
                        }
                    });
        }else if (!mPolicy.isActivePasswordSufficient()) {
            // Launches password set-up screen in Settings.
            setupNavigation(R.string.setup_message_enforce_policy,R.string.setup_action_enforce_policy,mEnforcePolicyListener);
        } else {
            // Grants access to secure content.
            setupNavigation(
                   R.string.setup_message_go_secured,
                    R.string.setup_action_go_secured,
                    new View.OnClickListener() {
                        public void onClick(View view) {
                            startActivity(new Intent(view.getContext(), SecureActivity.class));
                        }
                    });
           }
       }
    /**
    * 监听器实现
    */
    private View.OnClickListener mActivateButtonListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            // First, persist the policy.  Then, launch intent to trigger the system screen
            // requesting user to confirm the activation of the device administrator.
            writePolicy();
            Intent activateDeviceAdminIntent =new Intent(DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN);
            activateDeviceAdminIntent.putExtra(DevicePolicyManager.EXTRA_DEVICE_ADMIN,mPolicy.getPolicyAdmin());
            // It is good practice to include the optional explanation text to explain to
            // user why the application is requesting to be a device administrator.  The system
            // will display this message on the activation screen.
            activateDeviceAdminIntent.putExtra(DevicePolicyManager.EXTRA_ADD_EXPLANATION,
                    getResources().getString(R.string.device_admin_activation_message));
            startActivityForResult(activateDeviceAdminIntent, REQ_ACTIVATE_DEVICE_ADMIN);
        }
    };
    /**
    * 监听器实现
    */
    private View.OnClickListener mEnforcePolicyListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            writePolicy();
            // The device administration API does not "fix" the password if it is
            // determined that the current password does not conform to what is requested
            // by the policy.  The caller is responsible for triggering the password set up
            // screen via the below intent.
            Intent intent = new Intent(DevicePolicyManager.ACTION_SET_NEW_PASSWORD);
            startActivity(intent);
        }
    };
    /**
    * 设置激活按钮不同状态时的文本信息
    * @param messageResId
    * @param buttonTextResId
    * @param listener
    */
    private void setupNavigation(int messageResId, int buttonTextResId,View.OnClickListener listener) {
        TextView setupMessage = (TextView) findViewById(R.id.setup_message);
        setupMessage.setText(messageResId);
        Button actionBtn = (Button) findViewById(R.id.setup_action_btn);
        actionBtn.setText(buttonTextResId);
        actionBtn.setOnClickListener(listener);
    }
    // 在关闭此页时，将配置信息写入本地SP文件中.
    private void writePolicy() {
        int passwordQuality = (int) mPasswordQualityInputField.getSelectedItemId();
        int passwordLength = 0;
        try {
            passwordLength = Integer.valueOf(mPasswordLengthInputField.getText().toString());
        } catch (NumberFormatException nfe) {}  // Defaults to 0.
        int passwordMinUppercase = 0;
        try {
            passwordMinUppercase =Integer.valueOf(mPasswordMinUppercaseInputField.getText().toString());
        } catch (NumberFormatException nfe) {}  // Defaults to 0.
        mPolicy.saveToLocal(passwordQuality, passwordLength, passwordMinUppercase);
    }
}

配置操作类:

import android.app.Activity;
import android.app.admin.DeviceAdminReceiver;
import android.app.admin.DevicePolicyManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Build;
/**
* @Title: Policy.java
* @Package com.xxxxx.policymanager.demo
* @Description: 用来获取相关安全配置信息的类
*/
public class Policy {
    public static final int REQUEST_ADD_DEVICE_ADMIN = 1;
    /**保存屏幕锁相关参数的SP文件名*/
    private static final String APP_PREF = "APP_PREF";
    /**下面三个是往SP中存储时的Key*/
    private static final String KEY_PASSWORD_LENGTH = "PW_LENGTH";
    private static final String KEY_PASSWORD_QUALITY = "PW_QUALITY";
    private static final String KEY_PASSWORD_MIN_UPPERCASE = "PW_MIN_UPPERCASE";
    /**
    * 下面是可允许输入密码的类型,此处的类型必须与string.xml文件中定义的arrays.xml中的相匹配
    */
    final static int[] PASSWORD_QUALITY_VALUES = new int[] {
        DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED,
        DevicePolicyManager.PASSWORD_QUALITY_SOMETHING,
        DevicePolicyManager.PASSWORD_QUALITY_NUMERIC,
        DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC,
        DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC,
        DevicePolicyManager.PASSWORD_QUALITY_COMPLEX
    };
    private int mPasswordQuality;
    private int mPasswordLength;
    private int mPasswordMinUpperCase;
    private Context mContext;
    private DevicePolicyManager mDPM;
    private ComponentName mPolicyAdmin;
    /**
    * 构造器，在new此类对象时，获取系统级管理员对象 DevicePolicyManager
    * @param context
    */
    public Policy(Context context) {
        mContext = context;
        mPasswordQuality = -1;
        mPasswordLength = 0;
        mPasswordMinUpperCase = 0;
        mDPM = (DevicePolicyManager) context.getSystemService(Context.DEVICE_POLICY_SERVICE);
        mPolicyAdmin = new ComponentName(context, PolicyAdmin.class);
    }
    /**
    * 保存设备参数
    */
    public void saveToLocal(int passwordQuality, int passwordLength, int passwordMinUppercase) {
        SharedPreferences.Editor editor =mContext.getSharedPreferences(APP_PREF, Context.MODE_PRIVATE).edit();
        if (mPasswordQuality != passwordQuality) {
            editor.putInt(KEY_PASSWORD_QUALITY, passwordQuality);
            mPasswordQuality = passwordQuality;
        }
        if (mPasswordLength != passwordLength) {
            editor.putInt(KEY_PASSWORD_LENGTH, passwordLength);
            mPasswordLength = passwordLength;
        }
        if (mPasswordMinUpperCase != passwordMinUppercase) {
            editor.putInt(KEY_PASSWORD_MIN_UPPERCASE, passwordMinUppercase);
            mPasswordMinUpperCase = passwordMinUppercase;
        }
        editor.commit();
    }
    /**
    * 从本地SP文件中获取密码配置参数
    */
    public void readFromLocal() {
        SharedPreferences prefs = mContext.getSharedPreferences(APP_PREF, Context.MODE_PRIVATE);
        mPasswordQuality = prefs.getInt(KEY_PASSWORD_QUALITY, -1);
        mPasswordLength = prefs.getInt(KEY_PASSWORD_LENGTH, -1);
        mPasswordMinUpperCase = prefs.getInt(KEY_PASSWORD_MIN_UPPERCASE, -1);
    }
    /**
    * 获取密码.
    *
    * @return
    */
    public int getPasswordQuality() { return mPasswordQuality; }
    /**
    * 获取密码长度.
    *
    * @return
    */
    public int getPasswordLength() { return mPasswordLength; }
    /**
    * 获取字母密码.
    *
    * @return
    */
    public int getPasswordMinUpperCase() { return mPasswordMinUpperCase; }
    /**
    * 获取设备管理的 ComponentName 对象.
    *
    * @return
    */
    public ComponentName getPolicyAdmin() { return mPolicyAdmin; }
    /**
    * 判断设备是否被激活.
    *
    * @return
    */
    public boolean isAdminActive() {
        return mDPM.isAdminActive(mPolicyAdmin);
    }
    public boolean isActivePasswordSufficient() {
        return mDPM.isActivePasswordSufficient();
    }
    /**
    * 判断设备是否加安全
    * @return
    */
    public boolean isDeviceSecured() {
        return isAdminActive() && isActivePasswordSufficient();
    }
    /**
    * 在声明的mDPM对象中进行配置.
    */
    public void configurePolicy() {
        mDPM.setPasswordQuality(mPolicyAdmin, PASSWORD_QUALITY_VALUES[mPasswordQuality]);
        mDPM.setPasswordMinimumLength(mPolicyAdmin, mPasswordLength);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
            mDPM.setPasswordMinimumUpperCase(mPolicyAdmin, mPasswordMinUpperCase);
        }
    }
    /**
    * 下面这个类用来监听各种不同类型的设备管理事件,比如:改变密码..错误密码等等
    */
    public static class PolicyAdmin extends DeviceAdminReceiver {
        @Override
        public void onDisabled(Context context, Intent intent) {
            // Called when the app is about to be deactivated as a device administrator.
            super.onDisabled(context, intent);
            SharedPreferences prefs = context.getSharedPreferences(APP_PREF, Activity.MODE_PRIVATE);
            /**清除以前在SP文件下保存的所有值*/
            prefs.edit().clear().commit();
        }
    }
}

权限验证类:

import android.app.Activity;
import android.content.Intent;
/**
* @Title: SecureActivity.java
* @Package com.xxxxx.policymanager.demo
* @Description: 权限验证类实现
*/
public class SecureActivity extends Activity {
    @Override
    protected void onResume() {
        super.onResume();
        // Check to see if the device is properly secured as per the policy.  Send user
        // back to policy set up screen if necessary.
        Policy policy = new Policy(this);
        policy.readFromLocal();
        if (!policy.isDeviceSecured()) {
            Intent intent = new Intent();
            intent.setClass(this, PolicySetupActivity.class);
            intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP | Intent.FLAG_ACTIVITY_CLEAR_TASK);
            startActivity(intent);
            finish();
        }
        setContentView(R.layout.activity_secure);
    }
}