PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Convert SecuritySubSetting into DashboardFragment

Browse Source 
Bug: 32953042
Test: robotests
Change-Id: Iecdb0a42695644ff8aa095bcd49b5ccb16aa46d4
This commit is contained in:
Fan Zhang
2017-11-03 15:43:53 -07:00
parent 5f6c80a288
commit a681094e8a
23 changed files with 899 additions and 422 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
res/xml/security_settings_pattern_sub.xml → res/xml/screen_lock_settings.xml
View File

@@ -1,29 +1,31 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
~ 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
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.
-->
<PreferenceScreen
xmlns:android="http://schemas.android.com/apk/res/android"
android:key="security_settings_pattern_sub_screen"
android:title="@string/settings_label">
android:key="security_settings_password_sub_screen"
android:title="@string/security_settings_title">
<!-- available in pattern -->
<SwitchPreference
android:key="visiblepattern"
android:title="@string/lockpattern_settings_enable_visible_pattern_title" />
<!-- available in pin/pattern/password -->
<com.android.settings.TimeoutListPreference
android:key="lock_after_timeout"
android:title="@string/lock_after_timeout"
@@ -31,10 +33,12 @@
android:entries="@array/lock_after_timeout_entries"
android:entryValues="@array/lock_after_timeout_values" />
<!-- available in pin/pattern/password -->
<SwitchPreference
android:key="power_button_instantly_locks"
android:title="@string/lockpattern_settings_enable_power_button_instantly_locks" />
<!-- available in pin/pattern/password/slide -->
<com.android.settingslib.RestrictedPreference
android:key="owner_info_settings"
android:title="@string/owner_info_settings_title" />

38
res/xml/security_settings_password_sub.xml
View File

@@ -1,38 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
~ 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
-->
<PreferenceScreen
xmlns:android="http://schemas.android.com/apk/res/android"
android:key="security_settings_password_sub_screen"
android:title="@string/settings_label">
<com.android.settings.TimeoutListPreference
android:key="lock_after_timeout"
android:title="@string/lock_after_timeout"
android:summary="@string/summary_placeholder"
android:entries="@array/lock_after_timeout_entries"
android:entryValues="@array/lock_after_timeout_values" />
<SwitchPreference
android:key="power_button_instantly_locks"
android:title="@string/lockpattern_settings_enable_power_button_instantly_locks" />
<com.android.settingslib.RestrictedPreference
android:key="owner_info_settings"
android:title="@string/owner_info_settings_title" />
</PreferenceScreen>

38
res/xml/security_settings_pin_sub.xml
View File

@@ -1,38 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
~ 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
-->
<PreferenceScreen
xmlns:android="http://schemas.android.com/apk/res/android"
android:key="security_settings_pin_sub_screen"
android:title="@string/settings_label">
<com.android.settings.TimeoutListPreference
android:key="lock_after_timeout"
android:title="@string/lock_after_timeout"
android:summary="@string/summary_placeholder"
android:entries="@array/lock_after_timeout_entries"
android:entryValues="@array/lock_after_timeout_values" />
<SwitchPreference
android:key="power_button_instantly_locks"
android:title="@string/lockpattern_settings_enable_power_button_instantly_locks" />
<com.android.settingslib.RestrictedPreference
android:key="owner_info_settings"
android:title="@string/owner_info_settings_title" />
</PreferenceScreen>

28
res/xml/security_settings_slide_sub.xml
View File

@@ -1,28 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
~ 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
-->
<PreferenceScreen
xmlns:android="http://schemas.android.com/apk/res/android"
android:key="security_settings_slide_sub_screen"
android:title="@string/settings_label">
<com.android.settingslib.RestrictedPreference
android:key="owner_info_settings"
android:title="@string/owner_info_settings_title"
android:summary="@string/owner_info_settings_summary" />
</PreferenceScreen>

9
src/com/android/settings/password/ManagedLockPasswordProvider.java
View File

@@ -65,15 +65,6 @@ public class ManagedLockPasswordProvider {
: 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}.
*/
public 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.

2
src/com/android/settings/search/SearchIndexableResources.java
View File

