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 | |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 20 | import static android.provider.Settings.System.SCREEN_OFF_TIMEOUT; |
| 21 | |
Danielle Millett | 487b16f | 2011-11-02 11:12:21 -0400 | [diff] [blame] | 22 | import android.app.Activity; |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 23 | import android.app.AlertDialog; |
Dianne Hackborn | 4037c7f | 2010-02-26 17:26:55 -0800 | [diff] [blame] | 24 | import android.app.admin.DevicePolicyManager; |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 25 | import android.appwidget.AppWidgetHost; |
| 26 | import android.appwidget.AppWidgetManager; |
| 27 | import android.appwidget.AppWidgetProviderInfo; |
| 28 | import android.content.ActivityNotFoundException; |
| 29 | import android.content.ComponentName; |
Dianne Hackborn | abc3dc6 | 2010-01-20 13:40:19 -0800 | [diff] [blame] | 30 | import android.content.Context; |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 31 | import android.content.DialogInterface; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 32 | import android.content.Intent; |
rich cannings | bfbdcef | 2012-09-09 12:48:50 -0700 | [diff] [blame] | 33 | import android.content.pm.PackageManager; |
| 34 | import android.content.pm.ResolveInfo; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 35 | import android.os.Bundle; |
Dianne Hackborn | bb06a42 | 2012-08-16 11:01:57 -0700 | [diff] [blame] | 36 | import android.os.UserHandle; |
Amith Yamasani | edac9af | 2010-11-17 09:08:21 -0800 | [diff] [blame] | 37 | import android.os.Vibrator; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 38 | import android.preference.CheckBoxPreference; |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 39 | import android.preference.ListPreference; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 40 | import android.preference.Preference; |
Mathew Inwood | f8b2579 | 2010-10-21 18:43:35 +0100 | [diff] [blame] | 41 | import android.preference.Preference.OnPreferenceChangeListener; |
Mathew Inwood | f8b2579 | 2010-10-21 18:43:35 +0100 | [diff] [blame] | 42 | import android.preference.PreferenceGroup; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 43 | import android.preference.PreferenceScreen; |
| 44 | import android.provider.Settings; |
Chia-chi Yeh | 9cec698 | 2009-09-22 23:59:01 +0800 | [diff] [blame] | 45 | import android.security.KeyStore; |
Oscar Montemayor | 56e1526 | 2009-11-30 10:39:07 -0800 | [diff] [blame] | 46 | import android.telephony.TelephonyManager; |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 47 | import android.util.Log; |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 48 | import android.widget.Toast; |
Amith Yamasani | f06d869 | 2009-06-11 22:32:33 -0700 | [diff] [blame] | 49 | |
Gilles Debunne | a6a8a14 | 2011-06-09 11:56:17 -0700 | [diff] [blame] | 50 | import com.android.internal.widget.LockPatternUtils; |
| 51 | |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 52 | import java.util.ArrayList; |
rich cannings | bfbdcef | 2012-09-09 12:48:50 -0700 | [diff] [blame] | 53 | import java.util.List; |
Mike Lockwood | 5ed2c4a | 2009-06-07 23:07:20 -0400 | [diff] [blame] | 54 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 55 | /** |
| 56 | * Gesture lock pattern settings. |
| 57 | */ |
Jim Miller | 36972bb | 2010-11-30 19:47:38 -0800 | [diff] [blame] | 58 | public class SecuritySettings extends SettingsPreferenceFragment |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 59 | implements OnPreferenceChangeListener, DialogInterface.OnClickListener { |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 60 | static final String TAG = "SecuritySettings"; |
Jason parks | 6f8fb43 | 2011-01-07 09:02:14 -0600 | [diff] [blame] | 61 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 62 | // Lock Settings |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 63 | private static final String KEY_UNLOCK_SET_OR_CHANGE = "unlock_set_or_change"; |
Michael Jurka | 091477b | 2012-09-20 19:03:35 -0700 | [diff] [blame] | 64 | private static final String KEY_CHOOSE_LOCKSCREEN_STATUS_WIDGET = |
| 65 | "choose_lockscreen_status_widget"; |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 66 | private static final String KEY_CHOOSE_USER_SELECTED_LOCKSCREEN_WIDGET = |
| 67 | "choose_user_selected_lockscreen_widget"; |
Danielle Millett | 487b16f | 2011-11-02 11:12:21 -0400 | [diff] [blame] | 68 | private static final String KEY_BIOMETRIC_WEAK_IMPROVE_MATCHING = |
| 69 | "biometric_weak_improve_matching"; |
Danielle Millett | a87a25b | 2012-03-19 18:05:26 -0400 | [diff] [blame] | 70 | private static final String KEY_BIOMETRIC_WEAK_LIVELINESS = "biometric_weak_liveliness"; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 71 | private static final String KEY_LOCK_ENABLED = "lockenabled"; |
| 72 | private static final String KEY_VISIBLE_PATTERN = "visiblepattern"; |
Jim Miller | 9e61b9f | 2010-02-18 19:56:04 -0800 | [diff] [blame] | 73 | private static final String KEY_TACTILE_FEEDBACK_ENABLED = "unlock_tactile_feedback"; |
Amith Yamasani | edac9af | 2010-11-17 09:08:21 -0800 | [diff] [blame] | 74 | private static final String KEY_SECURITY_CATEGORY = "security_category"; |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 75 | private static final String KEY_LOCK_AFTER_TIMEOUT = "lock_after_timeout"; |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 76 | private static final String EXTRA_NO_WIDGET = "com.android.settings.NO_WIDGET"; |
Michael Jurka | 091477b | 2012-09-20 19:03:35 -0700 | [diff] [blame] | 77 | private static final String EXTRA_DEFAULT_WIDGET = "com.android.settings.DEFAULT_WIDGET"; |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 78 | private static final int SET_OR_CHANGE_LOCK_METHOD_REQUEST = 123; |
Danielle Millett | 790e0c3 | 2012-03-23 15:17:50 -0400 | [diff] [blame] | 79 | private static final int CONFIRM_EXISTING_FOR_BIOMETRIC_WEAK_IMPROVE_REQUEST = 124; |
Danielle Millett | 4a3e40d | 2012-06-06 13:54:11 -0400 | [diff] [blame] | 80 | private static final int CONFIRM_EXISTING_FOR_BIOMETRIC_WEAK_LIVELINESS_OFF = 125; |
Michael Jurka | 091477b | 2012-09-20 19:03:35 -0700 | [diff] [blame] | 81 | private static final int REQUEST_PICK_USER_SELECTED_APPWIDGET = 126; |
| 82 | private static final int REQUEST_PICK_STATUS_APPWIDGET = 127; |
| 83 | private static final int REQUEST_CREATE_USER_SELECTED_APPWIDGET = 128; |
| 84 | private static final int REQUEST_CREATE_STATUS_APPWIDGET = 129; |
Hung-ying Tyan | 7031ab0 | 2009-07-02 00:26:46 +0800 | [diff] [blame] | 85 | |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 86 | // Misc Settings |
| 87 | private static final String KEY_SIM_LOCK = "sim_lock"; |
| 88 | private static final String KEY_SHOW_PASSWORD = "show_password"; |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 89 | private static final String KEY_RESET_CREDENTIALS = "reset_credentials"; |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 90 | private static final String KEY_TOGGLE_INSTALL_APPLICATIONS = "toggle_install_applications"; |
rich cannings | d5d6065 | 2012-09-07 13:20:44 -0700 | [diff] [blame] | 91 | private static final String KEY_TOGGLE_VERIFY_APPLICATIONS = "toggle_verify_applications"; |
Jim Miller | 071742d | 2012-01-06 18:28:09 -0800 | [diff] [blame] | 92 | private static final String KEY_POWER_INSTANTLY_LOCKS = "power_button_instantly_locks"; |
Amith Yamasani | 7fb4f85 | 2012-09-25 22:17:33 -0700 | [diff] [blame^] | 93 | private static final String KEY_CREDENTIALS_MANAGER = "credentials_management"; |
rich cannings | bfbdcef | 2012-09-09 12:48:50 -0700 | [diff] [blame] | 94 | private static final String PACKAGE_MIME_TYPE = "application/vnd.android.package-archive"; |
Jim Miller | 47d380f | 2010-01-20 13:37:14 -0800 | [diff] [blame] | 95 | |
Dianne Hackborn | abc3dc6 | 2010-01-20 13:40:19 -0800 | [diff] [blame] | 96 | DevicePolicyManager mDPM; |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 97 | |
Jim Miller | 00d2476 | 2009-12-22 19:04:57 -0800 | [diff] [blame] | 98 | private ChooseLockSettingsHelper mChooseLockSettingsHelper; |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 99 | private Preference mUserSelectedWidget; |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 100 | private LockPatternUtils mLockPatternUtils; |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 101 | private ListPreference mLockAfter; |
Jim Miller | 36972bb | 2010-11-30 19:47:38 -0800 | [diff] [blame] | 102 | |
Danielle Millett | 4a3e40d | 2012-06-06 13:54:11 -0400 | [diff] [blame] | 103 | private CheckBoxPreference mBiometricWeakLiveliness; |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 104 | private CheckBoxPreference mVisiblePattern; |
| 105 | private CheckBoxPreference mTactileFeedback; |
| 106 | |
| 107 | private CheckBoxPreference mShowPassword; |
| 108 | |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 109 | private Preference mResetCredentials; |
Mike Lockwood | 5ed2c4a | 2009-06-07 23:07:20 -0400 | [diff] [blame] | 110 | |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 111 | private CheckBoxPreference mToggleAppInstallation; |
| 112 | private DialogInterface mWarnInstallApps; |
rich cannings | d5d6065 | 2012-09-07 13:20:44 -0700 | [diff] [blame] | 113 | private CheckBoxPreference mToggleVerifyApps; |
Jim Miller | 071742d | 2012-01-06 18:28:09 -0800 | [diff] [blame] | 114 | private CheckBoxPreference mPowerButtonInstantlyLocks; |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 115 | |
Amith Yamasani | 7fb4f85 | 2012-09-25 22:17:33 -0700 | [diff] [blame^] | 116 | private boolean mIsPrimary; |
| 117 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 118 | @Override |
Amith Yamasani | d799347 | 2010-08-18 13:59:28 -0700 | [diff] [blame] | 119 | public void onCreate(Bundle savedInstanceState) { |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 120 | super.onCreate(savedInstanceState); |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 121 | |
Amith Yamasani | d799347 | 2010-08-18 13:59:28 -0700 | [diff] [blame] | 122 | mLockPatternUtils = new LockPatternUtils(getActivity()); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 123 | |
Dianne Hackborn | abc3dc6 | 2010-01-20 13:40:19 -0800 | [diff] [blame] | 124 | mDPM = (DevicePolicyManager)getSystemService(Context.DEVICE_POLICY_SERVICE); |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 125 | |
Amith Yamasani | d799347 | 2010-08-18 13:59:28 -0700 | [diff] [blame] | 126 | mChooseLockSettingsHelper = new ChooseLockSettingsHelper(getActivity()); |
Amith Yamasani | 02cf71a | 2010-09-21 15:48:52 -0700 | [diff] [blame] | 127 | } |
Mike Lockwood | 5ed2c4a | 2009-06-07 23:07:20 -0400 | [diff] [blame] | 128 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 129 | private PreferenceScreen createPreferenceHierarchy() { |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 130 | PreferenceScreen root = getPreferenceScreen(); |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 131 | if (root != null) { |
| 132 | root.removeAll(); |
| 133 | } |
| 134 | addPreferencesFromResource(R.xml.security_settings); |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 135 | root = getPreferenceScreen(); |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 136 | |
Jim Miller | 36972bb | 2010-11-30 19:47:38 -0800 | [diff] [blame] | 137 | // Add options for lock/unlock screen |
| 138 | int resid = 0; |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 139 | if (!mLockPatternUtils.isSecure()) { |
Jim Miller | 36972bb | 2010-11-30 19:47:38 -0800 | [diff] [blame] | 140 | if (mLockPatternUtils.isLockScreenDisabled()) { |
| 141 | resid = R.xml.security_settings_lockscreen; |
| 142 | } else { |
| 143 | resid = R.xml.security_settings_chooser; |
| 144 | } |
Danielle Millett | 0fb158a | 2011-09-30 13:49:14 -0400 | [diff] [blame] | 145 | } else if (mLockPatternUtils.usingBiometricWeak() && |
| 146 | mLockPatternUtils.isBiometricWeakInstalled()) { |
Jim Miller | 5541a86 | 2011-09-02 17:33:53 -0700 | [diff] [blame] | 147 | resid = R.xml.security_settings_biometric_weak; |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 148 | } else { |
Jim Miller | af366a3 | 2010-03-25 18:45:22 -0700 | [diff] [blame] | 149 | switch (mLockPatternUtils.getKeyguardStoredPasswordQuality()) { |
| 150 | case DevicePolicyManager.PASSWORD_QUALITY_SOMETHING: |
Jim Miller | 36972bb | 2010-11-30 19:47:38 -0800 | [diff] [blame] | 151 | resid = R.xml.security_settings_pattern; |
Jim Miller | af366a3 | 2010-03-25 18:45:22 -0700 | [diff] [blame] | 152 | break; |
| 153 | case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC: |
Jim Miller | 36972bb | 2010-11-30 19:47:38 -0800 | [diff] [blame] | 154 | resid = R.xml.security_settings_pin; |
Jim Miller | af366a3 | 2010-03-25 18:45:22 -0700 | [diff] [blame] | 155 | break; |
| 156 | case DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC: |
| 157 | case DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC: |
Konstantin Lopyrev | 57fbf69 | 2010-05-27 16:01:41 -0700 | [diff] [blame] | 158 | case DevicePolicyManager.PASSWORD_QUALITY_COMPLEX: |
Jim Miller | 36972bb | 2010-11-30 19:47:38 -0800 | [diff] [blame] | 159 | resid = R.xml.security_settings_password; |
Jim Miller | af366a3 | 2010-03-25 18:45:22 -0700 | [diff] [blame] | 160 | break; |
Jim Miller | 00d2476 | 2009-12-22 19:04:57 -0800 | [diff] [blame] | 161 | } |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 162 | } |
Jim Miller | 36972bb | 2010-11-30 19:47:38 -0800 | [diff] [blame] | 163 | addPreferencesFromResource(resid); |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 164 | |
Jason parks | 4112199 | 2011-01-25 09:26:55 -0600 | [diff] [blame] | 165 | |
| 166 | // Add options for device encryption |
Jason parks | f821730 | 2011-01-26 13:11:42 -0600 | [diff] [blame] | 167 | DevicePolicyManager dpm = |
| 168 | (DevicePolicyManager) getSystemService(Context.DEVICE_POLICY_SERVICE); |
Jason parks | 4112199 | 2011-01-25 09:26:55 -0600 | [diff] [blame] | 169 | |
Amith Yamasani | 7fb4f85 | 2012-09-25 22:17:33 -0700 | [diff] [blame^] | 170 | mIsPrimary = UserHandle.myUserId() == UserHandle.USER_OWNER; |
| 171 | |
| 172 | if (mIsPrimary) { |
Amith Yamasani | b810a0d | 2012-03-25 10:12:26 -0700 | [diff] [blame] | 173 | switch (dpm.getStorageEncryptionStatus()) { |
| 174 | case DevicePolicyManager.ENCRYPTION_STATUS_ACTIVE: |
| 175 | // The device is currently encrypted. |
| 176 | addPreferencesFromResource(R.xml.security_settings_encrypted); |
| 177 | break; |
| 178 | case DevicePolicyManager.ENCRYPTION_STATUS_INACTIVE: |
| 179 | // This device supports encryption but isn't encrypted. |
| 180 | addPreferencesFromResource(R.xml.security_settings_unencrypted); |
| 181 | break; |
| 182 | } |
Jason parks | 4112199 | 2011-01-25 09:26:55 -0600 | [diff] [blame] | 183 | } |
| 184 | |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 185 | // lock after preference |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 186 | mLockAfter = (ListPreference) root.findPreference(KEY_LOCK_AFTER_TIMEOUT); |
| 187 | if (mLockAfter != null) { |
| 188 | setupLockAfterPreference(); |
| 189 | updateLockAfterPreferenceSummary(); |
| 190 | } |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 191 | |
Danielle Millett | a87a25b | 2012-03-19 18:05:26 -0400 | [diff] [blame] | 192 | // biometric weak liveliness |
| 193 | mBiometricWeakLiveliness = |
Danielle Millett | 4a3e40d | 2012-06-06 13:54:11 -0400 | [diff] [blame] | 194 | (CheckBoxPreference) root.findPreference(KEY_BIOMETRIC_WEAK_LIVELINESS); |
Danielle Millett | a87a25b | 2012-03-19 18:05:26 -0400 | [diff] [blame] | 195 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 196 | // visible pattern |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 197 | mVisiblePattern = (CheckBoxPreference) root.findPreference(KEY_VISIBLE_PATTERN); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 198 | |
Jim Miller | 071742d | 2012-01-06 18:28:09 -0800 | [diff] [blame] | 199 | // lock instantly on power key press |
| 200 | mPowerButtonInstantlyLocks = (CheckBoxPreference) root.findPreference( |
| 201 | KEY_POWER_INSTANTLY_LOCKS); |
| 202 | |
Danielle Millett | 8123493 | 2011-10-19 13:58:30 -0400 | [diff] [blame] | 203 | // don't display visible pattern if biometric and backup is not pattern |
| 204 | if (resid == R.xml.security_settings_biometric_weak && |
| 205 | mLockPatternUtils.getKeyguardStoredPasswordQuality() != |
| 206 | DevicePolicyManager.PASSWORD_QUALITY_SOMETHING) { |
| 207 | PreferenceGroup securityCategory = (PreferenceGroup) |
| 208 | root.findPreference(KEY_SECURITY_CATEGORY); |
| 209 | if (securityCategory != null && mVisiblePattern != null) { |
| 210 | securityCategory.removePreference(root.findPreference(KEY_VISIBLE_PATTERN)); |
| 211 | } |
| 212 | } |
| 213 | |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 214 | // tactile feedback. Should be common to all unlock preference screens. |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 215 | mTactileFeedback = (CheckBoxPreference) root.findPreference(KEY_TACTILE_FEEDBACK_ENABLED); |
Amith Yamasani | edac9af | 2010-11-17 09:08:21 -0800 | [diff] [blame] | 216 | if (!((Vibrator) getSystemService(Context.VIBRATOR_SERVICE)).hasVibrator()) { |
| 217 | PreferenceGroup securityCategory = (PreferenceGroup) |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 218 | root.findPreference(KEY_SECURITY_CATEGORY); |
Amith Yamasani | edac9af | 2010-11-17 09:08:21 -0800 | [diff] [blame] | 219 | if (securityCategory != null && mTactileFeedback != null) { |
| 220 | securityCategory.removePreference(mTactileFeedback); |
| 221 | } |
| 222 | } |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 223 | |
Michael Jurka | 091477b | 2012-09-20 19:03:35 -0700 | [diff] [blame] | 224 | mUserSelectedWidget = root.findPreference(KEY_CHOOSE_LOCKSCREEN_STATUS_WIDGET); |
| 225 | if (mUserSelectedWidget != null) { |
| 226 | AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(getActivity()); |
| 227 | int appWidgetId = getStatusAppWidgetId(); |
| 228 | if (appWidgetId == -1) { |
| 229 | mUserSelectedWidget.setSummary(getResources().getString(R.string.widget_default)); |
| 230 | } else { |
| 231 | AppWidgetProviderInfo appWidget = appWidgetManager.getAppWidgetInfo(appWidgetId); |
| 232 | if (appWidget != null) { |
| 233 | mUserSelectedWidget.setSummary(appWidget.label); |
| 234 | } |
| 235 | } |
| 236 | } |
| 237 | |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 238 | mUserSelectedWidget = root.findPreference(KEY_CHOOSE_USER_SELECTED_LOCKSCREEN_WIDGET); |
Michael Jurka | ce72ec7 | 2012-09-14 14:09:16 -0700 | [diff] [blame] | 239 | if (mUserSelectedWidget != null) { |
| 240 | AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(getActivity()); |
Michael Jurka | 3028051 | 2012-09-17 17:46:49 -0700 | [diff] [blame] | 241 | int appWidgetId = getUserSelectedAppWidgetId(); |
Michael Jurka | ce72ec7 | 2012-09-14 14:09:16 -0700 | [diff] [blame] | 242 | if (appWidgetId == -1) { |
| 243 | mUserSelectedWidget.setSummary(getResources().getString(R.string.widget_none)); |
| 244 | } else { |
| 245 | AppWidgetProviderInfo appWidget = appWidgetManager.getAppWidgetInfo(appWidgetId); |
| 246 | if (appWidget != null) { |
| 247 | mUserSelectedWidget.setSummary(appWidget.label); |
| 248 | } |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 249 | } |
| 250 | } |
| 251 | |
Amith Yamasani | 7fb4f85 | 2012-09-25 22:17:33 -0700 | [diff] [blame^] | 252 | // Append the rest of the settings |
| 253 | addPreferencesFromResource(R.xml.security_settings_misc); |
| 254 | |
| 255 | // Do not display SIM lock for devices without an Icc card |
| 256 | TelephonyManager tm = TelephonyManager.getDefault(); |
| 257 | if (!mIsPrimary || !tm.hasIccCard()) { |
| 258 | root.removePreference(root.findPreference(KEY_SIM_LOCK)); |
| 259 | } else { |
| 260 | // Disable SIM lock if sim card is missing or unknown |
| 261 | if ((TelephonyManager.getDefault().getSimState() == |
| 262 | TelephonyManager.SIM_STATE_ABSENT) || |
| 263 | (TelephonyManager.getDefault().getSimState() == |
| 264 | TelephonyManager.SIM_STATE_UNKNOWN)) { |
| 265 | root.findPreference(KEY_SIM_LOCK).setEnabled(false); |
| 266 | } |
| 267 | } |
| 268 | |
| 269 | // Show password |
| 270 | mShowPassword = (CheckBoxPreference) root.findPreference(KEY_SHOW_PASSWORD); |
| 271 | |
| 272 | // Credential storage, only for primary user |
| 273 | if (mIsPrimary) { |
| 274 | mResetCredentials = root.findPreference(KEY_RESET_CREDENTIALS); |
| 275 | } else { |
| 276 | removePreference(KEY_CREDENTIALS_MANAGER); |
| 277 | } |
| 278 | |
| 279 | mToggleAppInstallation = (CheckBoxPreference) findPreference( |
| 280 | KEY_TOGGLE_INSTALL_APPLICATIONS); |
| 281 | mToggleAppInstallation.setChecked(isNonMarketAppsAllowed()); |
| 282 | |
| 283 | // Package verification, only visible to primary user and if enabled |
| 284 | mToggleVerifyApps = (CheckBoxPreference) findPreference(KEY_TOGGLE_VERIFY_APPLICATIONS); |
| 285 | if (mIsPrimary && showVerifierSetting()) { |
| 286 | if (isVerifierInstalled()) { |
| 287 | mToggleVerifyApps.setChecked(isVerifyAppsEnabled()); |
| 288 | } else { |
| 289 | mToggleVerifyApps.setChecked(false); |
| 290 | mToggleVerifyApps.setEnabled(false); |
| 291 | } |
| 292 | } else if (mToggleVerifyApps != null) { |
| 293 | mToggleVerifyApps.setEnabled(false); |
| 294 | } |
| 295 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 296 | return root; |
| 297 | } |
| 298 | |
Michael Jurka | 091477b | 2012-09-20 19:03:35 -0700 | [diff] [blame] | 299 | private int getStatusAppWidgetId() { |
| 300 | int appWidgetId = -1; |
| 301 | String appWidgetIdString = Settings.Secure.getString( |
| 302 | getContentResolver(), Settings.Secure.LOCK_SCREEN_STATUS_APPWIDGET_ID); |
| 303 | if (appWidgetIdString != null) {; |
| 304 | appWidgetId = (int) Integer.decode(appWidgetIdString); |
| 305 | } |
| 306 | return appWidgetId; |
| 307 | } |
| 308 | |
Michael Jurka | 3028051 | 2012-09-17 17:46:49 -0700 | [diff] [blame] | 309 | private int getUserSelectedAppWidgetId() { |
| 310 | int appWidgetId = -1; |
| 311 | String appWidgetIdString = Settings.Secure.getString( |
| 312 | getContentResolver(), Settings.Secure.LOCK_SCREEN_USER_SELECTED_APPWIDGET_ID); |
| 313 | if (appWidgetIdString != null) {; |
| 314 | appWidgetId = (int) Integer.decode(appWidgetIdString); |
| 315 | } |
| 316 | return appWidgetId; |
| 317 | } |
| 318 | |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 319 | private boolean isNonMarketAppsAllowed() { |
Christopher Tate | 5a64c73 | 2012-09-07 13:35:31 -0700 | [diff] [blame] | 320 | return Settings.Global.getInt(getContentResolver(), |
| 321 | Settings.Global.INSTALL_NON_MARKET_APPS, 0) > 0; |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 322 | } |
| 323 | |
| 324 | private void setNonMarketAppsAllowed(boolean enabled) { |
| 325 | // Change the system setting |
Christopher Tate | 5a64c73 | 2012-09-07 13:35:31 -0700 | [diff] [blame] | 326 | Settings.Global.putInt(getContentResolver(), Settings.Global.INSTALL_NON_MARKET_APPS, |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 327 | enabled ? 1 : 0); |
| 328 | } |
| 329 | |
rich cannings | d5d6065 | 2012-09-07 13:20:44 -0700 | [diff] [blame] | 330 | private boolean isVerifyAppsEnabled() { |
| 331 | return Settings.Global.getInt(getContentResolver(), |
| 332 | Settings.Global.PACKAGE_VERIFIER_ENABLE, 1) > 0; |
| 333 | } |
| 334 | |
rich cannings | bfbdcef | 2012-09-09 12:48:50 -0700 | [diff] [blame] | 335 | private boolean isVerifierInstalled() { |
| 336 | final PackageManager pm = getPackageManager(); |
| 337 | final Intent verification = new Intent(Intent.ACTION_PACKAGE_NEEDS_VERIFICATION); |
| 338 | verification.setType(PACKAGE_MIME_TYPE); |
| 339 | verification.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); |
| 340 | final List<ResolveInfo> receivers = pm.queryBroadcastReceivers(verification, 0); |
| 341 | return (receivers.size() > 0) ? true : false; |
| 342 | } |
| 343 | |
rich cannings | bbc3045 | 2012-09-16 13:58:07 -0700 | [diff] [blame] | 344 | private boolean showVerifierSetting() { |
| 345 | return Settings.Global.getInt(getContentResolver(), |
| 346 | Settings.Global.PACKAGE_VERIFIER_SETTING_VISIBLE, 1) > 0; |
| 347 | } |
| 348 | |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 349 | private void warnAppInstallation() { |
| 350 | // TODO: DialogFragment? |
| 351 | mWarnInstallApps = new AlertDialog.Builder(getActivity()).setTitle( |
| 352 | getResources().getString(R.string.error_title)) |
| 353 | .setIcon(com.android.internal.R.drawable.ic_dialog_alert) |
| 354 | .setMessage(getResources().getString(R.string.install_all_warning)) |
| 355 | .setPositiveButton(android.R.string.yes, this) |
| 356 | .setNegativeButton(android.R.string.no, null) |
| 357 | .show(); |
| 358 | } |
| 359 | |
| 360 | public void onClick(DialogInterface dialog, int which) { |
| 361 | if (dialog == mWarnInstallApps && which == DialogInterface.BUTTON_POSITIVE) { |
| 362 | setNonMarketAppsAllowed(true); |
Amith Yamasani | b810a0d | 2012-03-25 10:12:26 -0700 | [diff] [blame] | 363 | if (mToggleAppInstallation != null) { |
| 364 | mToggleAppInstallation.setChecked(true); |
| 365 | } |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 366 | } |
| 367 | } |
| 368 | |
| 369 | @Override |
| 370 | public void onDestroy() { |
| 371 | super.onDestroy(); |
| 372 | if (mWarnInstallApps != null) { |
| 373 | mWarnInstallApps.dismiss(); |
| 374 | } |
| 375 | } |
| 376 | |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 377 | private void setupLockAfterPreference() { |
| 378 | // Compatible with pre-Froyo |
| 379 | long currentTimeout = Settings.Secure.getLong(getContentResolver(), |
| 380 | Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT, 5000); |
| 381 | mLockAfter.setValue(String.valueOf(currentTimeout)); |
| 382 | mLockAfter.setOnPreferenceChangeListener(this); |
| 383 | final long adminTimeout = (mDPM != null ? mDPM.getMaximumTimeToLock(null) : 0); |
| 384 | final long displayTimeout = Math.max(0, |
| 385 | Settings.System.getInt(getContentResolver(), SCREEN_OFF_TIMEOUT, 0)); |
| 386 | if (adminTimeout > 0) { |
| 387 | // This setting is a slave to display timeout when a device policy is enforced. |
| 388 | // As such, maxLockTimeout = adminTimeout - displayTimeout. |
| 389 | // If there isn't enough time, shows "immediately" setting. |
| 390 | disableUnusableTimeouts(Math.max(0, adminTimeout - displayTimeout)); |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 391 | } |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 392 | } |
| 393 | |
Jim Miller | c978707 | 2011-01-09 18:00:28 -0800 | [diff] [blame] | 394 | private void updateLockAfterPreferenceSummary() { |
Jim Miller | c978707 | 2011-01-09 18:00:28 -0800 | [diff] [blame] | 395 | // Update summary message with current value |
| 396 | long currentTimeout = Settings.Secure.getLong(getContentResolver(), |
Amith Yamasani | 58bca8f | 2011-07-22 12:16:16 -0700 | [diff] [blame] | 397 | Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT, 5000); |
Jim Miller | c978707 | 2011-01-09 18:00:28 -0800 | [diff] [blame] | 398 | final CharSequence[] entries = mLockAfter.getEntries(); |
| 399 | final CharSequence[] values = mLockAfter.getEntryValues(); |
| 400 | int best = 0; |
| 401 | for (int i = 0; i < values.length; i++) { |
| 402 | long timeout = Long.valueOf(values[i].toString()); |
| 403 | if (currentTimeout >= timeout) { |
| 404 | best = i; |
| 405 | } |
| 406 | } |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 407 | mLockAfter.setSummary(getString(R.string.lock_after_timeout_summary, entries[best])); |
Jim Miller | c978707 | 2011-01-09 18:00:28 -0800 | [diff] [blame] | 408 | } |
| 409 | |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 410 | private void disableUnusableTimeouts(long maxTimeout) { |
| 411 | final CharSequence[] entries = mLockAfter.getEntries(); |
| 412 | final CharSequence[] values = mLockAfter.getEntryValues(); |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 413 | ArrayList<CharSequence> revisedEntries = new ArrayList<CharSequence>(); |
| 414 | ArrayList<CharSequence> revisedValues = new ArrayList<CharSequence>(); |
| 415 | for (int i = 0; i < values.length; i++) { |
| 416 | long timeout = Long.valueOf(values[i].toString()); |
| 417 | if (timeout <= maxTimeout) { |
| 418 | revisedEntries.add(entries[i]); |
| 419 | revisedValues.add(values[i]); |
| 420 | } |
| 421 | } |
| 422 | if (revisedEntries.size() != entries.length || revisedValues.size() != values.length) { |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 423 | mLockAfter.setEntries( |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 424 | revisedEntries.toArray(new CharSequence[revisedEntries.size()])); |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 425 | mLockAfter.setEntryValues( |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 426 | revisedValues.toArray(new CharSequence[revisedValues.size()])); |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 427 | final int userPreference = Integer.valueOf(mLockAfter.getValue()); |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 428 | if (userPreference <= maxTimeout) { |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 429 | mLockAfter.setValue(String.valueOf(userPreference)); |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 430 | } else { |
| 431 | // There will be no highlighted selection since nothing in the list matches |
| 432 | // maxTimeout. The user can still select anything less than maxTimeout. |
| 433 | // TODO: maybe append maxTimeout to the list and mark selected. |
| 434 | } |
| 435 | } |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 436 | mLockAfter.setEnabled(revisedEntries.size() > 0); |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 437 | } |
| 438 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 439 | @Override |
Amith Yamasani | d799347 | 2010-08-18 13:59:28 -0700 | [diff] [blame] | 440 | public void onResume() { |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 441 | super.onResume(); |
| 442 | |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 443 | // Make sure we reload the preference hierarchy since some of these settings |
| 444 | // depend on others... |
| 445 | createPreferenceHierarchy(); |
| 446 | |
Jim Miller | 00d2476 | 2009-12-22 19:04:57 -0800 | [diff] [blame] | 447 | final LockPatternUtils lockPatternUtils = mChooseLockSettingsHelper.utils(); |
Danielle Millett | a87a25b | 2012-03-19 18:05:26 -0400 | [diff] [blame] | 448 | if (mBiometricWeakLiveliness != null) { |
Danielle Millett | 4a3e40d | 2012-06-06 13:54:11 -0400 | [diff] [blame] | 449 | mBiometricWeakLiveliness.setChecked( |
| 450 | lockPatternUtils.isBiometricWeakLivelinessEnabled()); |
Danielle Millett | a87a25b | 2012-03-19 18:05:26 -0400 | [diff] [blame] | 451 | } |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 452 | if (mVisiblePattern != null) { |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 453 | mVisiblePattern.setChecked(lockPatternUtils.isVisiblePatternEnabled()); |
| 454 | } |
| 455 | if (mTactileFeedback != null) { |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 456 | mTactileFeedback.setChecked(lockPatternUtils.isTactileFeedbackEnabled()); |
| 457 | } |
Jim Miller | 071742d | 2012-01-06 18:28:09 -0800 | [diff] [blame] | 458 | if (mPowerButtonInstantlyLocks != null) { |
| 459 | mPowerButtonInstantlyLocks.setChecked(lockPatternUtils.getPowerButtonInstantlyLocks()); |
| 460 | } |
Hung-ying Tyan | 7031ab0 | 2009-07-02 00:26:46 +0800 | [diff] [blame] | 461 | |
Amith Yamasani | b810a0d | 2012-03-25 10:12:26 -0700 | [diff] [blame] | 462 | if (mShowPassword != null) { |
| 463 | mShowPassword.setChecked(Settings.System.getInt(getContentResolver(), |
| 464 | Settings.System.TEXT_SHOW_PASSWORD, 1) != 0); |
| 465 | } |
Hung-ying Tyan | b0883cb | 2009-09-30 11:56:05 +0800 | [diff] [blame] | 466 | |
Brian Carlstrom | d4023b7 | 2011-05-25 13:24:20 -0700 | [diff] [blame] | 467 | KeyStore.State state = KeyStore.getInstance().state(); |
Amith Yamasani | b810a0d | 2012-03-25 10:12:26 -0700 | [diff] [blame] | 468 | if (mResetCredentials != null) { |
| 469 | mResetCredentials.setEnabled(state != KeyStore.State.UNINITIALIZED); |
| 470 | } |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 471 | } |
| 472 | |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 473 | void startActivityForResultSafely(Intent intent, int requestCode) { |
| 474 | try { |
| 475 | startActivityForResult(intent, requestCode); |
| 476 | } catch (ActivityNotFoundException e) { |
| 477 | Toast.makeText(getActivity(), R.string.activity_not_found, Toast.LENGTH_SHORT).show(); |
| 478 | } catch (SecurityException e) { |
| 479 | Toast.makeText(getActivity(), R.string.activity_not_found, Toast.LENGTH_SHORT).show(); |
| 480 | Log.e(TAG, "Settings does not have the permission to launch " + intent, e); |
| 481 | } |
| 482 | } |
| 483 | |
Michael Jurka | 16398c9 | 2012-09-24 17:30:17 -0700 | [diff] [blame] | 484 | private void launchPickActivityIntent(int featuresFilter, int defaultLabelId, int defaultIconId, |
| 485 | ComponentName defaultComponentName, String defaultTag) { |
| 486 | // Create intent to pick widget |
| 487 | Intent pickIntent = new Intent(AppWidgetManager.ACTION_APPWIDGET_PICK); |
| 488 | |
| 489 | // Found in KeyguardHostView.java |
| 490 | final int KEYGUARD_HOST_ID = 0x4B455947; |
| 491 | int appWidgetId = AppWidgetHost.allocateAppWidgetIdForSystem(KEYGUARD_HOST_ID); |
| 492 | if (appWidgetId != -1) { |
| 493 | pickIntent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId); |
| 494 | pickIntent.putExtra(AppWidgetManager.EXTRA_CUSTOM_SORT, false); |
| 495 | pickIntent.putExtra(AppWidgetManager.EXTRA_CATEGORY_FILTER, |
| 496 | AppWidgetProviderInfo.WIDGET_CATEGORY_KEYGUARD); |
| 497 | if (featuresFilter != AppWidgetProviderInfo.WIDGET_FEATURES_NONE) { |
| 498 | pickIntent.putExtra(AppWidgetManager.EXTRA_FEATURES_FILTER, featuresFilter); |
| 499 | } |
| 500 | |
| 501 | // Add an entry for "none" to let someone select no widget |
| 502 | AppWidgetProviderInfo defaultInfo = new AppWidgetProviderInfo(); |
| 503 | ArrayList<AppWidgetProviderInfo> extraInfos = new ArrayList<AppWidgetProviderInfo>(); |
| 504 | defaultInfo.label = getResources().getString(defaultLabelId); |
| 505 | defaultInfo.icon = defaultIconId; |
| 506 | defaultInfo.provider = defaultComponentName; |
| 507 | extraInfos.add(defaultInfo); |
| 508 | |
| 509 | ArrayList<Bundle> extraExtras = new ArrayList<Bundle>(); |
| 510 | Bundle b = new Bundle(); |
| 511 | b.putBoolean(defaultTag, true); |
| 512 | extraExtras.add(b); |
| 513 | |
| 514 | // Launch the widget picker |
| 515 | pickIntent.putExtra(AppWidgetManager.EXTRA_CUSTOM_INFO, extraInfos); |
| 516 | pickIntent.putExtra(AppWidgetManager.EXTRA_CUSTOM_EXTRAS, extraExtras); |
| 517 | pickIntent.putExtra(Intent.EXTRA_INTENT, getBaseIntent()); |
| 518 | startActivityForResult(pickIntent, REQUEST_PICK_USER_SELECTED_APPWIDGET); |
| 519 | } else { |
| 520 | Log.e(TAG, "Unable to allocate an AppWidget id in lock screen"); |
| 521 | } |
| 522 | } |
| 523 | |
Adam Cohen | 85d4b5f | 2012-09-24 13:15:14 -0700 | [diff] [blame] | 524 | private Intent getBaseIntent() { |
| 525 | Intent baseIntent = new Intent(Intent.ACTION_MAIN, null); |
| 526 | baseIntent.addCategory(Intent.CATEGORY_DEFAULT); |
| 527 | |
| 528 | Bundle options = new Bundle(); |
| 529 | options.putInt(AppWidgetManager.OPTION_APPWIDGET_HOST_CATEGORY, |
| 530 | AppWidgetProviderInfo.WIDGET_CATEGORY_KEYGUARD); |
| 531 | baseIntent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_OPTIONS, options); |
| 532 | return baseIntent; |
| 533 | } |
| 534 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 535 | @Override |
Gilles Debunne | a6a8a14 | 2011-06-09 11:56:17 -0700 | [diff] [blame] | 536 | public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) { |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 537 | final String key = preference.getKey(); |
| 538 | |
Jim Miller | 00d2476 | 2009-12-22 19:04:57 -0800 | [diff] [blame] | 539 | final LockPatternUtils lockPatternUtils = mChooseLockSettingsHelper.utils(); |
Jim Miller | bbb4afa | 2010-04-08 19:40:19 -0700 | [diff] [blame] | 540 | if (KEY_UNLOCK_SET_OR_CHANGE.equals(key)) { |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 541 | startFragment(this, "com.android.settings.ChooseLockGeneric$ChooseLockGenericFragment", |
| 542 | SET_OR_CHANGE_LOCK_METHOD_REQUEST, null); |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 543 | } else if (KEY_CHOOSE_USER_SELECTED_LOCKSCREEN_WIDGET.equals(key)) { |
Michael Jurka | 16398c9 | 2012-09-24 17:30:17 -0700 | [diff] [blame] | 544 | launchPickActivityIntent(AppWidgetProviderInfo.WIDGET_FEATURES_NONE, |
| 545 | R.string.widget_none, 0, new ComponentName("", ""), EXTRA_NO_WIDGET); |
Michael Jurka | 091477b | 2012-09-20 19:03:35 -0700 | [diff] [blame] | 546 | } else if (KEY_CHOOSE_LOCKSCREEN_STATUS_WIDGET.equals(key)) { |
Michael Jurka | 16398c9 | 2012-09-24 17:30:17 -0700 | [diff] [blame] | 547 | int defaultIconId; |
| 548 | ComponentName clock = new ComponentName( |
| 549 | "com.google.android.deskclock", "com.android.deskclock.DeskClock"); |
| 550 | try { |
| 551 | defaultIconId = getActivity().getPackageManager().getActivityInfo(clock, 0).icon; |
| 552 | } catch (PackageManager.NameNotFoundException e) { |
| 553 | defaultIconId = 0; |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 554 | } |
Michael Jurka | 16398c9 | 2012-09-24 17:30:17 -0700 | [diff] [blame] | 555 | launchPickActivityIntent(AppWidgetProviderInfo.WIDGET_FEATURES_STATUS, |
| 556 | R.string.widget_default, defaultIconId, clock, EXTRA_DEFAULT_WIDGET); |
Danielle Millett | 487b16f | 2011-11-02 11:12:21 -0400 | [diff] [blame] | 557 | } else if (KEY_BIOMETRIC_WEAK_IMPROVE_MATCHING.equals(key)) { |
| 558 | ChooseLockSettingsHelper helper = |
| 559 | new ChooseLockSettingsHelper(this.getActivity(), this); |
| 560 | if (!helper.launchConfirmationActivity( |
Danielle Millett | 790e0c3 | 2012-03-23 15:17:50 -0400 | [diff] [blame] | 561 | CONFIRM_EXISTING_FOR_BIOMETRIC_WEAK_IMPROVE_REQUEST, null, null)) { |
| 562 | // If this returns false, it means no password confirmation is required, so |
| 563 | // go ahead and start improve. |
| 564 | // Note: currently a backup is required for biometric_weak so this code path |
| 565 | // can't be reached, but is here in case things change in the future |
| 566 | startBiometricWeakImprove(); |
Danielle Millett | 487b16f | 2011-11-02 11:12:21 -0400 | [diff] [blame] | 567 | } |
Danielle Millett | 4a3e40d | 2012-06-06 13:54:11 -0400 | [diff] [blame] | 568 | } else if (KEY_BIOMETRIC_WEAK_LIVELINESS.equals(key)) { |
| 569 | if (isToggled(preference)) { |
| 570 | lockPatternUtils.setBiometricWeakLivelinessEnabled(true); |
| 571 | } else { |
| 572 | // In this case the user has just unchecked the checkbox, but this action requires |
| 573 | // them to confirm their password. We need to re-check the checkbox until |
| 574 | // they've confirmed their password |
| 575 | mBiometricWeakLiveliness.setChecked(true); |
| 576 | ChooseLockSettingsHelper helper = |
| 577 | new ChooseLockSettingsHelper(this.getActivity(), this); |
| 578 | if (!helper.launchConfirmationActivity( |
| 579 | CONFIRM_EXISTING_FOR_BIOMETRIC_WEAK_LIVELINESS_OFF, null, null)) { |
| 580 | // If this returns false, it means no password confirmation is required, so |
| 581 | // go ahead and uncheck it here. |
| 582 | // Note: currently a backup is required for biometric_weak so this code path |
| 583 | // can't be reached, but is here in case things change in the future |
| 584 | lockPatternUtils.setBiometricWeakLivelinessEnabled(false); |
| 585 | mBiometricWeakLiveliness.setChecked(false); |
| 586 | } |
| 587 | } |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 588 | } else if (KEY_LOCK_ENABLED.equals(key)) { |
Jim Miller | 00d2476 | 2009-12-22 19:04:57 -0800 | [diff] [blame] | 589 | lockPatternUtils.setLockPatternEnabled(isToggled(preference)); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 590 | } else if (KEY_VISIBLE_PATTERN.equals(key)) { |
Jim Miller | 00d2476 | 2009-12-22 19:04:57 -0800 | [diff] [blame] | 591 | lockPatternUtils.setVisiblePatternEnabled(isToggled(preference)); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 592 | } else if (KEY_TACTILE_FEEDBACK_ENABLED.equals(key)) { |
Jim Miller | 00d2476 | 2009-12-22 19:04:57 -0800 | [diff] [blame] | 593 | lockPatternUtils.setTactileFeedbackEnabled(isToggled(preference)); |
Jim Miller | 071742d | 2012-01-06 18:28:09 -0800 | [diff] [blame] | 594 | } else if (KEY_POWER_INSTANTLY_LOCKS.equals(key)) { |
| 595 | lockPatternUtils.setPowerButtonInstantlyLocks(isToggled(preference)); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 596 | } else if (preference == mShowPassword) { |
| 597 | Settings.System.putInt(getContentResolver(), Settings.System.TEXT_SHOW_PASSWORD, |
| 598 | mShowPassword.isChecked() ? 1 : 0); |
Gilles Debunne | 2c88a87 | 2011-06-21 12:47:17 -0700 | [diff] [blame] | 599 | } else if (preference == mToggleAppInstallation) { |
| 600 | if (mToggleAppInstallation.isChecked()) { |
| 601 | mToggleAppInstallation.setChecked(false); |
| 602 | warnAppInstallation(); |
| 603 | } else { |
| 604 | setNonMarketAppsAllowed(false); |
| 605 | } |
rich cannings | d5d6065 | 2012-09-07 13:20:44 -0700 | [diff] [blame] | 606 | } else if (KEY_TOGGLE_VERIFY_APPLICATIONS.equals(key)) { |
| 607 | Settings.Global.putInt(getContentResolver(), Settings.Global.PACKAGE_VERIFIER_ENABLE, |
| 608 | mToggleVerifyApps.isChecked() ? 1 : 0); |
Jim Miller | 36972bb | 2010-11-30 19:47:38 -0800 | [diff] [blame] | 609 | } else { |
| 610 | // If we didn't handle it, let preferences handle it. |
| 611 | return super.onPreferenceTreeClick(preferenceScreen, preference); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 612 | } |
Amith Yamasani | 4bfdcd3 | 2009-04-02 11:40:25 -0700 | [diff] [blame] | 613 | |
Jim Miller | 36972bb | 2010-11-30 19:47:38 -0800 | [diff] [blame] | 614 | return true; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 615 | } |
| 616 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 617 | private boolean isToggled(Preference pref) { |
| 618 | return ((CheckBoxPreference) pref).isChecked(); |
| 619 | } |
| 620 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 621 | /** |
Gilles Debunne | a6a8a14 | 2011-06-09 11:56:17 -0700 | [diff] [blame] | 622 | * see confirmPatternThenDisableAndClear |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 623 | */ |
| 624 | @Override |
Amith Yamasani | d799347 | 2010-08-18 13:59:28 -0700 | [diff] [blame] | 625 | public void onActivityResult(int requestCode, int resultCode, Intent data) { |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 626 | super.onActivityResult(requestCode, resultCode, data); |
Danielle Millett | 790e0c3 | 2012-03-23 15:17:50 -0400 | [diff] [blame] | 627 | if (requestCode == CONFIRM_EXISTING_FOR_BIOMETRIC_WEAK_IMPROVE_REQUEST && |
Danielle Millett | 487b16f | 2011-11-02 11:12:21 -0400 | [diff] [blame] | 628 | resultCode == Activity.RESULT_OK) { |
| 629 | startBiometricWeakImprove(); |
| 630 | return; |
Danielle Millett | 4a3e40d | 2012-06-06 13:54:11 -0400 | [diff] [blame] | 631 | } else if (requestCode == CONFIRM_EXISTING_FOR_BIOMETRIC_WEAK_LIVELINESS_OFF && |
| 632 | resultCode == Activity.RESULT_OK) { |
| 633 | final LockPatternUtils lockPatternUtils = mChooseLockSettingsHelper.utils(); |
| 634 | lockPatternUtils.setBiometricWeakLivelinessEnabled(false); |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 635 | // Setting the mBiometricWeakLiveliness checked value to false is handled when onResume |
| 636 | // is called by grabbing the value from lockPatternUtils. We can't set it here |
| 637 | // because mBiometricWeakLiveliness could be null |
Danielle Millett | 4a3e40d | 2012-06-06 13:54:11 -0400 | [diff] [blame] | 638 | return; |
Michael Jurka | 091477b | 2012-09-20 19:03:35 -0700 | [diff] [blame] | 639 | } else if (requestCode == REQUEST_PICK_USER_SELECTED_APPWIDGET || |
| 640 | requestCode == REQUEST_PICK_STATUS_APPWIDGET || |
| 641 | requestCode == REQUEST_CREATE_USER_SELECTED_APPWIDGET || |
| 642 | requestCode == REQUEST_CREATE_STATUS_APPWIDGET) { |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 643 | int appWidgetId = (data == null) ? -1 : data.getIntExtra( |
| 644 | AppWidgetManager.EXTRA_APPWIDGET_ID, -1); |
Michael Jurka | 091477b | 2012-09-20 19:03:35 -0700 | [diff] [blame] | 645 | if ((requestCode == REQUEST_PICK_USER_SELECTED_APPWIDGET || |
| 646 | requestCode == REQUEST_PICK_STATUS_APPWIDGET) && |
| 647 | resultCode == Activity.RESULT_OK) { |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 648 | AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(getActivity()); |
Michael Jurka | 091477b | 2012-09-20 19:03:35 -0700 | [diff] [blame] | 649 | boolean defaultOrNoWidget = data.getBooleanExtra(EXTRA_NO_WIDGET, false) || |
| 650 | data.getBooleanExtra(EXTRA_DEFAULT_WIDGET, false); |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 651 | |
| 652 | AppWidgetProviderInfo appWidget = null; |
Michael Jurka | 091477b | 2012-09-20 19:03:35 -0700 | [diff] [blame] | 653 | if (!defaultOrNoWidget) { |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 654 | appWidget = appWidgetManager.getAppWidgetInfo(appWidgetId); |
| 655 | } |
| 656 | |
Michael Jurka | 091477b | 2012-09-20 19:03:35 -0700 | [diff] [blame] | 657 | int newRequestCode = requestCode == REQUEST_PICK_USER_SELECTED_APPWIDGET ? |
| 658 | REQUEST_CREATE_USER_SELECTED_APPWIDGET : |
| 659 | REQUEST_CREATE_STATUS_APPWIDGET; |
| 660 | if (!defaultOrNoWidget && appWidget.configure != null) { |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 661 | // Launch over to configure widget, if needed |
| 662 | Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_CONFIGURE); |
| 663 | intent.setComponent(appWidget.configure); |
| 664 | intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId); |
| 665 | |
Michael Jurka | 091477b | 2012-09-20 19:03:35 -0700 | [diff] [blame] | 666 | startActivityForResultSafely(intent, newRequestCode); |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 667 | } else { |
| 668 | // Otherwise just add it |
Michael Jurka | 091477b | 2012-09-20 19:03:35 -0700 | [diff] [blame] | 669 | if (defaultOrNoWidget) { |
Michael Jurka | 3028051 | 2012-09-17 17:46:49 -0700 | [diff] [blame] | 670 | // If we selected "none", delete the allocated id |
Adam Cohen | 1dd0024 | 2012-09-18 13:26:29 -0700 | [diff] [blame] | 671 | AppWidgetHost.deleteAppWidgetIdForSystem(appWidgetId); |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 672 | data.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, -1); |
| 673 | } |
Michael Jurka | 091477b | 2012-09-20 19:03:35 -0700 | [diff] [blame] | 674 | onActivityResult(newRequestCode, Activity.RESULT_OK, data); |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 675 | } |
Michael Jurka | 091477b | 2012-09-20 19:03:35 -0700 | [diff] [blame] | 676 | } else if ((requestCode == REQUEST_CREATE_USER_SELECTED_APPWIDGET || |
| 677 | requestCode == REQUEST_CREATE_STATUS_APPWIDGET) && |
| 678 | resultCode == Activity.RESULT_OK) { |
Michael Jurka | 3028051 | 2012-09-17 17:46:49 -0700 | [diff] [blame] | 679 | // If a widget existed before, delete it |
Michael Jurka | 091477b | 2012-09-20 19:03:35 -0700 | [diff] [blame] | 680 | int oldAppWidgetId = requestCode == REQUEST_CREATE_USER_SELECTED_APPWIDGET ? |
| 681 | getUserSelectedAppWidgetId() : getStatusAppWidgetId(); |
Michael Jurka | 3028051 | 2012-09-17 17:46:49 -0700 | [diff] [blame] | 682 | if (oldAppWidgetId != -1) { |
Adam Cohen | 1dd0024 | 2012-09-18 13:26:29 -0700 | [diff] [blame] | 683 | AppWidgetHost.deleteAppWidgetIdForSystem(oldAppWidgetId); |
Michael Jurka | 3028051 | 2012-09-17 17:46:49 -0700 | [diff] [blame] | 684 | } |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 685 | Settings.Secure.putString(getContentResolver(), |
Michael Jurka | 091477b | 2012-09-20 19:03:35 -0700 | [diff] [blame] | 686 | (requestCode == REQUEST_CREATE_USER_SELECTED_APPWIDGET ? |
| 687 | Settings.Secure.LOCK_SCREEN_USER_SELECTED_APPWIDGET_ID : |
| 688 | Settings.Secure.LOCK_SCREEN_STATUS_APPWIDGET_ID), |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 689 | Integer.toString(appWidgetId)); |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 690 | } else { |
Adam Cohen | 1dd0024 | 2012-09-18 13:26:29 -0700 | [diff] [blame] | 691 | AppWidgetHost.deleteAppWidgetIdForSystem(appWidgetId); |
Michael Jurka | 8227e30 | 2012-09-07 09:24:03 -0700 | [diff] [blame] | 692 | } |
Danielle Millett | 487b16f | 2011-11-02 11:12:21 -0400 | [diff] [blame] | 693 | } |
Jim Miller | 122b6c8 | 2010-02-10 19:53:58 -0800 | [diff] [blame] | 694 | createPreferenceHierarchy(); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 695 | } |
Amith Yamasani | f06d869 | 2009-06-11 22:32:33 -0700 | [diff] [blame] | 696 | |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 697 | public boolean onPreferenceChange(Preference preference, Object value) { |
| 698 | if (preference == mLockAfter) { |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 699 | int timeout = Integer.parseInt((String) value); |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 700 | try { |
| 701 | Settings.Secure.putInt(getContentResolver(), |
Chia-chi Yeh | 91d65a2 | 2011-01-20 18:46:01 +0800 | [diff] [blame] | 702 | Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT, timeout); |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 703 | } catch (NumberFormatException e) { |
| 704 | Log.e("SecuritySettings", "could not persist lockAfter timeout setting", e); |
| 705 | } |
Jim Miller | c978707 | 2011-01-09 18:00:28 -0800 | [diff] [blame] | 706 | updateLockAfterPreferenceSummary(); |
Jim Miller | 86624a2 | 2010-08-30 22:07:58 -0700 | [diff] [blame] | 707 | } |
| 708 | return true; |
| 709 | } |
Danielle Millett | 487b16f | 2011-11-02 11:12:21 -0400 | [diff] [blame] | 710 | |
| 711 | public void startBiometricWeakImprove(){ |
| 712 | Intent intent = new Intent(); |
| 713 | intent.setClassName("com.android.facelock", "com.android.facelock.AddToSetup"); |
| 714 | startActivity(intent); |
| 715 | } |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 716 | } |