Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e7d6e4dd authored by Toni Barzic's avatar Toni Barzic
Browse files

Teach settings about PASSWORD_QUALITY_MANAGED constant 

Add hooks for adding an option for selecting a managed password as
lock credential. By default this option will not be visible.

BUG=27923581

Change-Id: Id17bd8074bf23cbcffb96d8576cc760df6f2298a
parent 36cce830

res/xml/security_settings_picker.xml

+4 −0
Original line number Diff line number Diff line
@@ -43,4 +43,8 @@ 
            android:title="@string/unlock_set_unlock_password_title"

            android:persistent="false"/>



    <com.android.settingslib.RestrictedPreference

            android:key="unlock_set_managed"

            android:persistent="false"/>



</PreferenceScreen>

src/com/android/settings/ChooseLockGeneric.java

+31 −2
Original line number Diff line number Diff line
@@ -92,6 +92,7 @@ public class ChooseLockGeneric extends SettingsActivity { 
        private static final String KEY_UNLOCK_SET_PIN = "unlock_set_pin";

        private static final String KEY_UNLOCK_SET_PASSWORD = "unlock_set_password";

        private static final String KEY_UNLOCK_SET_PATTERN = "unlock_set_pattern";

        private static final String KEY_UNLOCK_SET_MANAGED = "unlock_set_managed";

        private static final String PASSWORD_CONFIRMED = "password_confirmed";

        private static final String WAITING_FOR_CONFIRMATION = "waiting_for_confirmation";

        public static final String MINIMUM_QUALITY_KEY = "minimum_quality";
@@ -120,6 +121,7 @@ public class ChooseLockGeneric extends SettingsActivity { 
        private FingerprintManager mFingerprintManager;

        private int mUserId;

        private boolean mHideDrawer = false;

        private ManagedLockPasswordProvider mManagedPasswordProvider;



        protected boolean mForFingerprint = false;
@@ -181,6 +183,8 @@ public class ChooseLockGeneric extends SettingsActivity { 
                mUserId = targetUser;

            }



            mManagedPasswordProvider = ManagedLockPasswordProvider.get(getActivity(), mUserId);



            if (mPasswordConfirmed) {

                updatePreferencesOrFinish();

                if (mForChangeCredRequiredForBoot) {
@@ -356,6 +360,13 @@ public class ChooseLockGeneric extends SettingsActivity { 
                Preference password = findPreference(KEY_UNLOCK_SET_PASSWORD);

                password.setTitle(R.string.fingerprint_unlock_set_unlock_password);

            }



            if (mManagedPasswordProvider.isSettingManagedPasswordSupported()) {

                Preference managed = findPreference(KEY_UNLOCK_SET_MANAGED);

                managed.setTitle(mManagedPasswordProvider.getPickerOptionTitle(mForFingerprint));

            } else {

                removePreference(KEY_UNLOCK_SET_MANAGED);

            }

        }



        private void updateCurrentPreference() {
@@ -380,7 +391,10 @@ public class ChooseLockGeneric extends SettingsActivity { 
                    return KEY_UNLOCK_SET_PIN;

                case DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC:

                case DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC:

                case DevicePolicyManager.PASSWORD_QUALITY_COMPLEX:

                    return KEY_UNLOCK_SET_PASSWORD;

                case DevicePolicyManager.PASSWORD_QUALITY_MANAGED:

                    return KEY_UNLOCK_SET_MANAGED;

                case DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED:

                    return KEY_UNLOCK_SET_NONE;

            }
@@ -462,6 +476,11 @@ public class ChooseLockGeneric extends SettingsActivity { 
                        enabled = quality <= DevicePolicyManager.PASSWORD_QUALITY_COMPLEX;

                        disabledByAdmin = adminEnforcedQuality

                                > DevicePolicyManager.PASSWORD_QUALITY_COMPLEX;

                    } else if (KEY_UNLOCK_SET_MANAGED.equals(key)) {

                        enabled = quality <= DevicePolicyManager.PASSWORD_QUALITY_MANAGED

                                && mManagedPasswordProvider.isManagedPasswordChoosable();

                        disabledByAdmin = adminEnforcedQuality

                                > DevicePolicyManager.PASSWORD_QUALITY_MANAGED;

                    }

                    if (hideDisabled) {

                        visible = enabled;
@@ -508,13 +527,18 @@ public class ChooseLockGeneric extends SettingsActivity { 
                switch (preference.getKey()) {

                    case KEY_UNLOCK_SET_PATTERN:

                    case KEY_UNLOCK_SET_PIN:

                    case KEY_UNLOCK_SET_PASSWORD: {

                    case KEY_UNLOCK_SET_PASSWORD:

                    case KEY_UNLOCK_SET_MANAGED: {

                        preference.setSummary(summary);

                    } break;

                }

            }

        }



        protected Intent getLockManagedPasswordIntent(boolean requirePassword, String password) {

            return mManagedPasswordProvider.createIntent(requirePassword, password);

        }



        protected Intent getLockPasswordIntent(Context context, int quality,

                int minLength, final int maxLength,

                boolean requirePasswordToDecrypt, boolean confirmCredentials, int userId) {
@@ -593,7 +617,9 @@ public class ChooseLockGeneric extends SettingsActivity { 
        private Intent getIntentForUnlockMethod(int quality, boolean disabled) {

            Intent intent = null;

            final Context context = getActivity();

            if (quality >= DevicePolicyManager.PASSWORD_QUALITY_NUMERIC) {

            if (quality >= DevicePolicyManager.PASSWORD_QUALITY_MANAGED) {

                intent = getLockManagedPasswordIntent(mRequirePassword, mUserPassword);

            } else if (quality >= DevicePolicyManager.PASSWORD_QUALITY_NUMERIC) {

                int minLength = mDPM.getPasswordMinimumLength(null, mUserId);

                if (minLength < MIN_PASSWORD_LENGTH) {

                    minLength = MIN_PASSWORD_LENGTH;
@@ -721,6 +747,7 @@ public class ChooseLockGeneric extends SettingsActivity { 
                case DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC:

                case DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC:

                case DevicePolicyManager.PASSWORD_QUALITY_COMPLEX:

                case DevicePolicyManager.PASSWORD_QUALITY_MANAGED:

                    if (hasFingerprints && isProfile) {

                        return R.string

                                .unlock_disable_frp_warning_content_password_fingerprint_profile;
@@ -759,6 +786,8 @@ public class ChooseLockGeneric extends SettingsActivity { 
            } else if (KEY_UNLOCK_SET_NONE.equals(unlockMethod)) {

                updateUnlockMethodAndFinish(

                        DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED, false /* disabled */ );

            } else if (KEY_UNLOCK_SET_MANAGED.equals(unlockMethod)) {

                maybeEnableEncryption(DevicePolicyManager.PASSWORD_QUALITY_MANAGED, false);

            } else if (KEY_UNLOCK_SET_PATTERN.equals(unlockMethod)) {

                maybeEnableEncryption(

                        DevicePolicyManager.PASSWORD_QUALITY_SOMETHING, false);

src/com/android/settings/ChooseLockSettingsHelper.java

+1 −0
Original line number Diff line number Diff line
@@ -189,6 +189,7 @@ public final class ChooseLockSettingsHelper { 
            case DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC:

            case DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC:

            case DevicePolicyManager.PASSWORD_QUALITY_COMPLEX:

            case DevicePolicyManager.PASSWORD_QUALITY_MANAGED:

                launched = launchConfirmationActivity(request, title, header, description,

                        returnCredentials || hasChallenge

                                ? ConfirmLockPassword.InternalActivity.class

src/com/android/settings/ConfirmLockPassword.java

+2 −1
Original line number Diff line number Diff line
@@ -121,7 +121,8 @@ public class ConfirmLockPassword extends ConfirmDeviceCredentialBaseActivity { 
            mErrorTextView = (TextView) view.findViewById(R.id.errorText);

            mIsAlpha = DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC == storedQuality

                    || DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC == storedQuality

                    || DevicePolicyManager.PASSWORD_QUALITY_COMPLEX == storedQuality;

                    || DevicePolicyManager.PASSWORD_QUALITY_COMPLEX == storedQuality

                    || DevicePolicyManager.PASSWORD_QUALITY_MANAGED == storedQuality;



            mImm = (InputMethodManager) getActivity().getSystemService(

                    Context.INPUT_METHOD_SERVICE);

src/com/android/settings/ManagedLockPasswordProvider.java

0 → 100644
+85 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2016 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License

 */



package com.android.settings;



import android.content.Context;

import android.content.Intent;



/**

 * Helper for handling managed passwords in security settings UI.

 * It provides resources that should be shown in settings UI when lock password quality is set to

 * {@link android.app.admin.DevicePolicyManager#PASSWORD_QUALITY_MANAGED} and hooks for implementing

 * an option for setting the password quality to

 * {@link android.app.admin.DevicePolicyManager#PASSWORD_QUALITY_MANAGED}.

 */

public class ManagedLockPasswordProvider {

    /** Factory method to make it easier to inject extended ManagedLockPasswordProviders. */

    static ManagedLockPasswordProvider get(Context context, int userId) {

        return new ManagedLockPasswordProvider();

    }



    protected ManagedLockPasswordProvider() {}



    /**

     * Whether choosing/setting a managed lock password is supported for the user.

     * Please update {@link #getPickerOptionTitle(boolean)} if overridden to return true.

     */

    boolean isSettingManagedPasswordSupported() { return false; }



    /**

     * Whether the user should be able to choose managed lock password.

     */

    boolean isManagedPasswordChoosable() { return false; }



    /**

     * Returns title for managed password preference in security (lock) setting picker.

     * Should be overridden if {@link #isManagedPasswordSupported()} returns true.

     * @param forFingerprint Whether fingerprint unlock is enabled.

     */

    String getPickerOptionTitle(boolean forFingerprint) { return ""; }



    /**

     * Gets resource id of the lock screen preference that should be displayed in security settings

     * if the current password quality is set to

     * {@link android.app.admin.DevicePolicyManager#PASSWORD_QUALITY_MANAGED}.

     * @param forProfile Whether the settings are shown for a user profile rather than a user.

     */

    int getResIdForLockUnlockScreen(boolean forProfile) {

        return forProfile ? R.xml.security_settings_password_profile

                : R.xml.security_settings_password;

    }



    /**

     * Gets resource id of the subscreen that should be shown after clicking gear icon for lock

     * screen preference in security settings if the current password quality is set to

     * {@link android.app.admin.DevicePolicyManager#PASSWORD_QUALITY_MANAGED}.

     */

    int getResIdForLockUnlockSubScreen() {

        return R.xml.security_settings_password_sub;

    }



    /**

     * Creates intent that should be launched when user chooses managed password in the lock

     * settings picker.

     * @param requirePasswordToDecrypt Whether a password is needed to decrypt the user.

     * @param password Current lock password.

     * @return Intent that should update lock password to a managed password.

     */

    Intent createIntent(boolean requirePasswordToDecrypt, String password) {

        return null;

    }

}