Convert SecuritySubSetting into DashboardFragment

Bug: 32953042
Test: robotests
Change-Id: Iecdb0a42695644ff8aa095bcd49b5ccb16aa46d4

src/com/android/settings/security/OwnerInfoPreferenceController.java

@@ -22,9 +22,10 @@ import android.support.annotation.VisibleForTesting;
 import android.support.v7.preference.Preference;
 import android.support.v7.preference.Preference.OnPreferenceClickListener;
 import android.support.v7.preference.PreferenceScreen;
+
 import com.android.internal.widget.LockPatternUtils;
-import com.android.settings.OwnerInfoSettings;
 import com.android.settings.core.PreferenceControllerMixin;
+import com.android.settings.users.OwnerInfoSettings;
 import com.android.settingslib.RestrictedLockUtils;
 import com.android.settingslib.RestrictedLockUtils.EnforcedAdmin;
 import com.android.settingslib.RestrictedPreference;
@@ -45,7 +46,7 @@ public class OwnerInfoPreferenceController extends AbstractPreferenceController
 
     // Container fragment should implement this in order to show the correct summary
     public interface OwnerInfoCallback {
-        public void onOwnerInfoUpdated();
+        void onOwnerInfoUpdated();
     }
 
     public OwnerInfoPreferenceController(Context context, Fragment parent, Lifecycle lifecycle ) {

src/com/android/settings/security/SecuritySettings.java

@@ -67,6 +67,7 @@ import com.android.settings.password.ManagedLockPasswordProvider;
 import com.android.settings.search.BaseSearchIndexProvider;
 import com.android.settings.search.Indexable;
 import com.android.settings.search.SearchIndexableRaw;
+import com.android.settings.security.screenlock.ScreenLockSettings;
 import com.android.settings.security.trustagent.TrustAgentManager;
 import com.android.settings.security.trustagent.TrustAgentManager.TrustAgentComponentInfo;
 import com.android.settings.widget.GearPreference;
@@ -522,7 +523,7 @@ public class SecuritySettings extends SettingsPreferenceFragment
     @Override
     public void onGearClick(GearPreference p) {
         if (KEY_UNLOCK_SET_OR_CHANGE.equals(p.getKey())) {
-            startFragment(this, SecuritySubSettings.class.getName(), 0, 0, null);
+            startFragment(this, ScreenLockSettings.class.getName(), 0, 0, null);
         }
     }
 
@@ -763,7 +764,7 @@ public class SecuritySettings extends SettingsPreferenceFragment
         @Override
         public List<SearchIndexableResource> getXmlResourcesToIndex(
                 Context context, boolean enabled) {
-            final List<SearchIndexableResource> index = new ArrayList<SearchIndexableResource>();
+            final List<SearchIndexableResource> index = new ArrayList<>();
 
             final LockPatternUtils lockPatternUtils = new LockPatternUtils(context);
             final ManagedLockPasswordProvider managedPasswordProvider =
@@ -792,12 +793,6 @@ public class SecuritySettings extends SettingsPreferenceFragment
                         lockPatternUtils, managedPasswordProvider, profileUserId)));
             }
 
-            final SearchIndexableResource sir = getSearchResource(context,
-                    SecuritySubSettings.getResIdForLockUnlockSubScreen(lockPatternUtils,
-                            managedPasswordProvider));
-            sir.className = SecuritySubSettings.class.getName();
-            index.add(sir);
-
             // Append the rest of the settings
             index.add(getSearchResource(context, R.xml.security_settings_misc));
 

src/com/android/settings/security/SecuritySubSettings.java