@@ -76,6 +76,7 @@ import com.android.settings.print.PrintSettingsFragment;
import com.android.settings.security.EncryptionAndCredential;
import com.android.settings.security.LockscreenDashboardFragment;
import com.android.settings.security.SecuritySettings;
import com.android.settings.security.screenlock.ScreenLockSettings;
import com.android.settings.sim.SimSettings;
import com.android.settings.support.SupportDashboardActivity;
import com.android.settings.system.ResetDashboardFragment;
@@ -138,6 +139,7 @@ public final class SearchIndexableResources {
addIndex(LocationSettings.class);
addIndex(ScanningSettings.class);
addIndex(SecuritySettings.class);
addIndex(ScreenLockSettings.class);
addIndex(EncryptionAndCredential.class);
addIndex(ScreenPinningSettings.class);
addIndex(UserAndAccountDashboardFragment.class);

5
src/com/android/settings/security/OwnerInfoPreferenceController.java
View File

@@ -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 ) {

11
src/com/android/settings/security/SecuritySettings.java
View File

@@ -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));

252
src/com/android/settings/security/SecuritySubSettings.java
View File

@@ -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;
}
}

155
src/com/android/settings/security/screenlock/LockAfterTimeoutPreferenceController.java Normal file
View File

@@ -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);
}
}

70
src/com/android/settings/security/screenlock/PatternVisiblePreferenceController.java Normal file
View File

@@ -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;
}
}

94
src/com/android/settings/security/screenlock/PowerButtonInstantLockPreferenceController.java Normal file
View File

@@ -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;
}
}

106
src/com/android/settings/security/screenlock/ScreenLockSettings.java Normal file
View File

@@ -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));
}
};
}

3
src/com/android/settings/OwnerInfoSettings.java → src/com/android/settings/users/OwnerInfoSettings.java
View File

@@ -14,7 +14,7 @@
* limitations under the License.
*/
package com.android.settings;
package com.android.settings.users;
import android.app.AlertDialog;
import android.app.Dialog;
@@ -30,6 +30,7 @@ import android.widget.EditText;
import com.android.internal.logging.nano.MetricsProto;
import com.android.internal.widget.LockPatternUtils;
import com.android.settings.R;
import com.android.settings.core.instrumentation.InstrumentedDialogFragment;
import com.android.settings.security.OwnerInfoPreferenceController.OwnerInfoCallback;

1
src/com/android/settings/users/UserSettings.java
View File

@@ -54,7 +54,6 @@ import android.widget.SimpleAdapter;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.internal.widget.LockPatternUtils;
import com.android.settings.OwnerInfoSettings;
import com.android.settings.R;
import com.android.settings.SettingsActivity;
import com.android.settings.SettingsPreferenceFragment;

1
tests/robotests/assets/grandfather_not_implementing_indexable
View File

@@ -71,7 +71,6 @@ com.android.settings.applications.ExternalSourcesDetails
com.android.settings.applications.PictureInPictureSettings
com.android.settings.applications.PictureInPictureDetails
com.android.settings.ApnSettings
com.android.settings.security.SecuritySubSettings
com.android.settings.PrivacySettings
com.android.settings.WifiCallingSettings
com.android.settings.WifiCallingSettingsForSub

10
tests/robotests/src/com/android/settings/security/ConfigureKeyGuardDialogTest.java
View File

