The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2007 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | package com.android.settings; |
| 18 | |
| 19 | |
Danielle Millett | 487b16f | 2011-11-02 11:12:21 -0400 | [diff] [blame] | 20 | import android.app.Activity; |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 21 | import android.app.AlertDialog; |
Dianne Hackborn | 4037c7f | 2010-02-26 17:26:55 -0800 | [diff] [blame] | 22 | import android.app.admin.DevicePolicyManager; |
Ido Ofir | 524a63b | 2014-06-12 14:18:23 -0700 | [diff] [blame] | 23 | import android.content.ComponentName; |
Dianne Hackborn | abc3dc6 | 2010-01-20 13:40:19 -0800 | [diff] [blame] | 24 | import android.content.Context; |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 25 | import android.content.DialogInterface; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 26 | import android.content.Intent; |
rich cannings | bfbdcef | 2012-09-09 12:48:50 -0700 | [diff] [blame] | 27 | import android.content.pm.PackageManager; |
| 28 | import android.content.pm.ResolveInfo; |
Fabrice Di Meglio | d1d2f02 | 2014-04-11 16:09:11 -0700 | [diff] [blame] | 29 | import android.content.res.Resources; |
Jason Monk | 3bcd76c | 2015-04-21 11:20:20 -0400 | [diff] [blame] | 30 | import android.hardware.fingerprint.Fingerprint; |
| 31 | import android.hardware.fingerprint.FingerprintManager; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 32 | import android.os.Bundle; |
Junda Liu | 80753bc | 2015-06-17 10:15:34 -0700 | [diff] [blame] | 33 | import android.os.PersistableBundle; |
Dianne Hackborn | bb06a42 | 2012-08-16 11:01:57 -0700 | [diff] [blame] | 34 | import android.os.UserHandle; |
Jim Miller | 783ea85 | 2012-11-01 19:39:21 -0700 | [diff] [blame] | 35 | import android.os.UserManager; |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 36 | import android.preference.ListPreference; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 37 | import android.preference.Preference; |
Mathew Inwood | f8b2579 | 2010-10-21 18:43:35 +0100 | [diff] [blame] | 38 | import android.preference.Preference.OnPreferenceChangeListener; |
Jason Monk | 3bcd76c | 2015-04-21 11:20:20 -0400 | [diff] [blame] | 39 | import android.preference.Preference.OnPreferenceClickListener; |
Mathew Inwood | f8b2579 | 2010-10-21 18:43:35 +0100 | [diff] [blame] | 40 | import android.preference.PreferenceGroup; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 41 | import android.preference.PreferenceScreen; |
Jason Monk | 3bcd76c | 2015-04-21 11:20:20 -0400 | [diff] [blame] | 42 | import android.preference.SwitchPreference; |
Fabrice Di Meglio | d1d2f02 | 2014-04-11 16:09:11 -0700 | [diff] [blame] | 43 | import android.provider.SearchIndexableResource; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 44 | import android.provider.Settings; |
Chia-chi Yeh | 9cec698 | 2009-09-22 23:59:01 +0800 | [diff] [blame] | 45 | import android.security.KeyStore; |
Ido Ofir | 6f48244 | 2014-05-09 14:47:15 -0700 | [diff] [blame] | 46 | import android.service.trust.TrustAgentService; |
Junda Liu | 80753bc | 2015-06-17 10:15:34 -0700 | [diff] [blame] | 47 | import android.telephony.CarrierConfigManager; |
Wink Saville | ca75661 | 2014-11-08 10:47:12 -0800 | [diff] [blame] | 48 | import android.telephony.SubscriptionInfo; |
Jason Monk | 3bcd76c | 2015-04-21 11:20:20 -0400 | [diff] [blame] | 49 | import android.telephony.SubscriptionManager; |
| 50 | import android.telephony.TelephonyManager; |
Ido Ofir | 524a63b | 2014-06-12 14:18:23 -0700 | [diff] [blame] | 51 | import android.text.TextUtils; |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 52 | import android.util.Log; |
Amith Yamasani | f06d869 | 2009-06-11 22:32:33 -0700 | [diff] [blame] | 53 | |
Chris Wren | 8a963ba | 2015-03-20 10:29:14 -0400 | [diff] [blame] | 54 | import com.android.internal.logging.MetricsLogger; |
Gilles Debunne | a6a8a14 | 2011-06-09 11:56:17 -0700 | [diff] [blame] | 55 | import com.android.internal.widget.LockPatternUtils; |
Jim Miller | fe76559 | 2014-07-31 15:30:29 -0700 | [diff] [blame] | 56 | import com.android.settings.TrustAgentUtils.TrustAgentComponentInfo; |
Selim Cinek | ec85004 | 2015-06-11 18:59:54 -0700 | [diff] [blame] | 57 | import com.android.settings.fingerprint.FingerprintEnrollIntroduction; |
Jorim Jaggi | 5ad75f0 | 2015-04-22 16:17:23 -0700 | [diff] [blame] | 58 | import com.android.settings.fingerprint.FingerprintSettings; |
Fabrice Di Meglio | d1d2f02 | 2014-04-11 16:09:11 -0700 | [diff] [blame] | 59 | import com.android.settings.search.BaseSearchIndexProvider; |
Jim Miller | fe76559 | 2014-07-31 15:30:29 -0700 | [diff] [blame] | 60 | import com.android.settings.search.Index; |
Fabrice Di Meglio | d1d2f02 | 2014-04-11 16:09:11 -0700 | [diff] [blame] | 61 | import com.android.settings.search.Indexable; |
| 62 | import com.android.settings.search.SearchIndexableRaw; |
Gilles Debunne | a6a8a14 | 2011-06-09 11:56:17 -0700 | [diff] [blame] | 63 | |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 64 | import java.util.ArrayList; |
rich cannings | bfbdcef | 2012-09-09 12:48:50 -0700 | [diff] [blame] | 65 | import java.util.List; |
Mike Lockwood | 5ed2c4a | 2009-06-07 23:07:20 -0400 | [diff] [blame] | 66 | |
Selim Cinek | ec85004 | 2015-06-11 18:59:54 -0700 | [diff] [blame] | 67 | import static android.provider.Settings.System.SCREEN_OFF_TIMEOUT; |
| 68 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 69 | /** |
| 70 | * Gesture lock pattern settings. |
| 71 | */ |
Julia Reynolds | 565653c | 2014-06-12 11:49:12 -0400 | [diff] [blame] | 72 | public class SecuritySettings extends SettingsPreferenceFragment |
Fabrice Di Meglio | d1d2f02 | 2014-04-11 16:09:11 -0700 | [diff] [blame] | 73 | implements OnPreferenceChangeListener, DialogInterface.OnClickListener, Indexable { |
Jim Miller | 9218687 | 2015-03-04 18:07:32 -0800 | [diff] [blame] | 74 | |
| 75 | private static final String TAG = "SecuritySettings"; |
Jim Miller | 250b9be | 2014-09-05 18:48:18 -0700 | [diff] [blame] | 76 | private static final String TRUST_AGENT_CLICK_INTENT = "trust_agent_click_intent"; |
Ido Ofir | 6f48244 | 2014-05-09 14:47:15 -0700 | [diff] [blame] | 77 | private static final Intent TRUST_AGENT_INTENT = |
| 78 | new Intent(TrustAgentService.SERVICE_INTERFACE); |
Jason parks | 6f8fb43 | 2011-01-07 09:02:14 -0600 | [diff] [blame] | 79 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 80 | // Lock Settings |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 81 | private static final String KEY_UNLOCK_SET_OR_CHANGE = "unlock_set_or_change"; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 82 | private static final String KEY_VISIBLE_PATTERN = "visiblepattern"; |
Amith Yamasani | edac9af | 2010-11-17 09:08:21 -0800 | [diff] [blame] | 83 | private static final String KEY_SECURITY_CATEGORY = "security_category"; |
rich cannings | f042114 | 2012-09-25 16:20:36 -0700 | [diff] [blame] | 84 | private static final String KEY_DEVICE_ADMIN_CATEGORY = "device_admin_category"; |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 85 | private static final String KEY_LOCK_AFTER_TIMEOUT = "lock_after_timeout"; |
Amith Yamasani | 8666b9e | 2012-09-27 14:50:13 -0700 | [diff] [blame] | 86 | private static final String KEY_OWNER_INFO_SETTINGS = "owner_info_settings"; |
Jim Miller | fe76559 | 2014-07-31 15:30:29 -0700 | [diff] [blame] | 87 | private static final String KEY_ADVANCED_SECURITY = "advanced_security"; |
| 88 | private static final String KEY_MANAGE_TRUST_AGENTS = "manage_trust_agents"; |
Jim Miller | 9218687 | 2015-03-04 18:07:32 -0800 | [diff] [blame] | 89 | private static final String KEY_FINGERPRINT_SETTINGS = "fingerprint_settings"; |
Jim Miller | ef3e701 | 2013-08-20 19:03:30 -0700 | [diff] [blame] | 90 | |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 91 | private static final int SET_OR_CHANGE_LOCK_METHOD_REQUEST = 123; |
Ido Ofir | 6f48244 | 2014-05-09 14:47:15 -0700 | [diff] [blame] | 92 | private static final int CHANGE_TRUST_AGENT_SETTINGS = 126; |
Hung-ying Tyan | 7031ab0 | 2009-07-02 00:26:46 +0800 | [diff] [blame] | 93 | |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 94 | // Misc Settings |
| 95 | private static final String KEY_SIM_LOCK = "sim_lock"; |
| 96 | private static final String KEY_SHOW_PASSWORD = "show_password"; |
Kenny Root | 028634b | 2013-03-29 11:12:55 -0700 | [diff] [blame] | 97 | private static final String KEY_CREDENTIAL_STORAGE_TYPE = "credential_storage_type"; |
Julia Reynolds | 233ccd0 | 2014-06-23 09:43:09 -0400 | [diff] [blame] | 98 | private static final String KEY_RESET_CREDENTIALS = "credentials_reset"; |
Geoffrey Borggaard | 6e1102d | 2013-08-07 14:57:43 -0400 | [diff] [blame] | 99 | private static final String KEY_CREDENTIALS_INSTALL = "credentials_install"; |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 100 | private static final String KEY_TOGGLE_INSTALL_APPLICATIONS = "toggle_install_applications"; |
Jim Miller | 071742d | 2012-01-06 18:28:09 -0800 | [diff] [blame] | 101 | private static final String KEY_POWER_INSTANTLY_LOCKS = "power_button_instantly_locks"; |
Amith Yamasani | 7fb4f85 | 2012-09-25 22:17:33 -0700 | [diff] [blame] | 102 | private static final String KEY_CREDENTIALS_MANAGER = "credentials_management"; |
rich cannings | bfbdcef | 2012-09-09 12:48:50 -0700 | [diff] [blame] | 103 | private static final String PACKAGE_MIME_TYPE = "application/vnd.android.package-archive"; |
Ido Ofir | 6f48244 | 2014-05-09 14:47:15 -0700 | [diff] [blame] | 104 | private static final String KEY_TRUST_AGENT = "trust_agent"; |
Jason Monk | 27d7ea5 | 2014-07-18 09:55:41 -0400 | [diff] [blame] | 105 | private static final String KEY_SCREEN_PINNING = "screen_pinning_settings"; |
Jim Miller | 47d380f | 2010-01-20 13:37:14 -0800 | [diff] [blame] | 106 | |
Jim Miller | 4a9065e | 2014-08-08 15:25:31 -0700 | [diff] [blame] | 107 | // These switch preferences need special handling since they're not all stored in Settings. |
| 108 | private static final String SWITCH_PREFERENCE_KEYS[] = { KEY_LOCK_AFTER_TIMEOUT, |
Adrian Roos | 6b879f5 | 2015-01-08 16:20:00 +0100 | [diff] [blame] | 109 | KEY_VISIBLE_PATTERN, KEY_POWER_INSTANTLY_LOCKS, KEY_SHOW_PASSWORD, |
| 110 | KEY_TOGGLE_INSTALL_APPLICATIONS }; |
Jim Miller | 4a9065e | 2014-08-08 15:25:31 -0700 | [diff] [blame] | 111 | |
Jim Miller | fe76559 | 2014-07-31 15:30:29 -0700 | [diff] [blame] | 112 | // Only allow one trust agent on the platform. |
| 113 | private static final boolean ONLY_ONE_TRUST_AGENT = true; |
| 114 | |
Adrian Roos | 5437588 | 2015-04-16 17:11:22 -0700 | [diff] [blame] | 115 | private static final int MY_USER_ID = UserHandle.myUserId(); |
| 116 | |
Maggie Benthall | f48206e | 2013-08-20 11:03:05 -0400 | [diff] [blame] | 117 | private DevicePolicyManager mDPM; |
Wink Saville | 0183fb5 | 2014-11-22 10:11:39 -0800 | [diff] [blame] | 118 | private SubscriptionManager mSubscriptionManager; |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 119 | |
Jim Miller | 00d2476 | 2009-12-22 19:04:57 -0800 | [diff] [blame] | 120 | private ChooseLockSettingsHelper mChooseLockSettingsHelper; |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 121 | private LockPatternUtils mLockPatternUtils; |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 122 | private ListPreference mLockAfter; |
Jim Miller | 36972bb | 2010-11-30 19:47:38 -0800 | [diff] [blame] | 123 | |
Jim Miller | 4a9065e | 2014-08-08 15:25:31 -0700 | [diff] [blame] | 124 | private SwitchPreference mVisiblePattern; |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 125 | |
Jim Miller | 4a9065e | 2014-08-08 15:25:31 -0700 | [diff] [blame] | 126 | private SwitchPreference mShowPassword; |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 127 | |
Kenny Root | 028634b | 2013-03-29 11:12:55 -0700 | [diff] [blame] | 128 | private KeyStore mKeyStore; |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 129 | private Preference mResetCredentials; |
Mike Lockwood | 5ed2c4a | 2009-06-07 23:07:20 -0400 | [diff] [blame] | 130 | |
Jim Miller | 4a9065e | 2014-08-08 15:25:31 -0700 | [diff] [blame] | 131 | private SwitchPreference mToggleAppInstallation; |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 132 | private DialogInterface mWarnInstallApps; |
Jim Miller | 4a9065e | 2014-08-08 15:25:31 -0700 | [diff] [blame] | 133 | private SwitchPreference mPowerButtonInstantlyLocks; |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 134 | |
Amith Yamasani | 7fb4f85 | 2012-09-25 22:17:33 -0700 | [diff] [blame] | 135 | private boolean mIsPrimary; |
| 136 | |
Jim Miller | 250b9be | 2014-09-05 18:48:18 -0700 | [diff] [blame] | 137 | private Intent mTrustAgentClickIntent; |
Jason Monk | 3bcd76c | 2015-04-21 11:20:20 -0400 | [diff] [blame] | 138 | private Preference mOwnerInfoPref; |
Ido Ofir | 1682a0d | 2014-06-24 16:26:09 -0700 | [diff] [blame] | 139 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 140 | @Override |
Chris Wren | 8a963ba | 2015-03-20 10:29:14 -0400 | [diff] [blame] | 141 | protected int getMetricsCategory() { |
| 142 | return MetricsLogger.SECURITY; |
| 143 | } |
| 144 | |
| 145 | @Override |
Amith Yamasani | d799347 | 2010-08-18 13:59:28 -0700 | [diff] [blame] | 146 | public void onCreate(Bundle savedInstanceState) { |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 147 | super.onCreate(savedInstanceState); |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 148 | |
Wink Saville | 0183fb5 | 2014-11-22 10:11:39 -0800 | [diff] [blame] | 149 | mSubscriptionManager = SubscriptionManager.from(getActivity()); |
| 150 | |
Amith Yamasani | d799347 | 2010-08-18 13:59:28 -0700 | [diff] [blame] | 151 | mLockPatternUtils = new LockPatternUtils(getActivity()); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 152 | |
Dianne Hackborn | abc3dc6 | 2010-01-20 13:40:19 -0800 | [diff] [blame] | 153 | mDPM = (DevicePolicyManager)getSystemService(Context.DEVICE_POLICY_SERVICE); |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 154 | |
Amith Yamasani | d799347 | 2010-08-18 13:59:28 -0700 | [diff] [blame] | 155 | mChooseLockSettingsHelper = new ChooseLockSettingsHelper(getActivity()); |
Jim Miller | 250b9be | 2014-09-05 18:48:18 -0700 | [diff] [blame] | 156 | |
| 157 | if (savedInstanceState != null |
| 158 | && savedInstanceState.containsKey(TRUST_AGENT_CLICK_INTENT)) { |
| 159 | mTrustAgentClickIntent = savedInstanceState.getParcelable(TRUST_AGENT_CLICK_INTENT); |
| 160 | } |
Amith Yamasani | 02cf71a | 2010-09-21 15:48:52 -0700 | [diff] [blame] | 161 | } |
Mike Lockwood | 5ed2c4a | 2009-06-07 23:07:20 -0400 | [diff] [blame] | 162 | |
Fabrice Di Meglio | d1d2f02 | 2014-04-11 16:09:11 -0700 | [diff] [blame] | 163 | private static int getResIdForLockUnlockScreen(Context context, |
| 164 | LockPatternUtils lockPatternUtils) { |
Jim Miller | 36972bb | 2010-11-30 19:47:38 -0800 | [diff] [blame] | 165 | int resid = 0; |
Adrian Roos | 5437588 | 2015-04-16 17:11:22 -0700 | [diff] [blame] | 166 | if (!lockPatternUtils.isSecure(MY_USER_ID)) { |
| 167 | if (lockPatternUtils.isLockScreenDisabled(MY_USER_ID)) { |
Jim Miller | 36972bb | 2010-11-30 19:47:38 -0800 | [diff] [blame] | 168 | resid = R.xml.security_settings_lockscreen; |
| 169 | } else { |
| 170 | resid = R.xml.security_settings_chooser; |
| 171 | } |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 172 | } else { |
Adrian Roos | 5437588 | 2015-04-16 17:11:22 -0700 | [diff] [blame] | 173 | switch (lockPatternUtils.getKeyguardStoredPasswordQuality(MY_USER_ID)) { |
Jim Miller | af366a3 | 2010-03-25 18:45:22 -0700 | [diff] [blame] | 174 | case DevicePolicyManager.PASSWORD_QUALITY_SOMETHING: |
Jim Miller | 36972bb | 2010-11-30 19:47:38 -0800 | [diff] [blame] | 175 | resid = R.xml.security_settings_pattern; |
Jim Miller | af366a3 | 2010-03-25 18:45:22 -0700 | [diff] [blame] | 176 | break; |
| 177 | case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC: |
Nicolas Prevot | 8fd852e | 2014-01-25 01:02:04 +0000 | [diff] [blame] | 178 | case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC_COMPLEX: |
Jim Miller | 36972bb | 2010-11-30 19:47:38 -0800 | [diff] [blame] | 179 | resid = R.xml.security_settings_pin; |
Jim Miller | af366a3 | 2010-03-25 18:45:22 -0700 | [diff] [blame] | 180 | break; |
| 181 | case DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC: |
| 182 | case DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC: |
Konstantin Lopyrev | 57fbf69 | 2010-05-27 16:01:41 -0700 | [diff] [blame] | 183 | case DevicePolicyManager.PASSWORD_QUALITY_COMPLEX: |
Jim Miller | 36972bb | 2010-11-30 19:47:38 -0800 | [diff] [blame] | 184 | resid = R.xml.security_settings_password; |
Jim Miller | af366a3 | 2010-03-25 18:45:22 -0700 | [diff] [blame] | 185 | break; |
Jim Miller | 00d2476 | 2009-12-22 19:04:57 -0800 | [diff] [blame] | 186 | } |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 187 | } |
Fabrice Di Meglio | d1d2f02 | 2014-04-11 16:09:11 -0700 | [diff] [blame] | 188 | return resid; |
| 189 | } |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 190 | |
Fabrice Di Meglio | d1d2f02 | 2014-04-11 16:09:11 -0700 | [diff] [blame] | 191 | /** |
| 192 | * Important! |
| 193 | * |
Ido Ofir | 6f48244 | 2014-05-09 14:47:15 -0700 | [diff] [blame] | 194 | * Don't forget to update the SecuritySearchIndexProvider if you are doing any change in the |
Fabrice Di Meglio | d1d2f02 | 2014-04-11 16:09:11 -0700 | [diff] [blame] | 195 | * logic or adding/removing preferences here. |
| 196 | */ |
| 197 | private PreferenceScreen createPreferenceHierarchy() { |
| 198 | PreferenceScreen root = getPreferenceScreen(); |
| 199 | if (root != null) { |
| 200 | root.removeAll(); |
| 201 | } |
| 202 | addPreferencesFromResource(R.xml.security_settings); |
| 203 | root = getPreferenceScreen(); |
| 204 | |
| 205 | // Add options for lock/unlock screen |
| 206 | final int resid = getResIdForLockUnlockScreen(getActivity(), mLockPatternUtils); |
| 207 | addPreferencesFromResource(resid); |
Jason parks | 4112199 | 2011-01-25 09:26:55 -0600 | [diff] [blame] | 208 | |
| 209 | // Add options for device encryption |
Adrian Roos | 5437588 | 2015-04-16 17:11:22 -0700 | [diff] [blame] | 210 | mIsPrimary = MY_USER_ID == UserHandle.USER_OWNER; |
Amith Yamasani | 7fb4f85 | 2012-09-25 22:17:33 -0700 | [diff] [blame] | 211 | |
Jason Monk | 3bcd76c | 2015-04-21 11:20:20 -0400 | [diff] [blame] | 212 | mOwnerInfoPref = findPreference(KEY_OWNER_INFO_SETTINGS); |
| 213 | if (mOwnerInfoPref != null) { |
| 214 | mOwnerInfoPref.setOnPreferenceClickListener(new OnPreferenceClickListener() { |
| 215 | @Override |
| 216 | public boolean onPreferenceClick(Preference preference) { |
| 217 | OwnerInfoSettings.show(SecuritySettings.this); |
| 218 | return true; |
Amith Yamasani | b017171 | 2013-04-28 22:13:22 -0700 | [diff] [blame] | 219 | } |
Jason Monk | 3bcd76c | 2015-04-21 11:20:20 -0400 | [diff] [blame] | 220 | }); |
Amith Yamasani | 8666b9e | 2012-09-27 14:50:13 -0700 | [diff] [blame] | 221 | } |
| 222 | |
Amith Yamasani | 7fb4f85 | 2012-09-25 22:17:33 -0700 | [diff] [blame] | 223 | if (mIsPrimary) { |
Jim Miller | 0698a21 | 2014-10-16 19:49:07 -0700 | [diff] [blame] | 224 | if (LockPatternUtils.isDeviceEncryptionEnabled()) { |
Amith Yamasani | b810a0d | 2012-03-25 10:12:26 -0700 | [diff] [blame] | 225 | // The device is currently encrypted. |
| 226 | addPreferencesFromResource(R.xml.security_settings_encrypted); |
Jim Miller | 0698a21 | 2014-10-16 19:49:07 -0700 | [diff] [blame] | 227 | } else { |
Amith Yamasani | b810a0d | 2012-03-25 10:12:26 -0700 | [diff] [blame] | 228 | // This device supports encryption but isn't encrypted. |
| 229 | addPreferencesFromResource(R.xml.security_settings_unencrypted); |
Amith Yamasani | b810a0d | 2012-03-25 10:12:26 -0700 | [diff] [blame] | 230 | } |
Jason parks | 4112199 | 2011-01-25 09:26:55 -0600 | [diff] [blame] | 231 | } |
| 232 | |
Jim Miller | 94d4bd9 | 2015-02-19 21:04:57 -0800 | [diff] [blame] | 233 | // Fingerprint and trust agents |
Ido Ofir | 1682a0d | 2014-06-24 16:26:09 -0700 | [diff] [blame] | 234 | PreferenceGroup securityCategory = (PreferenceGroup) |
| 235 | root.findPreference(KEY_SECURITY_CATEGORY); |
Jim Miller | 9d25005 | 2014-08-21 19:24:47 -0700 | [diff] [blame] | 236 | if (securityCategory != null) { |
Jim Miller | 94d4bd9 | 2015-02-19 21:04:57 -0800 | [diff] [blame] | 237 | maybeAddFingerprintPreference(securityCategory); |
| 238 | addTrustAgentSettings(securityCategory); |
Ido Ofir | 1682a0d | 2014-06-24 16:26:09 -0700 | [diff] [blame] | 239 | } |
| 240 | |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 241 | // lock after preference |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 242 | mLockAfter = (ListPreference) root.findPreference(KEY_LOCK_AFTER_TIMEOUT); |
| 243 | if (mLockAfter != null) { |
| 244 | setupLockAfterPreference(); |
| 245 | updateLockAfterPreferenceSummary(); |
| 246 | } |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 247 | |
| 248 | // visible pattern |
Jim Miller | 4a9065e | 2014-08-08 15:25:31 -0700 | [diff] [blame] | 249 | mVisiblePattern = (SwitchPreference) root.findPreference(KEY_VISIBLE_PATTERN); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 250 | |
Jim Miller | 071742d | 2012-01-06 18:28:09 -0800 | [diff] [blame] | 251 | // lock instantly on power key press |
Jim Miller | 4a9065e | 2014-08-08 15:25:31 -0700 | [diff] [blame] | 252 | mPowerButtonInstantlyLocks = (SwitchPreference) root.findPreference( |
Jim Miller | 071742d | 2012-01-06 18:28:09 -0800 | [diff] [blame] | 253 | KEY_POWER_INSTANTLY_LOCKS); |
Ido Ofir | 1682a0d | 2014-06-24 16:26:09 -0700 | [diff] [blame] | 254 | Preference trustAgentPreference = root.findPreference(KEY_TRUST_AGENT); |
| 255 | if (mPowerButtonInstantlyLocks != null && |
| 256 | trustAgentPreference != null && |
| 257 | trustAgentPreference.getTitle().length() > 0) { |
| 258 | mPowerButtonInstantlyLocks.setSummary(getString( |
| 259 | R.string.lockpattern_settings_power_button_instantly_locks_summary, |
| 260 | trustAgentPreference.getTitle())); |
| 261 | } |
Jim Miller | 071742d | 2012-01-06 18:28:09 -0800 | [diff] [blame] | 262 | |
Amith Yamasani | 7fb4f85 | 2012-09-25 22:17:33 -0700 | [diff] [blame] | 263 | // Append the rest of the settings |
| 264 | addPreferencesFromResource(R.xml.security_settings_misc); |
| 265 | |
| 266 | // Do not display SIM lock for devices without an Icc card |
| 267 | TelephonyManager tm = TelephonyManager.getDefault(); |
Junda Liu | 80753bc | 2015-06-17 10:15:34 -0700 | [diff] [blame] | 268 | CarrierConfigManager cfgMgr = (CarrierConfigManager) |
| 269 | getActivity().getSystemService(Context.CARRIER_CONFIG_SERVICE); |
| 270 | PersistableBundle b = cfgMgr.getConfig(); |
| 271 | if (!mIsPrimary || !isSimIccReady() || |
| 272 | b.getBoolean(CarrierConfigManager.KEY_HIDE_SIM_LOCK_SETTINGS_BOOL)) { |
Amith Yamasani | 7fb4f85 | 2012-09-25 22:17:33 -0700 | [diff] [blame] | 273 | root.removePreference(root.findPreference(KEY_SIM_LOCK)); |
| 274 | } else { |
PauloftheWest | 50e6eca | 2014-10-03 11:07:14 -0700 | [diff] [blame] | 275 | // Disable SIM lock if there is no ready SIM card. |
| 276 | root.findPreference(KEY_SIM_LOCK).setEnabled(isSimReady()); |
Amith Yamasani | 7fb4f85 | 2012-09-25 22:17:33 -0700 | [diff] [blame] | 277 | } |
Jason Monk | b08853a | 2014-08-13 09:43:58 -0400 | [diff] [blame] | 278 | if (Settings.System.getInt(getContentResolver(), |
| 279 | Settings.System.LOCK_TO_APP_ENABLED, 0) != 0) { |
| 280 | root.findPreference(KEY_SCREEN_PINNING).setSummary( |
| 281 | getResources().getString(R.string.switch_on_text)); |
Jason Monk | 27d7ea5 | 2014-07-18 09:55:41 -0400 | [diff] [blame] | 282 | } |
Amith Yamasani | 7fb4f85 | 2012-09-25 22:17:33 -0700 | [diff] [blame] | 283 | |
| 284 | // Show password |
Jim Miller | 4a9065e | 2014-08-08 15:25:31 -0700 | [diff] [blame] | 285 | mShowPassword = (SwitchPreference) root.findPreference(KEY_SHOW_PASSWORD); |
Geoffrey Borggaard | 6e1102d | 2013-08-07 14:57:43 -0400 | [diff] [blame] | 286 | mResetCredentials = root.findPreference(KEY_RESET_CREDENTIALS); |
Amith Yamasani | 7fb4f85 | 2012-09-25 22:17:33 -0700 | [diff] [blame] | 287 | |
Kenny Root | c5550c2 | 2013-04-08 09:56:05 -0700 | [diff] [blame] | 288 | // Credential storage |
Emily Bernier | 11bd33a | 2013-04-11 16:24:56 -0400 | [diff] [blame] | 289 | final UserManager um = (UserManager) getActivity().getSystemService(Context.USER_SERVICE); |
Maggie Benthall | f48206e | 2013-08-20 11:03:05 -0400 | [diff] [blame] | 290 | mKeyStore = KeyStore.getInstance(); // needs to be initialized for onResume() |
Emily Bernier | 11bd33a | 2013-04-11 16:24:56 -0400 | [diff] [blame] | 291 | if (!um.hasUserRestriction(UserManager.DISALLOW_CONFIG_CREDENTIALS)) { |
Emily Bernier | 11bd33a | 2013-04-11 16:24:56 -0400 | [diff] [blame] | 292 | Preference credentialStorageType = root.findPreference(KEY_CREDENTIAL_STORAGE_TYPE); |
Kenny Root | 028634b | 2013-03-29 11:12:55 -0700 | [diff] [blame] | 293 | |
Emily Bernier | 11bd33a | 2013-04-11 16:24:56 -0400 | [diff] [blame] | 294 | final int storageSummaryRes = |
Kenny Root | c5550c2 | 2013-04-08 09:56:05 -0700 | [diff] [blame] | 295 | mKeyStore.isHardwareBacked() ? R.string.credential_storage_type_hardware |
| 296 | : R.string.credential_storage_type_software; |
Emily Bernier | 11bd33a | 2013-04-11 16:24:56 -0400 | [diff] [blame] | 297 | credentialStorageType.setSummary(storageSummaryRes); |
Emily Bernier | 11bd33a | 2013-04-11 16:24:56 -0400 | [diff] [blame] | 298 | } else { |
Julia Reynolds | 233ccd0 | 2014-06-23 09:43:09 -0400 | [diff] [blame] | 299 | PreferenceGroup credentialsManager = (PreferenceGroup) |
| 300 | root.findPreference(KEY_CREDENTIALS_MANAGER); |
| 301 | credentialsManager.removePreference(root.findPreference(KEY_RESET_CREDENTIALS)); |
| 302 | credentialsManager.removePreference(root.findPreference(KEY_CREDENTIALS_INSTALL)); |
| 303 | credentialsManager.removePreference(root.findPreference(KEY_CREDENTIAL_STORAGE_TYPE)); |
Emily Bernier | 11bd33a | 2013-04-11 16:24:56 -0400 | [diff] [blame] | 304 | } |
Amith Yamasani | 7fb4f85 | 2012-09-25 22:17:33 -0700 | [diff] [blame] | 305 | |
Kenny Root | c5550c2 | 2013-04-08 09:56:05 -0700 | [diff] [blame] | 306 | // Application install |
Ido Ofir | 6f48244 | 2014-05-09 14:47:15 -0700 | [diff] [blame] | 307 | PreferenceGroup deviceAdminCategory = (PreferenceGroup) |
Maggie Benthall | 0c5a401 | 2013-03-14 17:41:27 -0400 | [diff] [blame] | 308 | root.findPreference(KEY_DEVICE_ADMIN_CATEGORY); |
Jim Miller | 4a9065e | 2014-08-08 15:25:31 -0700 | [diff] [blame] | 309 | mToggleAppInstallation = (SwitchPreference) findPreference( |
Amith Yamasani | 7fb4f85 | 2012-09-25 22:17:33 -0700 | [diff] [blame] | 310 | KEY_TOGGLE_INSTALL_APPLICATIONS); |
| 311 | mToggleAppInstallation.setChecked(isNonMarketAppsAllowed()); |
Maggie Benthall | 0c5a401 | 2013-03-14 17:41:27 -0400 | [diff] [blame] | 312 | // Side loading of apps. |
Amith Yamasani | ceceb2a | 2014-11-11 15:36:15 -0800 | [diff] [blame] | 313 | // Disable for restricted profiles. For others, check if policy disallows it. |
Adrian Roos | 5437588 | 2015-04-16 17:11:22 -0700 | [diff] [blame] | 314 | mToggleAppInstallation.setEnabled(!um.getUserInfo(MY_USER_ID).isRestricted()); |
Julia Reynolds | 565653c | 2014-06-12 11:49:12 -0400 | [diff] [blame] | 315 | if (um.hasUserRestriction(UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES) |
| 316 | || um.hasUserRestriction(UserManager.DISALLOW_INSTALL_APPS)) { |
| 317 | mToggleAppInstallation.setEnabled(false); |
| 318 | } |
Maggie Benthall | 0c5a401 | 2013-03-14 17:41:27 -0400 | [diff] [blame] | 319 | |
Jim Miller | fe76559 | 2014-07-31 15:30:29 -0700 | [diff] [blame] | 320 | // Advanced Security features |
| 321 | PreferenceGroup advancedCategory = |
| 322 | (PreferenceGroup)root.findPreference(KEY_ADVANCED_SECURITY); |
Jim Miller | 9d25005 | 2014-08-21 19:24:47 -0700 | [diff] [blame] | 323 | if (advancedCategory != null) { |
Jim Miller | fe76559 | 2014-07-31 15:30:29 -0700 | [diff] [blame] | 324 | Preference manageAgents = advancedCategory.findPreference(KEY_MANAGE_TRUST_AGENTS); |
Adrian Roos | 5437588 | 2015-04-16 17:11:22 -0700 | [diff] [blame] | 325 | if (manageAgents != null && !mLockPatternUtils.isSecure(MY_USER_ID)) { |
Jim Miller | 9d25005 | 2014-08-21 19:24:47 -0700 | [diff] [blame] | 326 | manageAgents.setEnabled(false); |
| 327 | manageAgents.setSummary(R.string.disabled_because_no_backup_security); |
| 328 | } |
Jim Miller | fe76559 | 2014-07-31 15:30:29 -0700 | [diff] [blame] | 329 | } |
| 330 | |
| 331 | // The above preferences come and go based on security state, so we need to update |
| 332 | // the index. This call is expected to be fairly cheap, but we may want to do something |
| 333 | // smarter in the future. |
| 334 | Index.getInstance(getActivity()) |
| 335 | .updateFromClassNameResource(SecuritySettings.class.getName(), true, true); |
| 336 | |
Jim Miller | 4a9065e | 2014-08-08 15:25:31 -0700 | [diff] [blame] | 337 | for (int i = 0; i < SWITCH_PREFERENCE_KEYS.length; i++) { |
| 338 | final Preference pref = findPreference(SWITCH_PREFERENCE_KEYS[i]); |
| 339 | if (pref != null) pref.setOnPreferenceChangeListener(this); |
| 340 | } |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 341 | return root; |
| 342 | } |
| 343 | |
Jim Miller | 94d4bd9 | 2015-02-19 21:04:57 -0800 | [diff] [blame] | 344 | private void maybeAddFingerprintPreference(PreferenceGroup securityCategory) { |
| 345 | FingerprintManager fpm = (FingerprintManager) getActivity().getSystemService( |
| 346 | Context.FINGERPRINT_SERVICE); |
| 347 | if (!fpm.isHardwareDetected()) { |
| 348 | Log.v(TAG, "No fingerprint hardware detected!!"); |
| 349 | return; |
| 350 | } |
| 351 | Preference fingerprintPreference = new Preference(securityCategory.getContext()); |
Jim Miller | 9218687 | 2015-03-04 18:07:32 -0800 | [diff] [blame] | 352 | fingerprintPreference.setKey(KEY_FINGERPRINT_SETTINGS); |
Jim Miller | 94d4bd9 | 2015-02-19 21:04:57 -0800 | [diff] [blame] | 353 | fingerprintPreference.setTitle(R.string.security_settings_fingerprint_preference_title); |
| 354 | Intent intent = new Intent(); |
Jim Miller | d16c9b7 | 2015-03-24 16:02:59 -0700 | [diff] [blame] | 355 | final List<Fingerprint> items = fpm.getEnrolledFingerprints(); |
| 356 | final int fingerprintCount = items != null ? items.size() : 0; |
Jim Miller | 9218687 | 2015-03-04 18:07:32 -0800 | [diff] [blame] | 357 | final String clazz; |
Jim Miller | 94d4bd9 | 2015-02-19 21:04:57 -0800 | [diff] [blame] | 358 | if (fingerprintCount > 0) { |
| 359 | fingerprintPreference.setSummary(getResources().getQuantityString( |
| 360 | R.plurals.security_settings_fingerprint_preference_summary, |
| 361 | fingerprintCount, fingerprintCount)); |
Jim Miller | 9218687 | 2015-03-04 18:07:32 -0800 | [diff] [blame] | 362 | clazz = FingerprintSettings.class.getName(); |
Jim Miller | 94d4bd9 | 2015-02-19 21:04:57 -0800 | [diff] [blame] | 363 | } else { |
Selim Cinek | ec85004 | 2015-06-11 18:59:54 -0700 | [diff] [blame] | 364 | clazz = FingerprintEnrollIntroduction.class.getName(); |
Jim Miller | 94d4bd9 | 2015-02-19 21:04:57 -0800 | [diff] [blame] | 365 | } |
Jim Miller | 9218687 | 2015-03-04 18:07:32 -0800 | [diff] [blame] | 366 | intent.setClassName("com.android.settings", clazz); |
Jim Miller | 94d4bd9 | 2015-02-19 21:04:57 -0800 | [diff] [blame] | 367 | fingerprintPreference.setIntent(intent); |
| 368 | securityCategory.addPreference(fingerprintPreference); |
| 369 | } |
| 370 | |
| 371 | private void addTrustAgentSettings(PreferenceGroup securityCategory) { |
Adrian Roos | 5437588 | 2015-04-16 17:11:22 -0700 | [diff] [blame] | 372 | final boolean hasSecurity = mLockPatternUtils.isSecure(MY_USER_ID); |
Jim Miller | 94d4bd9 | 2015-02-19 21:04:57 -0800 | [diff] [blame] | 373 | ArrayList<TrustAgentComponentInfo> agents = |
Adrian Roos | 088de47 | 2015-04-07 14:09:39 +0200 | [diff] [blame] | 374 | getActiveTrustAgents(getPackageManager(), mLockPatternUtils, mDPM); |
Jim Miller | 94d4bd9 | 2015-02-19 21:04:57 -0800 | [diff] [blame] | 375 | for (int i = 0; i < agents.size(); i++) { |
| 376 | final TrustAgentComponentInfo agent = agents.get(i); |
| 377 | Preference trustAgentPreference = |
| 378 | new Preference(securityCategory.getContext()); |
| 379 | trustAgentPreference.setKey(KEY_TRUST_AGENT); |
| 380 | trustAgentPreference.setTitle(agent.title); |
| 381 | trustAgentPreference.setSummary(agent.summary); |
| 382 | // Create intent for this preference. |
| 383 | Intent intent = new Intent(); |
| 384 | intent.setComponent(agent.componentName); |
| 385 | intent.setAction(Intent.ACTION_MAIN); |
| 386 | trustAgentPreference.setIntent(intent); |
| 387 | // Add preference to the settings menu. |
| 388 | securityCategory.addPreference(trustAgentPreference); |
Adrian Roos | 088de47 | 2015-04-07 14:09:39 +0200 | [diff] [blame] | 389 | |
| 390 | if (agent.disabledByAdministrator) { |
| 391 | trustAgentPreference.setEnabled(false); |
| 392 | trustAgentPreference.setSummary(R.string.trust_agent_disabled_device_admin); |
| 393 | } else if (!hasSecurity) { |
Jim Miller | 94d4bd9 | 2015-02-19 21:04:57 -0800 | [diff] [blame] | 394 | trustAgentPreference.setEnabled(false); |
| 395 | trustAgentPreference.setSummary(R.string.disabled_because_no_backup_security); |
| 396 | } |
| 397 | } |
| 398 | } |
| 399 | |
PauloftheWest | 0b8788a | 2014-12-08 13:49:35 -0800 | [diff] [blame] | 400 | /* Return true if a there is a Slot that has Icc. |
| 401 | */ |
| 402 | private boolean isSimIccReady() { |
| 403 | TelephonyManager tm = TelephonyManager.getDefault(); |
| 404 | final List<SubscriptionInfo> subInfoList = |
| 405 | mSubscriptionManager.getActiveSubscriptionInfoList(); |
| 406 | |
| 407 | if (subInfoList != null) { |
| 408 | for (SubscriptionInfo subInfo : subInfoList) { |
Sanket Padawe | 2478420 | 2015-01-14 14:48:27 -0800 | [diff] [blame] | 409 | if (tm.hasIccCard(subInfo.getSimSlotIndex())) { |
PauloftheWest | 0b8788a | 2014-12-08 13:49:35 -0800 | [diff] [blame] | 410 | return true; |
| 411 | } |
| 412 | } |
| 413 | } |
| 414 | |
| 415 | return false; |
| 416 | } |
| 417 | |
PauloftheWest | 50e6eca | 2014-10-03 11:07:14 -0700 | [diff] [blame] | 418 | /* Return true if a SIM is ready for locking. |
| 419 | * TODO: consider adding to TelephonyManager or SubscritpionManasger. |
| 420 | */ |
Wink Saville | 0183fb5 | 2014-11-22 10:11:39 -0800 | [diff] [blame] | 421 | private boolean isSimReady() { |
PauloftheWest | 50e6eca | 2014-10-03 11:07:14 -0700 | [diff] [blame] | 422 | int simState = TelephonyManager.SIM_STATE_UNKNOWN; |
Wink Saville | 0183fb5 | 2014-11-22 10:11:39 -0800 | [diff] [blame] | 423 | final List<SubscriptionInfo> subInfoList = |
| 424 | mSubscriptionManager.getActiveSubscriptionInfoList(); |
PauloftheWest | 50e6eca | 2014-10-03 11:07:14 -0700 | [diff] [blame] | 425 | if (subInfoList != null) { |
Wink Saville | ca75661 | 2014-11-08 10:47:12 -0800 | [diff] [blame] | 426 | for (SubscriptionInfo subInfo : subInfoList) { |
Stuart Scott | 3ada2ec | 2014-10-31 14:11:24 -0700 | [diff] [blame] | 427 | simState = TelephonyManager.getDefault().getSimState(subInfo.getSimSlotIndex()); |
PauloftheWest | 50e6eca | 2014-10-03 11:07:14 -0700 | [diff] [blame] | 428 | if((simState != TelephonyManager.SIM_STATE_ABSENT) && |
| 429 | (simState != TelephonyManager.SIM_STATE_UNKNOWN)){ |
| 430 | return true; |
| 431 | } |
| 432 | } |
| 433 | } |
| 434 | return false; |
| 435 | } |
| 436 | |
Jim Miller | fe76559 | 2014-07-31 15:30:29 -0700 | [diff] [blame] | 437 | private static ArrayList<TrustAgentComponentInfo> getActiveTrustAgents( |
Adrian Roos | 088de47 | 2015-04-07 14:09:39 +0200 | [diff] [blame] | 438 | PackageManager pm, LockPatternUtils utils, DevicePolicyManager dpm) { |
Jim Miller | fe76559 | 2014-07-31 15:30:29 -0700 | [diff] [blame] | 439 | ArrayList<TrustAgentComponentInfo> result = new ArrayList<TrustAgentComponentInfo>(); |
| 440 | List<ResolveInfo> resolveInfos = pm.queryIntentServices(TRUST_AGENT_INTENT, |
| 441 | PackageManager.GET_META_DATA); |
Adrian Roos | 5437588 | 2015-04-16 17:11:22 -0700 | [diff] [blame] | 442 | List<ComponentName> enabledTrustAgents = utils.getEnabledTrustAgents(MY_USER_ID); |
Adrian Roos | 088de47 | 2015-04-07 14:09:39 +0200 | [diff] [blame] | 443 | |
| 444 | boolean disableTrustAgents = (dpm.getKeyguardDisabledFeatures(null) |
| 445 | & DevicePolicyManager.KEYGUARD_DISABLE_TRUST_AGENTS) != 0; |
| 446 | |
Jim Miller | fe76559 | 2014-07-31 15:30:29 -0700 | [diff] [blame] | 447 | if (enabledTrustAgents != null && !enabledTrustAgents.isEmpty()) { |
| 448 | for (int i = 0; i < resolveInfos.size(); i++) { |
| 449 | ResolveInfo resolveInfo = resolveInfos.get(i); |
| 450 | if (resolveInfo.serviceInfo == null) continue; |
| 451 | if (!TrustAgentUtils.checkProvidePermission(resolveInfo, pm)) continue; |
| 452 | TrustAgentComponentInfo trustAgentComponentInfo = |
| 453 | TrustAgentUtils.getSettingsComponent(pm, resolveInfo); |
| 454 | if (trustAgentComponentInfo.componentName == null || |
| 455 | !enabledTrustAgents.contains( |
| 456 | TrustAgentUtils.getComponentName(resolveInfo)) || |
| 457 | TextUtils.isEmpty(trustAgentComponentInfo.title)) continue; |
Adrian Roos | 088de47 | 2015-04-07 14:09:39 +0200 | [diff] [blame] | 458 | if (disableTrustAgents && dpm.getTrustAgentConfiguration( |
| 459 | null, TrustAgentUtils.getComponentName(resolveInfo)) == null) { |
| 460 | trustAgentComponentInfo.disabledByAdministrator = true; |
| 461 | } |
Jim Miller | fe76559 | 2014-07-31 15:30:29 -0700 | [diff] [blame] | 462 | result.add(trustAgentComponentInfo); |
| 463 | if (ONLY_ONE_TRUST_AGENT) break; |
| 464 | } |
| 465 | } |
| 466 | return result; |
| 467 | } |
| 468 | |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 469 | private boolean isNonMarketAppsAllowed() { |
Christopher Tate | 5a64c73 | 2012-09-07 13:35:31 -0700 | [diff] [blame] | 470 | return Settings.Global.getInt(getContentResolver(), |
| 471 | Settings.Global.INSTALL_NON_MARKET_APPS, 0) > 0; |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 472 | } |
| 473 | |
| 474 | private void setNonMarketAppsAllowed(boolean enabled) { |
Maggie Benthall | 0c5a401 | 2013-03-14 17:41:27 -0400 | [diff] [blame] | 475 | final UserManager um = (UserManager) getActivity().getSystemService(Context.USER_SERVICE); |
| 476 | if (um.hasUserRestriction(UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES)) { |
| 477 | return; |
| 478 | } |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 479 | // Change the system setting |
Christopher Tate | 5a64c73 | 2012-09-07 13:35:31 -0700 | [diff] [blame] | 480 | Settings.Global.putInt(getContentResolver(), Settings.Global.INSTALL_NON_MARKET_APPS, |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 481 | enabled ? 1 : 0); |
| 482 | } |
| 483 | |
| 484 | private void warnAppInstallation() { |
| 485 | // TODO: DialogFragment? |
| 486 | mWarnInstallApps = new AlertDialog.Builder(getActivity()).setTitle( |
| 487 | getResources().getString(R.string.error_title)) |
| 488 | .setIcon(com.android.internal.R.drawable.ic_dialog_alert) |
| 489 | .setMessage(getResources().getString(R.string.install_all_warning)) |
| 490 | .setPositiveButton(android.R.string.yes, this) |
arete | 1722482 | 2014-08-14 13:45:36 -0700 | [diff] [blame] | 491 | .setNegativeButton(android.R.string.no, this) |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 492 | .show(); |
| 493 | } |
| 494 | |
Maggie Benthall | 0c5a401 | 2013-03-14 17:41:27 -0400 | [diff] [blame] | 495 | @Override |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 496 | public void onClick(DialogInterface dialog, int which) { |
arete | 1722482 | 2014-08-14 13:45:36 -0700 | [diff] [blame] | 497 | if (dialog == mWarnInstallApps) { |
| 498 | boolean turnOn = which == DialogInterface.BUTTON_POSITIVE; |
| 499 | setNonMarketAppsAllowed(turnOn); |
Amith Yamasani | b810a0d | 2012-03-25 10:12:26 -0700 | [diff] [blame] | 500 | if (mToggleAppInstallation != null) { |
arete | 1722482 | 2014-08-14 13:45:36 -0700 | [diff] [blame] | 501 | mToggleAppInstallation.setChecked(turnOn); |
Amith Yamasani | b810a0d | 2012-03-25 10:12:26 -0700 | [diff] [blame] | 502 | } |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 503 | } |
| 504 | } |
| 505 | |
| 506 | @Override |
| 507 | public void onDestroy() { |
| 508 | super.onDestroy(); |
| 509 | if (mWarnInstallApps != null) { |
| 510 | mWarnInstallApps.dismiss(); |
| 511 | } |
| 512 | } |
| 513 | |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 514 | private void setupLockAfterPreference() { |
| 515 | // Compatible with pre-Froyo |
| 516 | long currentTimeout = Settings.Secure.getLong(getContentResolver(), |
| 517 | Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT, 5000); |
| 518 | mLockAfter.setValue(String.valueOf(currentTimeout)); |
| 519 | mLockAfter.setOnPreferenceChangeListener(this); |
| 520 | final long adminTimeout = (mDPM != null ? mDPM.getMaximumTimeToLock(null) : 0); |
| 521 | final long displayTimeout = Math.max(0, |
| 522 | Settings.System.getInt(getContentResolver(), SCREEN_OFF_TIMEOUT, 0)); |
| 523 | if (adminTimeout > 0) { |
| 524 | // This setting is a slave to display timeout when a device policy is enforced. |
| 525 | // As such, maxLockTimeout = adminTimeout - displayTimeout. |
| 526 | // If there isn't enough time, shows "immediately" setting. |
| 527 | disableUnusableTimeouts(Math.max(0, adminTimeout - displayTimeout)); |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 528 | } |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 529 | } |
| 530 | |
Jim Miller | c978707 | 2011-01-09 18:00:28 -0800 | [diff] [blame] | 531 | private void updateLockAfterPreferenceSummary() { |
Jim Miller | c978707 | 2011-01-09 18:00:28 -0800 | [diff] [blame] | 532 | // Update summary message with current value |
| 533 | long currentTimeout = Settings.Secure.getLong(getContentResolver(), |
Amith Yamasani | 58bca8f | 2011-07-22 12:16:16 -0700 | [diff] [blame] | 534 | Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT, 5000); |
Jim Miller | c978707 | 2011-01-09 18:00:28 -0800 | [diff] [blame] | 535 | final CharSequence[] entries = mLockAfter.getEntries(); |
| 536 | final CharSequence[] values = mLockAfter.getEntryValues(); |
| 537 | int best = 0; |
| 538 | for (int i = 0; i < values.length; i++) { |
| 539 | long timeout = Long.valueOf(values[i].toString()); |
| 540 | if (currentTimeout >= timeout) { |
| 541 | best = i; |
| 542 | } |
| 543 | } |
Ido Ofir | 1682a0d | 2014-06-24 16:26:09 -0700 | [diff] [blame] | 544 | |
| 545 | Preference preference = getPreferenceScreen().findPreference(KEY_TRUST_AGENT); |
| 546 | if (preference != null && preference.getTitle().length() > 0) { |
Jim Miller | 50d7d19 | 2015-06-16 16:21:27 -0700 | [diff] [blame] | 547 | if (Long.valueOf(values[best].toString()) == 0) { |
| 548 | mLockAfter.setSummary(getString(R.string.lock_immediately_summary_with_exception, |
| 549 | preference.getTitle())); |
| 550 | } else { |
| 551 | mLockAfter.setSummary(getString(R.string.lock_after_timeout_summary_with_exception, |
| 552 | entries[best], preference.getTitle())); |
| 553 | } |
Ido Ofir | 1682a0d | 2014-06-24 16:26:09 -0700 | [diff] [blame] | 554 | } else { |
| 555 | mLockAfter.setSummary(getString(R.string.lock_after_timeout_summary, entries[best])); |
| 556 | } |
Jim Miller | c978707 | 2011-01-09 18:00:28 -0800 | [diff] [blame] | 557 | } |
| 558 | |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 559 | private void disableUnusableTimeouts(long maxTimeout) { |
| 560 | final CharSequence[] entries = mLockAfter.getEntries(); |
| 561 | final CharSequence[] values = mLockAfter.getEntryValues(); |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 562 | ArrayList<CharSequence> revisedEntries = new ArrayList<CharSequence>(); |
| 563 | ArrayList<CharSequence> revisedValues = new ArrayList<CharSequence>(); |
| 564 | for (int i = 0; i < values.length; i++) { |
| 565 | long timeout = Long.valueOf(values[i].toString()); |
| 566 | if (timeout <= maxTimeout) { |
| 567 | revisedEntries.add(entries[i]); |
| 568 | revisedValues.add(values[i]); |
| 569 | } |
| 570 | } |
| 571 | if (revisedEntries.size() != entries.length || revisedValues.size() != values.length) { |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 572 | mLockAfter.setEntries( |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 573 | revisedEntries.toArray(new CharSequence[revisedEntries.size()])); |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 574 | mLockAfter.setEntryValues( |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 575 | revisedValues.toArray(new CharSequence[revisedValues.size()])); |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 576 | final int userPreference = Integer.valueOf(mLockAfter.getValue()); |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 577 | if (userPreference <= maxTimeout) { |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 578 | mLockAfter.setValue(String.valueOf(userPreference)); |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 579 | } else { |
| 580 | // There will be no highlighted selection since nothing in the list matches |
| 581 | // maxTimeout. The user can still select anything less than maxTimeout. |
| 582 | // TODO: maybe append maxTimeout to the list and mark selected. |
| 583 | } |
| 584 | } |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 585 | mLockAfter.setEnabled(revisedEntries.size() > 0); |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 586 | } |
| 587 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 588 | @Override |
Jim Miller | 250b9be | 2014-09-05 18:48:18 -0700 | [diff] [blame] | 589 | public void onSaveInstanceState(Bundle outState) { |
| 590 | super.onSaveInstanceState(outState); |
| 591 | if (mTrustAgentClickIntent != null) { |
| 592 | outState.putParcelable(TRUST_AGENT_CLICK_INTENT, mTrustAgentClickIntent); |
| 593 | } |
| 594 | } |
| 595 | |
| 596 | @Override |
Amith Yamasani | d799347 | 2010-08-18 13:59:28 -0700 | [diff] [blame] | 597 | public void onResume() { |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 598 | super.onResume(); |
| 599 | |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 600 | // Make sure we reload the preference hierarchy since some of these settings |
| 601 | // depend on others... |
| 602 | createPreferenceHierarchy(); |
| 603 | |
Jim Miller | 00d2476 | 2009-12-22 19:04:57 -0800 | [diff] [blame] | 604 | final LockPatternUtils lockPatternUtils = mChooseLockSettingsHelper.utils(); |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 605 | if (mVisiblePattern != null) { |
Adrian Roos | 5437588 | 2015-04-16 17:11:22 -0700 | [diff] [blame] | 606 | mVisiblePattern.setChecked(lockPatternUtils.isVisiblePatternEnabled( |
| 607 | MY_USER_ID)); |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 608 | } |
Jim Miller | 071742d | 2012-01-06 18:28:09 -0800 | [diff] [blame] | 609 | if (mPowerButtonInstantlyLocks != null) { |
Adrian Roos | 5437588 | 2015-04-16 17:11:22 -0700 | [diff] [blame] | 610 | mPowerButtonInstantlyLocks.setChecked(lockPatternUtils.getPowerButtonInstantlyLocks( |
| 611 | MY_USER_ID)); |
Jim Miller | 071742d | 2012-01-06 18:28:09 -0800 | [diff] [blame] | 612 | } |
Hung-ying Tyan | 7031ab0 | 2009-07-02 00:26:46 +0800 | [diff] [blame] | 613 | |
Amith Yamasani | b810a0d | 2012-03-25 10:12:26 -0700 | [diff] [blame] | 614 | if (mShowPassword != null) { |
| 615 | mShowPassword.setChecked(Settings.System.getInt(getContentResolver(), |
| 616 | Settings.System.TEXT_SHOW_PASSWORD, 1) != 0); |
| 617 | } |
Hung-ying Tyan | b0883cb | 2009-09-30 11:56:05 +0800 | [diff] [blame] | 618 | |
Amith Yamasani | b810a0d | 2012-03-25 10:12:26 -0700 | [diff] [blame] | 619 | if (mResetCredentials != null) { |
Kenny Root | c4372c3 | 2013-04-22 13:41:18 -0700 | [diff] [blame] | 620 | mResetCredentials.setEnabled(!mKeyStore.isEmpty()); |
Amith Yamasani | b810a0d | 2012-03-25 10:12:26 -0700 | [diff] [blame] | 621 | } |
Jason Monk | 3bcd76c | 2015-04-21 11:20:20 -0400 | [diff] [blame] | 622 | |
| 623 | updateOwnerInfo(); |
| 624 | } |
| 625 | |
| 626 | public void updateOwnerInfo() { |
| 627 | if (mOwnerInfoPref != null) { |
Adrian Roos | 5437588 | 2015-04-16 17:11:22 -0700 | [diff] [blame] | 628 | mOwnerInfoPref.setSummary(mLockPatternUtils.isOwnerInfoEnabled(MY_USER_ID) |
| 629 | ? mLockPatternUtils.getOwnerInfo(MY_USER_ID) |
Jason Monk | 3bcd76c | 2015-04-21 11:20:20 -0400 | [diff] [blame] | 630 | : getString(R.string.owner_info_settings_summary)); |
| 631 | } |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 632 | } |
| 633 | |
| 634 | @Override |
Gilles Debunne | a6a8a14 | 2011-06-09 11:56:17 -0700 | [diff] [blame] | 635 | public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) { |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 636 | final String key = preference.getKey(); |
Jim Miller | bbb4afa | 2010-04-08 19:40:19 -0700 | [diff] [blame] | 637 | if (KEY_UNLOCK_SET_OR_CHANGE.equals(key)) { |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 638 | startFragment(this, "com.android.settings.ChooseLockGeneric$ChooseLockGenericFragment", |
Fabrice Di Meglio | 5bdf042 | 2014-07-01 15:15:18 -0700 | [diff] [blame] | 639 | R.string.lock_settings_picker_title, SET_OR_CHANGE_LOCK_METHOD_REQUEST, null); |
Ido Ofir | 6f48244 | 2014-05-09 14:47:15 -0700 | [diff] [blame] | 640 | } else if (KEY_TRUST_AGENT.equals(key)) { |
| 641 | ChooseLockSettingsHelper helper = |
| 642 | new ChooseLockSettingsHelper(this.getActivity(), this); |
Jim Miller | 250b9be | 2014-09-05 18:48:18 -0700 | [diff] [blame] | 643 | mTrustAgentClickIntent = preference.getIntent(); |
Jorim Jaggi | 8a09b61 | 2015-04-06 17:47:18 -0700 | [diff] [blame] | 644 | boolean confirmationLaunched = helper.launchConfirmationActivity( |
| 645 | CHANGE_TRUST_AGENT_SETTINGS, preference.getTitle()); |
| 646 | if (!confirmationLaunched&& mTrustAgentClickIntent != null) { |
Ido Ofir | 6f48244 | 2014-05-09 14:47:15 -0700 | [diff] [blame] | 647 | // If this returns false, it means no password confirmation is required. |
Jim Miller | 250b9be | 2014-09-05 18:48:18 -0700 | [diff] [blame] | 648 | startActivity(mTrustAgentClickIntent); |
| 649 | mTrustAgentClickIntent = null; |
Ido Ofir | 6f48244 | 2014-05-09 14:47:15 -0700 | [diff] [blame] | 650 | } |
Jim Miller | 36972bb | 2010-11-30 19:47:38 -0800 | [diff] [blame] | 651 | } else { |
| 652 | // If we didn't handle it, let preferences handle it. |
| 653 | return super.onPreferenceTreeClick(preferenceScreen, preference); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 654 | } |
Jim Miller | 36972bb | 2010-11-30 19:47:38 -0800 | [diff] [blame] | 655 | return true; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 656 | } |
| 657 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 658 | /** |
Gilles Debunne | a6a8a14 | 2011-06-09 11:56:17 -0700 | [diff] [blame] | 659 | * see confirmPatternThenDisableAndClear |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 660 | */ |
| 661 | @Override |
Amith Yamasani | d799347 | 2010-08-18 13:59:28 -0700 | [diff] [blame] | 662 | public void onActivityResult(int requestCode, int resultCode, Intent data) { |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 663 | super.onActivityResult(requestCode, resultCode, data); |
Adrian Roos | f788718 | 2015-01-07 20:51:57 +0100 | [diff] [blame] | 664 | if (requestCode == CHANGE_TRUST_AGENT_SETTINGS && resultCode == Activity.RESULT_OK) { |
Jim Miller | 250b9be | 2014-09-05 18:48:18 -0700 | [diff] [blame] | 665 | if (mTrustAgentClickIntent != null) { |
| 666 | startActivity(mTrustAgentClickIntent); |
| 667 | mTrustAgentClickIntent = null; |
Ido Ofir | 6f48244 | 2014-05-09 14:47:15 -0700 | [diff] [blame] | 668 | } |
Jim Miller | 250b9be | 2014-09-05 18:48:18 -0700 | [diff] [blame] | 669 | return; |
Danielle Millett | 487b16f | 2011-11-02 11:12:21 -0400 | [diff] [blame] | 670 | } |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 671 | createPreferenceHierarchy(); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 672 | } |
Amith Yamasani | f06d869 | 2009-06-11 22:32:33 -0700 | [diff] [blame] | 673 | |
Maggie Benthall | 0c5a401 | 2013-03-14 17:41:27 -0400 | [diff] [blame] | 674 | @Override |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 675 | public boolean onPreferenceChange(Preference preference, Object value) { |
arete | 300e920 | 2014-08-15 12:04:48 -0700 | [diff] [blame] | 676 | boolean result = true; |
Jim Miller | 4a9065e | 2014-08-08 15:25:31 -0700 | [diff] [blame] | 677 | final String key = preference.getKey(); |
| 678 | final LockPatternUtils lockPatternUtils = mChooseLockSettingsHelper.utils(); |
| 679 | if (KEY_LOCK_AFTER_TIMEOUT.equals(key)) { |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 680 | int timeout = Integer.parseInt((String) value); |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 681 | try { |
| 682 | Settings.Secure.putInt(getContentResolver(), |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 683 | Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT, timeout); |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 684 | } catch (NumberFormatException e) { |
| 685 | Log.e("SecuritySettings", "could not persist lockAfter timeout setting", e); |
| 686 | } |
Jim Miller | c978707 | 2011-01-09 18:00:28 -0800 | [diff] [blame] | 687 | updateLockAfterPreferenceSummary(); |
Jim Miller | 4a9065e | 2014-08-08 15:25:31 -0700 | [diff] [blame] | 688 | } else if (KEY_VISIBLE_PATTERN.equals(key)) { |
Adrian Roos | 5437588 | 2015-04-16 17:11:22 -0700 | [diff] [blame] | 689 | lockPatternUtils.setVisiblePatternEnabled((Boolean) value, MY_USER_ID); |
Jim Miller | 4a9065e | 2014-08-08 15:25:31 -0700 | [diff] [blame] | 690 | } else if (KEY_POWER_INSTANTLY_LOCKS.equals(key)) { |
Adrian Roos | 5437588 | 2015-04-16 17:11:22 -0700 | [diff] [blame] | 691 | mLockPatternUtils.setPowerButtonInstantlyLocks((Boolean) value, MY_USER_ID); |
Jim Miller | 4a9065e | 2014-08-08 15:25:31 -0700 | [diff] [blame] | 692 | } else if (KEY_SHOW_PASSWORD.equals(key)) { |
| 693 | Settings.System.putInt(getContentResolver(), Settings.System.TEXT_SHOW_PASSWORD, |
| 694 | ((Boolean) value) ? 1 : 0); |
Paul Lawrence | c04420c | 2015-05-18 13:25:01 -0700 | [diff] [blame] | 695 | lockPatternUtils.setVisiblePasswordEnabled((Boolean) value, MY_USER_ID); |
Jim Miller | 4a9065e | 2014-08-08 15:25:31 -0700 | [diff] [blame] | 696 | } else if (KEY_TOGGLE_INSTALL_APPLICATIONS.equals(key)) { |
| 697 | if ((Boolean) value) { |
| 698 | mToggleAppInstallation.setChecked(false); |
| 699 | warnAppInstallation(); |
arete | 300e920 | 2014-08-15 12:04:48 -0700 | [diff] [blame] | 700 | // Don't change Switch status until user makes choice in dialog, so return false. |
| 701 | result = false; |
Jim Miller | 4a9065e | 2014-08-08 15:25:31 -0700 | [diff] [blame] | 702 | } else { |
| 703 | setNonMarketAppsAllowed(false); |
| 704 | } |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 705 | } |
arete | 300e920 | 2014-08-15 12:04:48 -0700 | [diff] [blame] | 706 | return result; |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 707 | } |
Danielle Millett | 487b16f | 2011-11-02 11:12:21 -0400 | [diff] [blame] | 708 | |
rich cannings | 93c0ee5 | 2012-09-30 13:54:26 -0700 | [diff] [blame] | 709 | @Override |
| 710 | protected int getHelpResource() { |
| 711 | return R.string.help_url_security; |
| 712 | } |
| 713 | |
Fabrice Di Meglio | d1d2f02 | 2014-04-11 16:09:11 -0700 | [diff] [blame] | 714 | /** |
| 715 | * For Search. Please keep it in sync when updating "createPreferenceHierarchy()" |
| 716 | */ |
| 717 | public static final SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = |
| 718 | new SecuritySearchIndexProvider(); |
| 719 | |
Jim Miller | fe76559 | 2014-07-31 15:30:29 -0700 | [diff] [blame] | 720 | private static class SecuritySearchIndexProvider extends BaseSearchIndexProvider { |
Fabrice Di Meglio | d1d2f02 | 2014-04-11 16:09:11 -0700 | [diff] [blame] | 721 | |
| 722 | boolean mIsPrimary; |
| 723 | |
| 724 | public SecuritySearchIndexProvider() { |
| 725 | super(); |
| 726 | |
Adrian Roos | 5437588 | 2015-04-16 17:11:22 -0700 | [diff] [blame] | 727 | mIsPrimary = MY_USER_ID == UserHandle.USER_OWNER; |
Fabrice Di Meglio | d1d2f02 | 2014-04-11 16:09:11 -0700 | [diff] [blame] | 728 | } |
| 729 | |
| 730 | @Override |
| 731 | public List<SearchIndexableResource> getXmlResourcesToIndex( |
| 732 | Context context, boolean enabled) { |
| 733 | |
| 734 | List<SearchIndexableResource> result = new ArrayList<SearchIndexableResource>(); |
| 735 | |
| 736 | LockPatternUtils lockPatternUtils = new LockPatternUtils(context); |
| 737 | // Add options for lock/unlock screen |
| 738 | int resId = getResIdForLockUnlockScreen(context, lockPatternUtils); |
| 739 | |
| 740 | SearchIndexableResource sir = new SearchIndexableResource(context); |
| 741 | sir.xmlResId = resId; |
| 742 | result.add(sir); |
| 743 | |
| 744 | if (mIsPrimary) { |
| 745 | DevicePolicyManager dpm = (DevicePolicyManager) |
| 746 | context.getSystemService(Context.DEVICE_POLICY_SERVICE); |
| 747 | |
| 748 | switch (dpm.getStorageEncryptionStatus()) { |
| 749 | case DevicePolicyManager.ENCRYPTION_STATUS_ACTIVE: |
| 750 | // The device is currently encrypted. |
| 751 | resId = R.xml.security_settings_encrypted; |
| 752 | break; |
| 753 | case DevicePolicyManager.ENCRYPTION_STATUS_INACTIVE: |
| 754 | // This device supports encryption but isn't encrypted. |
| 755 | resId = R.xml.security_settings_unencrypted; |
| 756 | break; |
| 757 | } |
| 758 | |
| 759 | sir = new SearchIndexableResource(context); |
| 760 | sir.xmlResId = resId; |
| 761 | result.add(sir); |
| 762 | } |
| 763 | |
| 764 | // Append the rest of the settings |
| 765 | sir = new SearchIndexableResource(context); |
| 766 | sir.xmlResId = R.xml.security_settings_misc; |
| 767 | result.add(sir); |
| 768 | |
| 769 | return result; |
| 770 | } |
| 771 | |
| 772 | @Override |
| 773 | public List<SearchIndexableRaw> getRawDataToIndex(Context context, boolean enabled) { |
| 774 | final List<SearchIndexableRaw> result = new ArrayList<SearchIndexableRaw>(); |
| 775 | final Resources res = context.getResources(); |
| 776 | |
| 777 | final String screenTitle = res.getString(R.string.security_settings_title); |
| 778 | |
Fabrice Di Meglio | d729029 | 2014-07-01 14:32:03 -0700 | [diff] [blame] | 779 | SearchIndexableRaw data = new SearchIndexableRaw(context); |
| 780 | data.title = screenTitle; |
| 781 | data.screenTitle = screenTitle; |
| 782 | result.add(data); |
Fabrice Di Meglio | d1d2f02 | 2014-04-11 16:09:11 -0700 | [diff] [blame] | 783 | |
| 784 | if (!mIsPrimary) { |
| 785 | int resId = (UserManager.get(context).isLinkedUser()) ? |
| 786 | R.string.profile_info_settings_title : R.string.user_info_settings_title; |
| 787 | |
| 788 | data = new SearchIndexableRaw(context); |
| 789 | data.title = res.getString(resId); |
| 790 | data.screenTitle = screenTitle; |
| 791 | result.add(data); |
| 792 | } |
| 793 | |
Julia Reynolds | f516e7d | 2015-07-16 15:33:22 -0400 | [diff] [blame^] | 794 | // Fingerprint |
| 795 | FingerprintManager fpm = |
| 796 | (FingerprintManager) context.getSystemService(Context.FINGERPRINT_SERVICE); |
| 797 | if (fpm.isHardwareDetected()) { |
| 798 | data = new SearchIndexableRaw(context); |
| 799 | data.title = res.getString(R.string.security_settings_fingerprint_preference_title); |
| 800 | data.screenTitle = screenTitle; |
| 801 | result.add(data); |
| 802 | } |
| 803 | |
Fabrice Di Meglio | d1d2f02 | 2014-04-11 16:09:11 -0700 | [diff] [blame] | 804 | // Credential storage |
| 805 | final UserManager um = (UserManager) context.getSystemService(Context.USER_SERVICE); |
| 806 | |
| 807 | if (!um.hasUserRestriction(UserManager.DISALLOW_CONFIG_CREDENTIALS)) { |
| 808 | KeyStore keyStore = KeyStore.getInstance(); |
| 809 | |
| 810 | final int storageSummaryRes = keyStore.isHardwareBacked() ? |
| 811 | R.string.credential_storage_type_hardware : |
| 812 | R.string.credential_storage_type_software; |
| 813 | |
| 814 | data = new SearchIndexableRaw(context); |
| 815 | data.title = res.getString(storageSummaryRes); |
| 816 | data.screenTitle = screenTitle; |
| 817 | result.add(data); |
| 818 | } |
| 819 | |
Jim Miller | fe76559 | 2014-07-31 15:30:29 -0700 | [diff] [blame] | 820 | // Advanced |
| 821 | final LockPatternUtils lockPatternUtils = new LockPatternUtils(context); |
Adrian Roos | 5437588 | 2015-04-16 17:11:22 -0700 | [diff] [blame] | 822 | if (lockPatternUtils.isSecure(MY_USER_ID)) { |
Jim Miller | fe76559 | 2014-07-31 15:30:29 -0700 | [diff] [blame] | 823 | ArrayList<TrustAgentComponentInfo> agents = |
Adrian Roos | 088de47 | 2015-04-07 14:09:39 +0200 | [diff] [blame] | 824 | getActiveTrustAgents(context.getPackageManager(), lockPatternUtils, |
| 825 | context.getSystemService(DevicePolicyManager.class)); |
Jim Miller | fe76559 | 2014-07-31 15:30:29 -0700 | [diff] [blame] | 826 | for (int i = 0; i < agents.size(); i++) { |
| 827 | final TrustAgentComponentInfo agent = agents.get(i); |
| 828 | data = new SearchIndexableRaw(context); |
| 829 | data.title = agent.title; |
| 830 | data.screenTitle = screenTitle; |
| 831 | result.add(data); |
| 832 | } |
| 833 | } |
Fabrice Di Meglio | d1d2f02 | 2014-04-11 16:09:11 -0700 | [diff] [blame] | 834 | return result; |
| 835 | } |
| 836 | |
| 837 | @Override |
| 838 | public List<String> getNonIndexableKeys(Context context) { |
| 839 | final List<String> keys = new ArrayList<String>(); |
| 840 | |
| 841 | LockPatternUtils lockPatternUtils = new LockPatternUtils(context); |
| 842 | // Add options for lock/unlock screen |
| 843 | int resId = getResIdForLockUnlockScreen(context, lockPatternUtils); |
| 844 | |
Fabrice Di Meglio | d1d2f02 | 2014-04-11 16:09:11 -0700 | [diff] [blame] | 845 | // Do not display SIM lock for devices without an Icc card |
| 846 | TelephonyManager tm = TelephonyManager.getDefault(); |
| 847 | if (!mIsPrimary || !tm.hasIccCard()) { |
| 848 | keys.add(KEY_SIM_LOCK); |
| 849 | } |
| 850 | |
Fabrice Di Meglio | d1d2f02 | 2014-04-11 16:09:11 -0700 | [diff] [blame] | 851 | final UserManager um = (UserManager) context.getSystemService(Context.USER_SERVICE); |
| 852 | if (um.hasUserRestriction(UserManager.DISALLOW_CONFIG_CREDENTIALS)) { |
| 853 | keys.add(KEY_CREDENTIALS_MANAGER); |
| 854 | } |
| 855 | |
Jim Miller | fe76559 | 2014-07-31 15:30:29 -0700 | [diff] [blame] | 856 | // TrustAgent settings disappear when the user has no primary security. |
Adrian Roos | 5437588 | 2015-04-16 17:11:22 -0700 | [diff] [blame] | 857 | if (!lockPatternUtils.isSecure(MY_USER_ID)) { |
Jim Miller | fe76559 | 2014-07-31 15:30:29 -0700 | [diff] [blame] | 858 | keys.add(KEY_TRUST_AGENT); |
| 859 | keys.add(KEY_MANAGE_TRUST_AGENTS); |
| 860 | } |
| 861 | |
Fabrice Di Meglio | d1d2f02 | 2014-04-11 16:09:11 -0700 | [diff] [blame] | 862 | return keys; |
| 863 | } |
| 864 | } |
| 865 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 866 | } |