@@ -1,252 +0,0 @@
-/*
- * Copyright (C) 2017 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.security;
-
-import static android.provider.Settings.System.SCREEN_OFF_TIMEOUT;
-
-import android.app.admin.DevicePolicyManager;
-import android.content.Intent;
-import android.os.Bundle;
-import android.os.UserHandle;
-import android.provider.Settings;
-import android.support.v14.preference.SwitchPreference;
-import android.support.v7.preference.Preference;
-import android.support.v7.preference.PreferenceScreen;
-import android.text.TextUtils;
-import android.util.Log;
-
-import com.android.internal.logging.nano.MetricsProto;
-import com.android.internal.widget.LockPatternUtils;
-import com.android.settings.R;
-import com.android.settings.SettingsPreferenceFragment;
-import com.android.settings.TimeoutListPreference;
-import com.android.settings.overlay.FeatureFactory;
-import com.android.settings.password.ManagedLockPasswordProvider;
-import com.android.settings.security.trustagent.TrustAgentManager;
-import com.android.settingslib.RestrictedLockUtils;
-
-public class SecuritySubSettings extends SettingsPreferenceFragment
-        implements Preference.OnPreferenceChangeListener,
-        OwnerInfoPreferenceController.OwnerInfoCallback {
-
-    private static final String TAG = "SecuritySubSettings";
-
-    private static final String KEY_VISIBLE_PATTERN = "visiblepattern";
-    private static final String KEY_LOCK_AFTER_TIMEOUT = "lock_after_timeout";
-    private static final String KEY_POWER_INSTANTLY_LOCKS = "power_button_instantly_locks";
-
-    // These switch preferences need special handling since they're not all stored in Settings.
-    private static final String SWITCH_PREFERENCE_KEYS[] = {
-            KEY_LOCK_AFTER_TIMEOUT, KEY_VISIBLE_PATTERN, KEY_POWER_INSTANTLY_LOCKS};
-    private static final int MY_USER_ID = UserHandle.myUserId();
-
-    private TimeoutListPreference mLockAfter;
-    private SwitchPreference mVisiblePattern;
-    private SwitchPreference mPowerButtonInstantlyLocks;
-
-    private TrustAgentManager mTrustAgentManager;
-    private LockPatternUtils mLockPatternUtils;
-    private DevicePolicyManager mDPM;
-    private OwnerInfoPreferenceController mOwnerInfoPreferenceController;
-
-    @Override
-    public int getMetricsCategory() {
-        return MetricsProto.MetricsEvent.SECURITY;
-    }
-
-    @Override
-    public void onCreate(Bundle icicle) {
-        super.onCreate(icicle);
-        mTrustAgentManager =
-                FeatureFactory.getFactory(
-                        getActivity()).getSecurityFeatureProvider().getTrustAgentManager();
-        mLockPatternUtils = new LockPatternUtils(getContext());
-        mDPM = getContext().getSystemService(DevicePolicyManager.class);
-        mOwnerInfoPreferenceController =
-                new OwnerInfoPreferenceController(getContext(), this, null /* lifecycle */);
-        createPreferenceHierarchy();
-    }
-
-    @Override
-    public void onResume() {
-        super.onResume();
-
-        createPreferenceHierarchy();
-
-        if (mVisiblePattern != null) {
-            mVisiblePattern.setChecked(mLockPatternUtils.isVisiblePatternEnabled(MY_USER_ID));
-        }
-        if (mPowerButtonInstantlyLocks != null) {
-            mPowerButtonInstantlyLocks.setChecked(
-                    mLockPatternUtils.getPowerButtonInstantlyLocks(MY_USER_ID));
-        }
-
-        mOwnerInfoPreferenceController.updateSummary();
-    }
-
-    @Override
-    public void onActivityResult(int requestCode, int resultCode, Intent data) {
-        super.onActivityResult(requestCode, resultCode, data);
-
-        createPreferenceHierarchy();
-    }
-
-    private void createPreferenceHierarchy() {
-        PreferenceScreen root = getPreferenceScreen();
-        if (root != null) {
-            root.removeAll();
-        }
-
-        final int resid = getResIdForLockUnlockSubScreen(new LockPatternUtils(getContext()),
-                ManagedLockPasswordProvider.get(getContext(), MY_USER_ID));
-        addPreferencesFromResource(resid);
-
-        // lock after preference
-        mLockAfter = (TimeoutListPreference) findPreference(KEY_LOCK_AFTER_TIMEOUT);
-        if (mLockAfter != null) {
-            setupLockAfterPreference();
-            updateLockAfterPreferenceSummary();
-        }
-
-        // visible pattern
-        mVisiblePattern = (SwitchPreference) findPreference(KEY_VISIBLE_PATTERN);
-
-        // lock instantly on power key press
-        mPowerButtonInstantlyLocks = (SwitchPreference) findPreference(
-                KEY_POWER_INSTANTLY_LOCKS);
-        final CharSequence trustAgentLabel = mTrustAgentManager.getActiveTrustAgentLabel(
-                getContext(), mLockPatternUtils);
-        if (mPowerButtonInstantlyLocks != null && !TextUtils.isEmpty(trustAgentLabel)) {
-            mPowerButtonInstantlyLocks.setSummary(getString(
-                    R.string.lockpattern_settings_power_button_instantly_locks_summary,
-                    trustAgentLabel));
-        }
-
-        mOwnerInfoPreferenceController.displayPreference(getPreferenceScreen());
-        mOwnerInfoPreferenceController.updateEnableState();
-
-        for (int i = 0; i < SWITCH_PREFERENCE_KEYS.length; i++) {
-            final Preference pref = findPreference(SWITCH_PREFERENCE_KEYS[i]);
-            if (pref != null) pref.setOnPreferenceChangeListener(this);
-        }
-    }
-
-    private void setupLockAfterPreference() {
-        // Compatible with pre-Froyo
-        long currentTimeout = Settings.Secure.getLong(getContentResolver(),
-                Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT, 5000);
-        mLockAfter.setValue(String.valueOf(currentTimeout));
-        mLockAfter.setOnPreferenceChangeListener(this);
-        if (mDPM != null) {
-            final RestrictedLockUtils.EnforcedAdmin admin =
-                    RestrictedLockUtils.checkIfMaximumTimeToLockIsSet(
-                            getActivity());
-            final long adminTimeout = mDPM
-                    .getMaximumTimeToLockForUserAndProfiles(UserHandle.myUserId());
-            final long displayTimeout = Math.max(0,
-                    Settings.System.getInt(getContentResolver(), SCREEN_OFF_TIMEOUT, 0));
-            // This setting is a slave to display timeout when a device policy is enforced.
-            // As such, maxLockTimeout = adminTimeout - displayTimeout.
-            // If there isn't enough time, shows "immediately" setting.
-            final long maxTimeout = Math.max(0, adminTimeout - displayTimeout);
-            mLockAfter.removeUnusableTimeouts(maxTimeout, admin);
-        }
-    }
-
-    private void updateLockAfterPreferenceSummary() {
-        final String summary;
-        if (mLockAfter.isDisabledByAdmin()) {
-            summary = getString(R.string.disabled_by_policy_title);
-        } else {
-            // Update summary message with current value
-            long currentTimeout = Settings.Secure.getLong(getContentResolver(),
-                    Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT, 5000);
-            final CharSequence[] entries = mLockAfter.getEntries();
-            final CharSequence[] values = mLockAfter.getEntryValues();
-            int best = 0;
-            for (int i = 0; i < values.length; i++) {
-                long timeout = Long.valueOf(values[i].toString());
-                if (currentTimeout >= timeout) {
-                    best = i;
-                }
-            }
-
-            final CharSequence trustAgentLabel = mTrustAgentManager
-                    .getActiveTrustAgentLabel(getContext(), mLockPatternUtils);
-            if (!TextUtils.isEmpty(trustAgentLabel)) {
-                if (Long.valueOf(values[best].toString()) == 0) {
-                    summary = getString(R.string.lock_immediately_summary_with_exception,
-                            trustAgentLabel);
-                } else {
-                    summary = getString(R.string.lock_after_timeout_summary_with_exception,
-                            entries[best], trustAgentLabel);
-                }
-            } else {
-                summary = getString(R.string.lock_after_timeout_summary, entries[best]);
-            }
-        }
-        mLockAfter.setSummary(summary);
-    }
-
-    @Override
-    public void onOwnerInfoUpdated() {
-        mOwnerInfoPreferenceController.updateSummary();
-    }
-
-    static int getResIdForLockUnlockSubScreen(LockPatternUtils lockPatternUtils,
-            ManagedLockPasswordProvider managedPasswordProvider) {
-        if (lockPatternUtils.isSecure(MY_USER_ID)) {
-            switch (lockPatternUtils.getKeyguardStoredPasswordQuality(MY_USER_ID)) {
-                case DevicePolicyManager.PASSWORD_QUALITY_SOMETHING:
-                    return R.xml.security_settings_pattern_sub;
-                case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC:
-                case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC_COMPLEX:
-                    return R.xml.security_settings_pin_sub;
-                case DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC:
-                case DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC:
-                case DevicePolicyManager.PASSWORD_QUALITY_COMPLEX:
-                    return R.xml.security_settings_password_sub;
-                case DevicePolicyManager.PASSWORD_QUALITY_MANAGED:
-                    return managedPasswordProvider.getResIdForLockUnlockSubScreen();
-            }
-        } else if (!lockPatternUtils.isLockScreenDisabled(MY_USER_ID)) {
-            return R.xml.security_settings_slide_sub;
-        }
-        return 0;
-    }
-
-    @Override
-    public boolean onPreferenceChange(Preference preference, Object value) {
-        String key = preference.getKey();
-        if (KEY_POWER_INSTANTLY_LOCKS.equals(key)) {
-            mLockPatternUtils.setPowerButtonInstantlyLocks((Boolean) value, MY_USER_ID);
-        } else if (KEY_LOCK_AFTER_TIMEOUT.equals(key)) {
-            int timeout = Integer.parseInt((String) value);
-            try {
-                Settings.Secure.putInt(getContentResolver(),
-                        Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT, timeout);
-            } catch (NumberFormatException e) {
-                Log.e(TAG, "could not persist lockAfter timeout setting", e);
-            }
-            setupLockAfterPreference();
-            updateLockAfterPreferenceSummary();
-        } else if (KEY_VISIBLE_PATTERN.equals(key)) {
-            mLockPatternUtils.setVisiblePatternEnabled((Boolean) value, MY_USER_ID);
-        }
-        return true;
-    }
-}