@@ -17,10 +17,14 @@
package com.android.settings.security;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import android.content.DialogInterface;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.ShadowEventLogWriter;
import org.junit.Test;
@@ -29,10 +33,6 @@ import org.robolectric.Robolectric;
import org.robolectric.android.controller.FragmentController;
import org.robolectric.annotation.Config;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(
manifest = TestConfig.MANIFEST_PATH,

29
tests/robotests/src/com/android/settings/security/OwnerInfoPreferenceControllerTest.java
View File

@@ -15,16 +15,27 @@
*/
package com.android.settings.security;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Answers.RETURNS_DEEP_STUBS;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.content.Context;
import android.support.v7.preference.PreferenceScreen;
import android.support.v14.preference.PreferenceFragment;
import android.support.v7.preference.PreferenceScreen;
import com.android.internal.widget.LockPatternUtils;
import com.android.settings.OwnerInfoSettings;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.users.OwnerInfoSettings;
import com.android.settingslib.RestrictedLockUtils.EnforcedAdmin;
import com.android.settingslib.RestrictedPreference;
@@ -37,18 +48,6 @@ import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowApplication;
import org.robolectric.util.ReflectionHelpers;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Answers.RETURNS_DEEP_STUBS;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class OwnerInfoPreferenceControllerTest {

104
tests/robotests/src/com/android/settings/security/screenlock/LockAfterTimeoutPreferenceControllerTest.java Normal file
View File

@@ -0,0 +1,104 @@
/*
* 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 com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.when;
import android.app.admin.DevicePolicyManager;
import android.content.Context;
import android.support.v14.preference.SwitchPreference;
import com.android.internal.widget.LockPatternUtils;
import com.android.settings.TestConfig;
import com.android.settings.security.trustagent.TrustAgentManager;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION_O)
public class LockAfterTimeoutPreferenceControllerTest {
private static final int TEST_USER_ID = 0;
@Mock
private LockPatternUtils mLockPatternUtils;
@Mock
private TrustAgentManager mTrustAgentManager;
private Context mContext;
private LockAfterTimeoutPreferenceController mController;
private SwitchPreference mPreference;
private FakeFeatureFactory mFeatureFactory;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = RuntimeEnvironment.application;
mFeatureFactory = FakeFeatureFactory.setupForTest();
when(mFeatureFactory.securityFeatureProvider.getTrustAgentManager())
.thenReturn(mTrustAgentManager);
mPreference = new SwitchPreference(mContext);
mController = new LockAfterTimeoutPreferenceController(
mContext, TEST_USER_ID, mLockPatternUtils);
}
@Test
public void isAvailable_lockSetToPattern_shouldReturnTrue() {
when(mLockPatternUtils.isSecure(TEST_USER_ID)).thenReturn(true);
when(mLockPatternUtils.getKeyguardStoredPasswordQuality(TEST_USER_ID))
.thenReturn(DevicePolicyManager.PASSWORD_QUALITY_SOMETHING);
assertThat(mController.isAvailable()).isTrue();
}
@Test
public void isAvailable_lockSetToPin_shouldReturnTrue() {
when(mLockPatternUtils.isSecure(TEST_USER_ID)).thenReturn(true);
when(mLockPatternUtils.getKeyguardStoredPasswordQuality(TEST_USER_ID))
.thenReturn(DevicePolicyManager.PASSWORD_QUALITY_NUMERIC);
assertThat(mController.isAvailable()).isTrue();
}
@Test
public void isAvailable_lockSetToPassword_shouldReturnTrue() {
when(mLockPatternUtils.isSecure(TEST_USER_ID)).thenReturn(true);
when(mLockPatternUtils.getKeyguardStoredPasswordQuality(TEST_USER_ID))
.thenReturn(DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC);
assertThat(mController.isAvailable()).isTrue();
}
@Test
public void isAvailable_lockSetToNone_shouldReturnFalse() {
when(mLockPatternUtils.isSecure(TEST_USER_ID)).thenReturn(false);
assertThat(mController.isAvailable()).isFalse();
}
}

102
tests/robotests/src/com/android/settings/security/screenlock/PatternVisiblePreferenceControllerTest.java Normal file
View File

@@ -0,0 +1,102 @@
/*
* 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 com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.app.admin.DevicePolicyManager;
import android.content.Context;
import android.support.v14.preference.SwitchPreference;
import com.android.internal.widget.LockPatternUtils;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION_O)
public class PatternVisiblePreferenceControllerTest {
private static final int TEST_USER_ID = 0;
@Mock
private LockPatternUtils mLockPatternUtils;
private Context mContext;
private PatternVisiblePreferenceController mController;
private SwitchPreference mPreference;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = RuntimeEnvironment.application;
mController = new PatternVisiblePreferenceController(
mContext, TEST_USER_ID, mLockPatternUtils);
mPreference = new SwitchPreference(mContext);
}
@Test
public void isAvailable_lockSetToPattern_shouldReturnTrue() {
when(mLockPatternUtils.isSecure(TEST_USER_ID)).thenReturn(true);
when(mLockPatternUtils.getKeyguardStoredPasswordQuality(TEST_USER_ID))
.thenReturn(DevicePolicyManager.PASSWORD_QUALITY_SOMETHING);
assertThat(mController.isAvailable()).isTrue();
}
@Test
public void isAvailable_lockSetToPin_shouldReturnFalse() {
when(mLockPatternUtils.isSecure(TEST_USER_ID)).thenReturn(true);
when(mLockPatternUtils.getKeyguardStoredPasswordQuality(TEST_USER_ID))
.thenReturn(DevicePolicyManager.PASSWORD_QUALITY_NUMERIC);
assertThat(mController.isAvailable()).isFalse();
}
@Test
public void isAvailable_lockSetToNone_shouldReturnFalse() {
when(mLockPatternUtils.isSecure(TEST_USER_ID)).thenReturn(false);
assertThat(mController.isAvailable()).isFalse();
}
@Test
public void updateState_shouldSetPref() {
when(mLockPatternUtils.isVisiblePatternEnabled(TEST_USER_ID)).thenReturn(true);
mController.updateState(mPreference);
assertThat(mPreference.isChecked()).isTrue();
when(mLockPatternUtils.isVisiblePatternEnabled(TEST_USER_ID)).thenReturn(false);
mController.updateState(mPreference);
assertThat(mPreference.isChecked()).isFalse();
}
@Test
public void onPreferenceChange_shouldUpdateLockPatternUtils() {
mController.onPreferenceChange(mPreference, true /* newValue */);
verify(mLockPatternUtils).setVisiblePatternEnabled(true, TEST_USER_ID);
}
}