src/com/android/settings/security/screenlock/LockAfterTimeoutPreferenceController.java

@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2017 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.security.screenlock;
+
+import static android.provider.Settings.System.SCREEN_OFF_TIMEOUT;
+
+import android.app.admin.DevicePolicyManager;
+import android.content.Context;
+import android.os.UserHandle;
+import android.provider.Settings;
+import android.support.v7.preference.Preference;
+import android.text.TextUtils;
+import android.util.Log;
+
+import com.android.internal.widget.LockPatternUtils;
+import com.android.settings.R;
+import com.android.settings.TimeoutListPreference;
+import com.android.settings.core.PreferenceControllerMixin;
+import com.android.settings.overlay.FeatureFactory;
+import com.android.settings.security.trustagent.TrustAgentManager;
+import com.android.settingslib.RestrictedLockUtils;
+import com.android.settingslib.core.AbstractPreferenceController;
+
+public class LockAfterTimeoutPreferenceController extends AbstractPreferenceController
+        implements PreferenceControllerMixin, Preference.OnPreferenceChangeListener {
+
+    private static final String KEY_LOCK_AFTER_TIMEOUT = "lock_after_timeout";
+
+    private final int mUserId;
+    private final LockPatternUtils mLockPatternUtils;
+    private final TrustAgentManager mTrustAgentManager;
+    private final DevicePolicyManager mDPM;
+
+    public LockAfterTimeoutPreferenceController(Context context, int userId,
+            LockPatternUtils lockPatternUtils) {
+        super(context);
+        mUserId = userId;
+        mLockPatternUtils = lockPatternUtils;
+        mDPM = context.getSystemService(DevicePolicyManager.class);
+        mTrustAgentManager = FeatureFactory.getFactory(context)
+                .getSecurityFeatureProvider().getTrustAgentManager();
+    }
+
+    @Override
+    public boolean isAvailable() {
+        if (!mLockPatternUtils.isSecure(mUserId)) {
+            return false;
+        }
+        switch (mLockPatternUtils.getKeyguardStoredPasswordQuality(mUserId)) {
+            case DevicePolicyManager.PASSWORD_QUALITY_SOMETHING:
+            case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC:
+            case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC_COMPLEX:
+            case DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC:
+            case DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC:
+            case DevicePolicyManager.PASSWORD_QUALITY_COMPLEX:
+            case DevicePolicyManager.PASSWORD_QUALITY_MANAGED:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public String getPreferenceKey() {
+        return KEY_LOCK_AFTER_TIMEOUT;
+    }
+
+    @Override
+    public void updateState(Preference preference) {
+        setupLockAfterPreference((TimeoutListPreference) preference);
+        updateLockAfterPreferenceSummary((TimeoutListPreference) preference);
+    }
+
+    @Override
+    public boolean onPreferenceChange(Preference preference, Object newValue) {
+        try {
+            final int timeout = Integer.parseInt((String) newValue);
+            Settings.Secure.putInt(mContext.getContentResolver(),
+                    Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT, timeout);
+            updateState(preference);
+        } catch (NumberFormatException e) {
+            Log.e(TAG, "could not persist lockAfter timeout setting", e);
+        }
+        return true;
+    }
+
+    private void setupLockAfterPreference(TimeoutListPreference preference) {
+        // Compatible with pre-Froyo
+        long currentTimeout = Settings.Secure.getLong(mContext.getContentResolver(),
+                Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT, 5000);
+        preference.setValue(String.valueOf(currentTimeout));
+        if (mDPM != null) {
+            final RestrictedLockUtils.EnforcedAdmin admin =
+                    RestrictedLockUtils.checkIfMaximumTimeToLockIsSet(mContext);
+            final long adminTimeout = mDPM
+                    .getMaximumTimeToLockForUserAndProfiles(UserHandle.myUserId());
+            final long displayTimeout = Math.max(0,
+                    Settings.System.getInt(mContext.getContentResolver(), SCREEN_OFF_TIMEOUT, 0));
+            // This setting is a slave to display timeout when a device policy is enforced.
+            // As such, maxLockTimeout = adminTimeout - displayTimeout.
+            // If there isn't enough time, shows "immediately" setting.
+            final long maxTimeout = Math.max(0, adminTimeout - displayTimeout);
+            preference.removeUnusableTimeouts(maxTimeout, admin);
+        }
+    }
+
+    private void updateLockAfterPreferenceSummary(TimeoutListPreference preference) {
+        final CharSequence summary;
+        if (preference.isDisabledByAdmin()) {
+            summary = mContext.getText(R.string.disabled_by_policy_title);
+        } else {
+            // Update summary message with current value
+            long currentTimeout = Settings.Secure.getLong(mContext.getContentResolver(),
+                    Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT, 5000);
+            final CharSequence[] entries = preference.getEntries();
+            final CharSequence[] values = preference.getEntryValues();
+            int best = 0;
+            for (int i = 0; i < values.length; i++) {
+                long timeout = Long.valueOf(values[i].toString());
+                if (currentTimeout >= timeout) {
+                    best = i;
+                }
+            }
+
+            final CharSequence trustAgentLabel = mTrustAgentManager
+                    .getActiveTrustAgentLabel(mContext, mLockPatternUtils);
+            if (!TextUtils.isEmpty(trustAgentLabel)) {
+                if (Long.valueOf(values[best].toString()) == 0) {
+                    summary = mContext.getString(R.string.lock_immediately_summary_with_exception,
+                            trustAgentLabel);
+                } else {
+                    summary = mContext.getString(R.string.lock_after_timeout_summary_with_exception,
+                            entries[best], trustAgentLabel);
+                }
+            } else {
+                summary = mContext.getString(R.string.lock_after_timeout_summary, entries[best]);
+            }
+        }
+        preference.setSummary(summary);
+    }
+}

src/com/android/settings/security/screenlock/PatternVisiblePreferenceController.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2017 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.security.screenlock;
+
+import android.app.admin.DevicePolicyManager;
+import android.content.Context;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.TwoStatePreference;
+
+import com.android.internal.widget.LockPatternUtils;
+import com.android.settings.core.PreferenceControllerMixin;
+import com.android.settingslib.core.AbstractPreferenceController;
+
+public class PatternVisiblePreferenceController extends AbstractPreferenceController
+        implements PreferenceControllerMixin, Preference.OnPreferenceChangeListener {
+
+    private static final String PREF_KEY = "visiblepattern";
+
+    private final int mUserId;
+    private final LockPatternUtils mLockPatternUtils;
+
+    public PatternVisiblePreferenceController(Context context, int userId,
+            LockPatternUtils lockPatternUtils) {
+        super(context);
+        mUserId = userId;
+        mLockPatternUtils = lockPatternUtils;
+    }
+
+    @Override
+    public boolean isAvailable() {
+        return isPatternLock();
+    }
+
+    @Override
+    public String getPreferenceKey() {
+        return PREF_KEY;
+    }
+
+    @Override
+    public void updateState(Preference preference) {
+        ((TwoStatePreference) preference).setChecked(
+                mLockPatternUtils.isVisiblePatternEnabled(mUserId));
+    }
+
+    private boolean isPatternLock() {
+        return mLockPatternUtils.isSecure(mUserId)
+                && mLockPatternUtils.getKeyguardStoredPasswordQuality(mUserId)
+                == DevicePolicyManager.PASSWORD_QUALITY_SOMETHING;
+    }
+
+    @Override
+    public boolean onPreferenceChange(Preference preference, Object newValue) {
+        mLockPatternUtils.setVisiblePatternEnabled((Boolean) newValue, mUserId);
+        return true;
+    }
+}

src/com/android/settings/security/screenlock/PowerButtonInstantLockPreferenceController.java

@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2017 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.security.screenlock;
+
+import android.app.admin.DevicePolicyManager;
+import android.content.Context;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.TwoStatePreference;
+import android.text.TextUtils;
+
+import com.android.internal.widget.LockPatternUtils;
+import com.android.settings.R;
+import com.android.settings.core.PreferenceControllerMixin;
+import com.android.settings.overlay.FeatureFactory;
+import com.android.settings.security.trustagent.TrustAgentManager;
+import com.android.settingslib.core.AbstractPreferenceController;
+
+public class PowerButtonInstantLockPreferenceController extends AbstractPreferenceController
+        implements PreferenceControllerMixin, Preference.OnPreferenceChangeListener {
+
+    private static final String KEY_POWER_INSTANTLY_LOCKS = "power_button_instantly_locks";
+
+    private final int mUserId;
+    private final LockPatternUtils mLockPatternUtils;
+    private final TrustAgentManager mTrustAgentManager;
+
+    public PowerButtonInstantLockPreferenceController(Context context, int userId,
+            LockPatternUtils lockPatternUtils) {
+        super(context);
+        mUserId = userId;
+        mLockPatternUtils = lockPatternUtils;
+        mTrustAgentManager = FeatureFactory.getFactory(context)
+                .getSecurityFeatureProvider().getTrustAgentManager();
+    }
+
+    @Override
+    public boolean isAvailable() {
+        if (!mLockPatternUtils.isSecure(mUserId)) {
+            return false;
+        }
+        switch (mLockPatternUtils.getKeyguardStoredPasswordQuality(mUserId)) {
+            case DevicePolicyManager.PASSWORD_QUALITY_SOMETHING:
+            case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC:
+            case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC_COMPLEX:
+            case DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC:
+            case DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC:
+            case DevicePolicyManager.PASSWORD_QUALITY_COMPLEX:
+            case DevicePolicyManager.PASSWORD_QUALITY_MANAGED:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public void updateState(Preference preference) {
+        ((TwoStatePreference) preference).setChecked(
+                mLockPatternUtils.getPowerButtonInstantlyLocks(mUserId));
+        final CharSequence trustAgentLabel = mTrustAgentManager.getActiveTrustAgentLabel(
+                mContext, mLockPatternUtils);
+        if (!TextUtils.isEmpty(trustAgentLabel)) {
+            preference.setSummary(mContext.getString(
+                    R.string.lockpattern_settings_power_button_instantly_locks_summary,
+                    trustAgentLabel));
+        } else {
+            preference.setSummary(R.string.summary_placeholder);
+        }
+    }
+
+    @Override
+    public String getPreferenceKey() {
+        return KEY_POWER_INSTANTLY_LOCKS;
+    }
+
+    @Override
+    public boolean onPreferenceChange(Preference preference, Object newValue) {
+        mLockPatternUtils.setPowerButtonInstantlyLocks((Boolean) newValue, mUserId);
+        return true;
+    }
+}

src/com/android/settings/security/screenlock/ScreenLockSettings.java

@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2017 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.security.screenlock;
+
+import android.app.Fragment;
+import android.content.Context;
+import android.os.UserHandle;
+import android.provider.SearchIndexableResource;
+
+import com.android.internal.logging.nano.MetricsProto;
+import com.android.internal.widget.LockPatternUtils;
+import com.android.settings.R;
+import com.android.settings.dashboard.DashboardFragment;
+import com.android.settings.search.BaseSearchIndexProvider;
+import com.android.settings.search.Indexable;
+import com.android.settings.security.OwnerInfoPreferenceController;
+import com.android.settingslib.core.AbstractPreferenceController;
+import com.android.settingslib.core.lifecycle.Lifecycle;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ScreenLockSettings extends DashboardFragment
+        implements OwnerInfoPreferenceController.OwnerInfoCallback {
+
+    private static final String TAG = "ScreenLockSettings";
+
+    private static final int MY_USER_ID = UserHandle.myUserId();
+    private LockPatternUtils mLockPatternUtils;
+
+    @Override
+    public int getMetricsCategory() {
+        return MetricsProto.MetricsEvent.SECURITY;
+    }
+
+    @Override
+    protected int getPreferenceScreenResId() {
+        return R.xml.screen_lock_settings;
+    }
+
+    @Override
+    protected String getLogTag() {
+        return TAG;
+    }
+
+    @Override
+    protected List<AbstractPreferenceController> getPreferenceControllers(Context context) {
+        mLockPatternUtils = new LockPatternUtils(context);
+        return buildPreferenceControllers(context, this /* parent */, getLifecycle(),
+                mLockPatternUtils);
+    }
+
+    @Override
+    public void onOwnerInfoUpdated() {
+        getPreferenceController(OwnerInfoPreferenceController.class).updateSummary();
+    }
+
+    private static List<AbstractPreferenceController> buildPreferenceControllers(Context context,
+            Fragment parent, Lifecycle lifecycle, LockPatternUtils lockPatternUtils) {
+        final List<AbstractPreferenceController> controllers = new ArrayList<>();
+        controllers.add(new PatternVisiblePreferenceController(
+                context, MY_USER_ID, lockPatternUtils));
+        controllers.add(new PowerButtonInstantLockPreferenceController(
+                context, MY_USER_ID, lockPatternUtils));
+        controllers.add(new LockAfterTimeoutPreferenceController(
+                context, MY_USER_ID, lockPatternUtils));
+        controllers.add(new OwnerInfoPreferenceController(context, parent, lifecycle));
+        return controllers;
+    }
+
+
+    public static final Indexable.SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
+            new BaseSearchIndexProvider() {
+                @Override
+                public List<SearchIndexableResource> getXmlResourcesToIndex(Context context,
+                        boolean enabled) {
+                    final ArrayList<SearchIndexableResource> result = new ArrayList<>();
+
+                    final SearchIndexableResource sir = new SearchIndexableResource(context);
+                    sir.xmlResId = R.xml.screen_lock_settings;
+                    result.add(sir);
+                    return result;
+                }
+
+                @Override
+                public List<AbstractPreferenceController> getPreferenceControllers(
+                        Context context) {
+                    return buildPreferenceControllers(context, null /* parent */,
+                            null /* lifecycle */, new LockPatternUtils(context));
+                }
+            };
+}