133
tests/robotests/src/com/android/settings/security/screenlock/PowerButtonInstantLockPreferenceControllerTest.java Normal file
View File

@@ -0,0 +1,133 @@
/*
* 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 com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.app.admin.DevicePolicyManager;
import android.content.Context;
import android.support.v14.preference.SwitchPreference;
import com.android.internal.widget.LockPatternUtils;
import com.android.settings.R;
import com.android.settings.TestConfig;
import com.android.settings.security.trustagent.TrustAgentManager;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION_O)
public class PowerButtonInstantLockPreferenceControllerTest {
private static final int TEST_USER_ID = 0;
@Mock
private LockPatternUtils mLockPatternUtils;
@Mock
private TrustAgentManager mTrustAgentManager;
private Context mContext;
private PowerButtonInstantLockPreferenceController mController;
private SwitchPreference mPreference;
private FakeFeatureFactory mFeatureFactory;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = RuntimeEnvironment.application;
mFeatureFactory = FakeFeatureFactory.setupForTest();
when(mFeatureFactory.securityFeatureProvider.getTrustAgentManager())
.thenReturn(mTrustAgentManager);
mPreference = new SwitchPreference(mContext);
mController = new PowerButtonInstantLockPreferenceController(
mContext, TEST_USER_ID, mLockPatternUtils);
}
@Test
public void isAvailable_lockSetToPattern_shouldReturnTrue() {
when(mLockPatternUtils.isSecure(TEST_USER_ID)).thenReturn(true);
when(mLockPatternUtils.getKeyguardStoredPasswordQuality(TEST_USER_ID))
.thenReturn(DevicePolicyManager.PASSWORD_QUALITY_SOMETHING);
assertThat(mController.isAvailable()).isTrue();
}
@Test
public void isAvailable_lockSetToPin_shouldReturnTrue() {
when(mLockPatternUtils.isSecure(TEST_USER_ID)).thenReturn(true);
when(mLockPatternUtils.getKeyguardStoredPasswordQuality(TEST_USER_ID))
.thenReturn(DevicePolicyManager.PASSWORD_QUALITY_NUMERIC);
assertThat(mController.isAvailable()).isTrue();
}
@Test
public void isAvailable_lockSetToPassword_shouldReturnTrue() {
when(mLockPatternUtils.isSecure(TEST_USER_ID)).thenReturn(true);
when(mLockPatternUtils.getKeyguardStoredPasswordQuality(TEST_USER_ID))
.thenReturn(DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC);
assertThat(mController.isAvailable()).isTrue();
}
@Test
public void isAvailable_lockSetToNone_shouldReturnFalse() {
when(mLockPatternUtils.isSecure(TEST_USER_ID)).thenReturn(false);
assertThat(mController.isAvailable()).isFalse();
}
@Test
public void updateState_shouldSetPref() {
final String fakeTrustAgent = "trust_agent";
when(mTrustAgentManager.getActiveTrustAgentLabel(mContext, mLockPatternUtils))
.thenReturn(fakeTrustAgent);
when(mLockPatternUtils.getPowerButtonInstantlyLocks(TEST_USER_ID)).thenReturn(true);
mController.updateState(mPreference);
assertThat(mPreference.isChecked()).isTrue();
assertThat(mPreference.getSummary()).isEqualTo(mContext.getString(
R.string.lockpattern_settings_power_button_instantly_locks_summary,
fakeTrustAgent));
when(mTrustAgentManager.getActiveTrustAgentLabel(mContext, mLockPatternUtils))
.thenReturn(null);
when(mLockPatternUtils.getPowerButtonInstantlyLocks(TEST_USER_ID)).thenReturn(false);
mController.updateState(mPreference);
assertThat(mPreference.isChecked()).isFalse();
assertThat(mPreference.getSummary()).isEqualTo(mContext.getString(
R.string.summary_placeholder));
}
@Test
public void onPreferenceChange_shouldUpdateLockPatternUtils() {
mController.onPreferenceChange(mPreference, true /* newValue */);
verify(mLockPatternUtils).setPowerButtonInstantlyLocks(true, TEST_USER_ID);
}
}

67
tests/robotests/src/com/android/settings/security/screenlock/ScreenLockSettingsTest.java Normal file
View File

@@ -0,0 +1,67 @@
/*
* 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 com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import com.android.internal.logging.nano.MetricsProto;
import com.android.settings.R;
import com.android.settings.TestConfig;
import com.android.settings.security.OwnerInfoPreferenceController;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settingslib.core.AbstractPreferenceController;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
import org.robolectric.util.ReflectionHelpers;
import java.util.Map;
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION_O)
public class ScreenLockSettingsTest {
private ScreenLockSettings mSettings;
@Before
public void setUp() {
mSettings = new ScreenLockSettings();
}
@Test
public void verifyConstants() {
assertThat(mSettings.getMetricsCategory()).isEqualTo(MetricsProto.MetricsEvent.SECURITY);
assertThat(mSettings.getPreferenceScreenResId()).isEqualTo(R.xml.screen_lock_settings);
}
@Test
public void onOwnerInfoUpdated_shouldUpdateOwnerInfoController() {
final Map<Class, AbstractPreferenceController> preferenceControllers =
ReflectionHelpers.getField(mSettings, "mPreferenceControllers");
final OwnerInfoPreferenceController controller = mock(OwnerInfoPreferenceController.class);
preferenceControllers.put(OwnerInfoPreferenceController.class, controller);
mSettings.onOwnerInfoUpdated();
verify(controller).updateSummary();
}
}

21
tests/robotests/src/com/android/settings/testutils/FakeFeatureFactory.java
View File

@@ -15,6 +15,10 @@
*/
package com.android.settings.testutils;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import android.content.Context;
import com.android.settings.applications.ApplicationFeatureProvider;
@@ -30,14 +34,12 @@ import com.android.settings.gestures.AssistGestureFeatureProvider;
import com.android.settings.localepicker.LocaleFeatureProvider;
import com.android.settings.overlay.FeatureFactory;
import com.android.settings.overlay.SupportFeatureProvider;
import com.android.settings.security.SecurityFeatureProvider;
import com.android.settings.search.SearchFeatureProvider;
import com.android.settings.overlay.SurveyFeatureProvider;
import com.android.settings.search.SearchFeatureProvider;
import com.android.settings.security.SecurityFeatureProvider;
import com.android.settings.users.UserFeatureProvider;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import org.mockito.Answers;
/**
* Test util to provide fake FeatureFactory. To use this factory, call {@code setupForTest} in
@@ -67,6 +69,7 @@ public class FakeFeatureFactory extends FeatureFactory {
*
* @param context The context must be a deep mock.
*/
@Deprecated
public static FakeFeatureFactory setupForTest(Context context) {
sFactory = null;
when(context.getString(com.android.settings.R.string.config_featureFactory))
@@ -80,6 +83,14 @@ public class FakeFeatureFactory extends FeatureFactory {
return (FakeFeatureFactory) FakeFeatureFactory.getFactory(context);
}
/**
* Call this in {@code @Before} method of the test class to use fake factory.
*/
public static FakeFeatureFactory setupForTest() {
final Context context = mock(Context.class, Answers.RETURNS_DEEP_STUBS);
return setupForTest(context);
}
/**
* Used by reflection. Do not call directly.
*/