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 17package com.android.settings; 18 19import static android.provider.Settings.System.SCREEN_OFF_TIMEOUT; 20 21import static com.android.settingslib.RestrictedLockUtils.EnforcedAdmin; 22 23import android.app.Activity; 24import android.app.AlertDialog; 25import android.app.Dialog; 26import android.app.FragmentManager; 27import android.app.admin.DevicePolicyManager; 28import android.content.ComponentName; 29import android.content.Context; 30import android.content.DialogInterface; 31import android.content.Intent; 32import android.content.pm.PackageManager; 33import android.content.pm.ResolveInfo; 34import android.content.res.Resources; 35import android.hardware.fingerprint.FingerprintManager; 36import android.os.Bundle; 37import android.os.PersistableBundle; 38import android.os.UserHandle; 39import android.os.UserManager; 40import android.os.storage.StorageManager; 41import android.provider.SearchIndexableResource; 42import android.provider.Settings; 43import android.service.trust.TrustAgentService; 44import android.support.annotation.VisibleForTesting; 45import android.support.v14.preference.SwitchPreference; 46import android.support.v7.preference.Preference; 47import android.support.v7.preference.Preference.OnPreferenceChangeListener; 48import android.support.v7.preference.PreferenceGroup; 49import android.support.v7.preference.PreferenceScreen; 50import android.telephony.CarrierConfigManager; 51import android.telephony.SubscriptionInfo; 52import android.telephony.SubscriptionManager; 53import android.telephony.TelephonyManager; 54import android.text.TextUtils; 55import android.util.Log; 56 57import com.android.internal.logging.nano.MetricsProto.MetricsEvent; 58import com.android.internal.widget.LockPatternUtils; 59import com.android.settings.TrustAgentUtils.TrustAgentComponentInfo; 60import com.android.settings.core.instrumentation.InstrumentedDialogFragment; 61import com.android.settings.dashboard.DashboardFeatureProvider; 62import com.android.settings.dashboard.SummaryLoader; 63import com.android.settings.enterprise.EnterprisePrivacyPreferenceController; 64import com.android.settings.enterprise.ManageDeviceAdminPreferenceController; 65import com.android.settings.fingerprint.FingerprintSettings; 66import com.android.settings.location.LocationPreferenceController; 67import com.android.settings.notification.LockScreenNotificationPreferenceController; 68import com.android.settings.overlay.FeatureFactory; 69import com.android.settings.password.ChooseLockGeneric.ChooseLockGenericFragment; 70import com.android.settings.password.ChooseLockSettingsHelper; 71import com.android.settings.password.ManagedLockPasswordProvider; 72import com.android.settings.search.BaseSearchIndexProvider; 73import com.android.settings.search.Indexable; 74import com.android.settings.search.SearchIndexableRaw; 75import com.android.settings.security.OwnerInfoPreferenceController; 76import com.android.settings.security.SecurityFeatureProvider; 77import com.android.settings.trustagent.TrustAgentManager; 78import com.android.settings.widget.GearPreference; 79import com.android.settingslib.RestrictedLockUtils; 80import com.android.settingslib.RestrictedPreference; 81import com.android.settingslib.drawer.CategoryKey; 82 83import java.util.ArrayList; 84import java.util.List; 85 86/** 87 * Gesture lock pattern settings. 88 */ 89public class SecuritySettings extends SettingsPreferenceFragment 90 implements OnPreferenceChangeListener, Indexable, 91 GearPreference.OnGearClickListener { 92 93 private static final String TAG = "SecuritySettings"; 94 95 private static final String TRUST_AGENT_CLICK_INTENT = "trust_agent_click_intent"; 96 private static final Intent TRUST_AGENT_INTENT = 97 new Intent(TrustAgentService.SERVICE_INTERFACE); 98 99 // Lock Settings 100 private static final String KEY_UNLOCK_SET_OR_CHANGE = "unlock_set_or_change"; 101 private static final String KEY_UNLOCK_SET_OR_CHANGE_PROFILE = "unlock_set_or_change_profile"; 102 private static final String KEY_VISIBLE_PATTERN_PROFILE = "visiblepattern_profile"; 103 private static final String KEY_SECURITY_CATEGORY = "security_category"; 104 @VisibleForTesting 105 static final String KEY_MANAGE_TRUST_AGENTS = "manage_trust_agents"; 106 private static final String KEY_UNIFICATION = "unification"; 107 @VisibleForTesting 108 static final String KEY_LOCKSCREEN_PREFERENCES = "lockscreen_preferences"; 109 private static final String KEY_ENCRYPTION_AND_CREDENTIALS = "encryption_and_credential"; 110 private static final String KEY_LOCATION_SCANNING = "location_scanning"; 111 private static final String KEY_LOCATION = "location"; 112 113 private static final int SET_OR_CHANGE_LOCK_METHOD_REQUEST = 123; 114 private static final int CHANGE_TRUST_AGENT_SETTINGS = 126; 115 private static final int SET_OR_CHANGE_LOCK_METHOD_REQUEST_PROFILE = 127; 116 private static final int UNIFY_LOCK_CONFIRM_DEVICE_REQUEST = 128; 117 private static final int UNIFY_LOCK_CONFIRM_PROFILE_REQUEST = 129; 118 private static final int UNUNIFY_LOCK_CONFIRM_DEVICE_REQUEST = 130; 119 private static final String TAG_UNIFICATION_DIALOG = "unification_dialog"; 120 121 // Misc Settings 122 private static final String KEY_SIM_LOCK = "sim_lock_settings"; 123 private static final String KEY_SHOW_PASSWORD = "show_password"; 124 private static final String KEY_TRUST_AGENT = "trust_agent"; 125 private static final String KEY_SCREEN_PINNING = "screen_pinning_settings"; 126 127 // Security status 128 private static final String KEY_SECURITY_STATUS = "security_status"; 129 private static final String SECURITY_STATUS_KEY_PREFIX = "security_status_"; 130 131 // Package verifier Settings 132 @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE) 133 static final String KEY_PACKAGE_VERIFIER_STATUS = "security_status_package_verifier"; 134 private static final int PACKAGE_VERIFIER_STATE_ENABLED = 1; 135 136 // Device management settings 137 private static final String KEY_ENTERPRISE_PRIVACY = "enterprise_privacy"; 138 private static final String KEY_MANAGE_DEVICE_ADMIN = "manage_device_admin"; 139 140 // These switch preferences need special handling since they're not all stored in Settings. 141 private static final String SWITCH_PREFERENCE_KEYS[] = { 142 KEY_SHOW_PASSWORD, KEY_UNIFICATION, KEY_VISIBLE_PATTERN_PROFILE 143 }; 144 145 // Only allow one trust agent on the platform. 146 private static final boolean ONLY_ONE_TRUST_AGENT = true; 147 148 private static final int MY_USER_ID = UserHandle.myUserId(); 149 150 private DashboardFeatureProvider mDashboardFeatureProvider; 151 private DevicePolicyManager mDPM; 152 private SecurityFeatureProvider mSecurityFeatureProvider; 153 private TrustAgentManager mTrustAgentManager; 154 private SubscriptionManager mSubscriptionManager; 155 private UserManager mUm; 156 157 private ChooseLockSettingsHelper mChooseLockSettingsHelper; 158 private LockPatternUtils mLockPatternUtils; 159 private ManagedLockPasswordProvider mManagedPasswordProvider; 160 161 private SwitchPreference mVisiblePatternProfile; 162 private SwitchPreference mUnifyProfile; 163 164 private SwitchPreference mShowPassword; 165 166 private boolean mIsAdmin; 167 168 private Intent mTrustAgentClickIntent; 169 170 private int mProfileChallengeUserId; 171 172 private String mCurrentDevicePassword; 173 private String mCurrentProfilePassword; 174 175 private LocationPreferenceController mLocationcontroller; 176 private ManageDeviceAdminPreferenceController mManageDeviceAdminPreferenceController; 177 private EnterprisePrivacyPreferenceController mEnterprisePrivacyPreferenceController; 178 private LockScreenNotificationPreferenceController mLockScreenNotificationPreferenceController; 179 180 @Override 181 public int getMetricsCategory() { 182 return MetricsEvent.SECURITY; 183 } 184 185 @Override 186 public void onAttach(Context context) { 187 super.onAttach(context); 188 mLocationcontroller = new LocationPreferenceController(context, getLifecycle()); 189 } 190 191 @Override 192 public void onCreate(Bundle savedInstanceState) { 193 super.onCreate(savedInstanceState); 194 195 final Activity activity = getActivity(); 196 197 mSubscriptionManager = SubscriptionManager.from(activity); 198 199 mLockPatternUtils = new LockPatternUtils(activity); 200 201 mManagedPasswordProvider = ManagedLockPasswordProvider.get(activity, MY_USER_ID); 202 203 mDPM = (DevicePolicyManager)getSystemService(Context.DEVICE_POLICY_SERVICE); 204 205 mUm = UserManager.get(activity); 206 207 mChooseLockSettingsHelper = new ChooseLockSettingsHelper(activity); 208 209 mDashboardFeatureProvider = FeatureFactory.getFactory(activity) 210 .getDashboardFeatureProvider(activity); 211 212 mSecurityFeatureProvider = FeatureFactory.getFactory(activity).getSecurityFeatureProvider(); 213 214 mTrustAgentManager = mSecurityFeatureProvider.getTrustAgentManager(); 215 216 if (savedInstanceState != null 217 && savedInstanceState.containsKey(TRUST_AGENT_CLICK_INTENT)) { 218 mTrustAgentClickIntent = savedInstanceState.getParcelable(TRUST_AGENT_CLICK_INTENT); 219 } 220 221 mManageDeviceAdminPreferenceController 222 = new ManageDeviceAdminPreferenceController(activity); 223 mEnterprisePrivacyPreferenceController 224 = new EnterprisePrivacyPreferenceController(activity, null /* lifecycle */); 225 mLockScreenNotificationPreferenceController 226 = new LockScreenNotificationPreferenceController(activity); 227 } 228 229 private static int getResIdForLockUnlockScreen(Context context, 230 LockPatternUtils lockPatternUtils, ManagedLockPasswordProvider managedPasswordProvider, 231 int userId) { 232 final boolean isMyUser = userId == MY_USER_ID; 233 int resid = 0; 234 if (!lockPatternUtils.isSecure(userId)) { 235 if (!isMyUser) { 236 resid = R.xml.security_settings_lockscreen_profile; 237 } else if (lockPatternUtils.isLockScreenDisabled(userId)) { 238 resid = R.xml.security_settings_lockscreen; 239 } else { 240 resid = R.xml.security_settings_chooser; 241 } 242 } else { 243 switch (lockPatternUtils.getKeyguardStoredPasswordQuality(userId)) { 244 case DevicePolicyManager.PASSWORD_QUALITY_SOMETHING: 245 resid = isMyUser ? R.xml.security_settings_pattern 246 : R.xml.security_settings_pattern_profile; 247 break; 248 case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC: 249 case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC_COMPLEX: 250 resid = isMyUser ? R.xml.security_settings_pin 251 : R.xml.security_settings_pin_profile; 252 break; 253 case DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC: 254 case DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC: 255 case DevicePolicyManager.PASSWORD_QUALITY_COMPLEX: 256 resid = isMyUser ? R.xml.security_settings_password 257 : R.xml.security_settings_password_profile; 258 break; 259 case DevicePolicyManager.PASSWORD_QUALITY_MANAGED: 260 resid = managedPasswordProvider.getResIdForLockUnlockScreen(!isMyUser); 261 break; 262 } 263 } 264 return resid; 265 } 266 267 /** 268 * Important! 269 * 270 * Don't forget to update the SecuritySearchIndexProvider if you are doing any change in the 271 * logic or adding/removing preferences here. 272 */ 273 private PreferenceScreen createPreferenceHierarchy() { 274 PreferenceScreen root = getPreferenceScreen(); 275 if (root != null) { 276 root.removeAll(); 277 } 278 addPreferencesFromResource(R.xml.security_settings); 279 root = getPreferenceScreen(); 280 281 // Add category for security status 282 addPreferencesFromResource(R.xml.security_settings_status); 283 284 // Add options for lock/unlock screen 285 final int resid = getResIdForLockUnlockScreen(getActivity(), mLockPatternUtils, 286 mManagedPasswordProvider, MY_USER_ID); 287 addPreferencesFromResource(resid); 288 289 // DO or PO installed in the user may disallow to change password. 290 disableIfPasswordQualityManaged(KEY_UNLOCK_SET_OR_CHANGE, MY_USER_ID); 291 292 mProfileChallengeUserId = Utils.getManagedProfileId(mUm, MY_USER_ID); 293 if (mProfileChallengeUserId != UserHandle.USER_NULL 294 && mLockPatternUtils.isSeparateProfileChallengeAllowed(mProfileChallengeUserId)) { 295 addPreferencesFromResource(R.xml.security_settings_profile); 296 addPreferencesFromResource(R.xml.security_settings_unification); 297 final int profileResid = getResIdForLockUnlockScreen( 298 getActivity(), mLockPatternUtils, mManagedPasswordProvider, 299 mProfileChallengeUserId); 300 addPreferencesFromResource(profileResid); 301 maybeAddFingerprintPreference(root, mProfileChallengeUserId); 302 if (!mLockPatternUtils.isSeparateProfileChallengeEnabled(mProfileChallengeUserId)) { 303 final Preference lockPreference = 304 root.findPreference(KEY_UNLOCK_SET_OR_CHANGE_PROFILE); 305 final String summary = getContext().getString( 306 R.string.lock_settings_profile_unified_summary); 307 lockPreference.setSummary(summary); 308 lockPreference.setEnabled(false); 309 // PO may disallow to change password for the profile, but screen lock and managed 310 // profile's lock is the same. Disable main "Screen lock" menu. 311 disableIfPasswordQualityManaged(KEY_UNLOCK_SET_OR_CHANGE, mProfileChallengeUserId); 312 } else { 313 // PO may disallow to change profile password, and the profile's password is 314 // separated from screen lock password. Disable profile specific "Screen lock" menu. 315 disableIfPasswordQualityManaged(KEY_UNLOCK_SET_OR_CHANGE_PROFILE, 316 mProfileChallengeUserId); 317 } 318 } 319 320 Preference unlockSetOrChange = findPreference(KEY_UNLOCK_SET_OR_CHANGE); 321 if (unlockSetOrChange instanceof GearPreference) { 322 ((GearPreference) unlockSetOrChange).setOnGearClickListener(this); 323 } 324 325 mIsAdmin = mUm.isAdminUser(); 326 327 // Fingerprint and trust agents 328 int numberOfTrustAgent = 0; 329 PreferenceGroup securityCategory = (PreferenceGroup) 330 root.findPreference(KEY_SECURITY_CATEGORY); 331 if (securityCategory != null) { 332 maybeAddFingerprintPreference(securityCategory, UserHandle.myUserId()); 333 numberOfTrustAgent = addTrustAgentSettings(securityCategory); 334 setLockscreenPreferencesSummary(securityCategory); 335 } 336 337 mVisiblePatternProfile = 338 (SwitchPreference) root.findPreference(KEY_VISIBLE_PATTERN_PROFILE); 339 mUnifyProfile = (SwitchPreference) root.findPreference(KEY_UNIFICATION); 340 341 // Append the rest of the settings 342 addPreferencesFromResource(R.xml.security_settings_misc); 343 344 // Do not display SIM lock for devices without an Icc card 345 TelephonyManager tm = TelephonyManager.getDefault(); 346 CarrierConfigManager cfgMgr = (CarrierConfigManager) 347 getActivity().getSystemService(Context.CARRIER_CONFIG_SERVICE); 348 PersistableBundle b = cfgMgr.getConfig(); 349 if (!mIsAdmin || !isSimIccReady() || 350 b.getBoolean(CarrierConfigManager.KEY_HIDE_SIM_LOCK_SETTINGS_BOOL)) { 351 root.removePreference(root.findPreference(KEY_SIM_LOCK)); 352 } else { 353 // Disable SIM lock if there is no ready SIM card. 354 root.findPreference(KEY_SIM_LOCK).setEnabled(isSimReady()); 355 } 356 if (Settings.System.getInt(getContentResolver(), 357 Settings.System.LOCK_TO_APP_ENABLED, 0) != 0) { 358 root.findPreference(KEY_SCREEN_PINNING).setSummary( 359 getResources().getString(R.string.switch_on_text)); 360 } 361 362 // Encryption status of device 363 if (LockPatternUtils.isDeviceEncryptionEnabled()) { 364 root.findPreference(KEY_ENCRYPTION_AND_CREDENTIALS).setSummary( 365 R.string.encryption_and_credential_settings_summary); 366 } else { 367 root.findPreference(KEY_ENCRYPTION_AND_CREDENTIALS).setSummary( 368 R.string.summary_placeholder); 369 } 370 371 // Show password 372 mShowPassword = (SwitchPreference) root.findPreference(KEY_SHOW_PASSWORD); 373 374 // Credential storage 375 final UserManager um = (UserManager) getActivity().getSystemService(Context.USER_SERVICE); 376 377 // Advanced Security features 378 initTrustAgentPreference(root, numberOfTrustAgent); 379 380 // The above preferences come and go based on security state, so we need to update 381 // the index. This call is expected to be fairly cheap, but we may want to do something 382 // smarter in the future. 383 final Activity activity = getActivity(); 384 FeatureFactory.getFactory(activity).getSearchFeatureProvider().getIndexingManager(activity) 385 .updateFromClassNameResource(SecuritySettings.class.getName(), 386 true /* includeInSearchResults */); 387 388 PreferenceGroup securityStatusPreferenceGroup = 389 (PreferenceGroup) root.findPreference(KEY_SECURITY_STATUS); 390 final List<Preference> tilePrefs = mDashboardFeatureProvider.getPreferencesForCategory( 391 getActivity(), getPrefContext(), getMetricsCategory(), 392 CategoryKey.CATEGORY_SECURITY); 393 int numSecurityStatusPrefs = 0; 394 if (tilePrefs != null && !tilePrefs.isEmpty()) { 395 for (Preference preference : tilePrefs) { 396 if (!TextUtils.isEmpty(preference.getKey()) 397 && preference.getKey().startsWith(SECURITY_STATUS_KEY_PREFIX)) { 398 // Injected security status settings are placed under the Security status 399 // category. 400 securityStatusPreferenceGroup.addPreference(preference); 401 numSecurityStatusPrefs++; 402 } else { 403 // Other injected settings are placed under the Security preference screen. 404 root.addPreference(preference); 405 } 406 } 407 } 408 409 if (numSecurityStatusPrefs == 0) { 410 root.removePreference(securityStatusPreferenceGroup); 411 } else if (numSecurityStatusPrefs > 0) { 412 // Update preference data with tile data. Security feature provider only updates the 413 // data if it actually needs to be changed. 414 mSecurityFeatureProvider.updatePreferences(getActivity(), root, 415 mDashboardFeatureProvider.getTilesForCategory( 416 CategoryKey.CATEGORY_SECURITY)); 417 } 418 419 for (int i = 0; i < SWITCH_PREFERENCE_KEYS.length; i++) { 420 final Preference pref = findPreference(SWITCH_PREFERENCE_KEYS[i]); 421 if (pref != null) pref.setOnPreferenceChangeListener(this); 422 } 423 424 mLocationcontroller.displayPreference(root); 425 mManageDeviceAdminPreferenceController.updateState( 426 root.findPreference(KEY_MANAGE_DEVICE_ADMIN)); 427 mEnterprisePrivacyPreferenceController.displayPreference(root); 428 mEnterprisePrivacyPreferenceController.onResume(); 429 430 return root; 431 } 432 433 @VisibleForTesting 434 void initTrustAgentPreference(PreferenceScreen root, int numberOfTrustAgent) { 435 Preference manageAgents = root.findPreference(KEY_MANAGE_TRUST_AGENTS); 436 if (manageAgents != null) { 437 if (!mLockPatternUtils.isSecure(MY_USER_ID)) { 438 manageAgents.setEnabled(false); 439 manageAgents.setSummary(R.string.disabled_because_no_backup_security); 440 } else if (numberOfTrustAgent > 0) { 441 manageAgents.setSummary(getActivity().getResources().getQuantityString( 442 R.plurals.manage_trust_agents_summary_on, 443 numberOfTrustAgent, numberOfTrustAgent)); 444 } else { 445 manageAgents.setSummary(R.string.manage_trust_agents_summary); 446 } 447 } 448 } 449 450 @VisibleForTesting 451 void setLockscreenPreferencesSummary(PreferenceGroup group) { 452 final Preference lockscreenPreferences = group.findPreference(KEY_LOCKSCREEN_PREFERENCES); 453 if (lockscreenPreferences != null) { 454 lockscreenPreferences.setSummary( 455 mLockScreenNotificationPreferenceController.getSummaryResource()); 456 } 457 } 458 459 /* 460 * Sets the preference as disabled by admin if PASSWORD_QUALITY_MANAGED is set. 461 * The preference must be a RestrictedPreference. 462 */ 463 private void disableIfPasswordQualityManaged(String preferenceKey, int userId) { 464 final EnforcedAdmin admin = RestrictedLockUtils.checkIfPasswordQualityIsSet( 465 getActivity(), userId); 466 if (admin != null && mDPM.getPasswordQuality(admin.component, userId) == 467 DevicePolicyManager.PASSWORD_QUALITY_MANAGED) { 468 final RestrictedPreference pref = 469 (RestrictedPreference) getPreferenceScreen().findPreference(preferenceKey); 470 pref.setDisabledByAdmin(admin); 471 } 472 } 473 474 private void maybeAddFingerprintPreference(PreferenceGroup securityCategory, int userId) { 475 Preference fingerprintPreference = 476 FingerprintSettings.getFingerprintPreferenceForUser( 477 securityCategory.getContext(), userId); 478 if (fingerprintPreference != null) { 479 securityCategory.addPreference(fingerprintPreference); 480 } 481 } 482 483 // Return the number of trust agents being added 484 private int addTrustAgentSettings(PreferenceGroup securityCategory) { 485 final boolean hasSecurity = mLockPatternUtils.isSecure(MY_USER_ID); 486 ArrayList<TrustAgentComponentInfo> agents = getActiveTrustAgents( 487 getActivity(), mTrustAgentManager, mLockPatternUtils, mDPM); 488 for (int i = 0; i < agents.size(); i++) { 489 final TrustAgentComponentInfo agent = agents.get(i); 490 RestrictedPreference trustAgentPreference = 491 new RestrictedPreference(securityCategory.getContext()); 492 trustAgentPreference.setKey(KEY_TRUST_AGENT); 493 trustAgentPreference.setTitle(agent.title); 494 trustAgentPreference.setSummary(agent.summary); 495 // Create intent for this preference. 496 Intent intent = new Intent(); 497 intent.setComponent(agent.componentName); 498 intent.setAction(Intent.ACTION_MAIN); 499 trustAgentPreference.setIntent(intent); 500 // Add preference to the settings menu. 501 securityCategory.addPreference(trustAgentPreference); 502 503 trustAgentPreference.setDisabledByAdmin(agent.admin); 504 if (!trustAgentPreference.isDisabledByAdmin() && !hasSecurity) { 505 trustAgentPreference.setEnabled(false); 506 trustAgentPreference.setSummary(R.string.disabled_because_no_backup_security); 507 } 508 } 509 return agents.size(); 510 } 511 512 /* Return true if a there is a Slot that has Icc. 513 */ 514 private boolean isSimIccReady() { 515 TelephonyManager tm = TelephonyManager.getDefault(); 516 final List<SubscriptionInfo> subInfoList = 517 mSubscriptionManager.getActiveSubscriptionInfoList(); 518 519 if (subInfoList != null) { 520 for (SubscriptionInfo subInfo : subInfoList) { 521 if (tm.hasIccCard(subInfo.getSimSlotIndex())) { 522 return true; 523 } 524 } 525 } 526 527 return false; 528 } 529 530 /* Return true if a SIM is ready for locking. 531 * TODO: consider adding to TelephonyManager or SubscritpionManasger. 532 */ 533 private boolean isSimReady() { 534 int simState = TelephonyManager.SIM_STATE_UNKNOWN; 535 final List<SubscriptionInfo> subInfoList = 536 mSubscriptionManager.getActiveSubscriptionInfoList(); 537 if (subInfoList != null) { 538 for (SubscriptionInfo subInfo : subInfoList) { 539 simState = TelephonyManager.getDefault().getSimState(subInfo.getSimSlotIndex()); 540 if((simState != TelephonyManager.SIM_STATE_ABSENT) && 541 (simState != TelephonyManager.SIM_STATE_UNKNOWN)){ 542 return true; 543 } 544 } 545 } 546 return false; 547 } 548 549 private static ArrayList<TrustAgentComponentInfo> getActiveTrustAgents(Context context, 550 TrustAgentManager trustAgentManager, LockPatternUtils utils, 551 DevicePolicyManager dpm) { 552 PackageManager pm = context.getPackageManager(); 553 ArrayList<TrustAgentComponentInfo> result = new ArrayList<TrustAgentComponentInfo>(); 554 List<ResolveInfo> resolveInfos = pm.queryIntentServices(TRUST_AGENT_INTENT, 555 PackageManager.GET_META_DATA); 556 List<ComponentName> enabledTrustAgents = utils.getEnabledTrustAgents(MY_USER_ID); 557 558 EnforcedAdmin admin = RestrictedLockUtils.checkIfKeyguardFeaturesDisabled(context, 559 DevicePolicyManager.KEYGUARD_DISABLE_TRUST_AGENTS, UserHandle.myUserId()); 560 561 if (enabledTrustAgents != null && !enabledTrustAgents.isEmpty()) { 562 for (int i = 0; i < resolveInfos.size(); i++) { 563 ResolveInfo resolveInfo = resolveInfos.get(i); 564 if (resolveInfo.serviceInfo == null) continue; 565 if (!trustAgentManager.shouldProvideTrust(resolveInfo, pm)) { 566 continue; 567 } 568 TrustAgentComponentInfo trustAgentComponentInfo = 569 TrustAgentUtils.getSettingsComponent(pm, resolveInfo); 570 if (trustAgentComponentInfo.componentName == null || 571 !enabledTrustAgents.contains( 572 TrustAgentUtils.getComponentName(resolveInfo)) || 573 TextUtils.isEmpty(trustAgentComponentInfo.title)) continue; 574 if (admin != null && dpm.getTrustAgentConfiguration( 575 null, TrustAgentUtils.getComponentName(resolveInfo)) == null) { 576 trustAgentComponentInfo.admin = admin; 577 } 578 result.add(trustAgentComponentInfo); 579 if (ONLY_ONE_TRUST_AGENT) break; 580 } 581 } 582 return result; 583 } 584 585 private static CharSequence getActiveTrustAgentLabel(Context context, 586 TrustAgentManager trustAgentManager, LockPatternUtils utils, 587 DevicePolicyManager dpm) { 588 ArrayList<TrustAgentComponentInfo> agents = getActiveTrustAgents(context, 589 trustAgentManager, utils, dpm); 590 return agents.isEmpty() ? null : agents.get(0).title; 591 } 592 593 @Override 594 public void onGearClick(GearPreference p) { 595 if (KEY_UNLOCK_SET_OR_CHANGE.equals(p.getKey())) { 596 startFragment(this, SecuritySubSettings.class.getName(), 0, 0, null); 597 } 598 } 599 600 @Override 601 public void onSaveInstanceState(Bundle outState) { 602 super.onSaveInstanceState(outState); 603 if (mTrustAgentClickIntent != null) { 604 outState.putParcelable(TRUST_AGENT_CLICK_INTENT, mTrustAgentClickIntent); 605 } 606 } 607 608 @Override 609 public void onResume() { 610 super.onResume(); 611 612 // Make sure we reload the preference hierarchy since some of these settings 613 // depend on others... 614 createPreferenceHierarchy(); 615 616 if (mVisiblePatternProfile != null) { 617 mVisiblePatternProfile.setChecked(mLockPatternUtils.isVisiblePatternEnabled( 618 mProfileChallengeUserId)); 619 } 620 621 updateUnificationPreference(); 622 623 if (mShowPassword != null) { 624 mShowPassword.setChecked(Settings.System.getInt(getContentResolver(), 625 Settings.System.TEXT_SHOW_PASSWORD, 1) != 0); 626 } 627 628 mLocationcontroller.updateSummary(); 629 } 630 631 private void updateUnificationPreference() { 632 if (mUnifyProfile != null) { 633 mUnifyProfile.setChecked(!mLockPatternUtils.isSeparateProfileChallengeEnabled( 634 mProfileChallengeUserId)); 635 } 636 } 637 638 @Override 639 public boolean onPreferenceTreeClick(Preference preference) { 640 final String key = preference.getKey(); 641 if (KEY_UNLOCK_SET_OR_CHANGE.equals(key)) { 642 // TODO(b/35930129): Remove once existing password can be passed into vold directly. 643 // Currently we need this logic to ensure that the QUIET_MODE is off for any work 644 // profile with unified challenge on FBE-enabled devices. Otherwise, vold would not be 645 // able to complete the operation due to the lack of (old) encryption key. 646 if (mProfileChallengeUserId != UserHandle.USER_NULL 647 && !mLockPatternUtils.isSeparateProfileChallengeEnabled(mProfileChallengeUserId) 648 && StorageManager.isFileEncryptedNativeOnly()) { 649 if (Utils.startQuietModeDialogIfNecessary(this.getActivity(), mUm, 650 mProfileChallengeUserId)) { 651 return false; 652 } 653 } 654 startFragment(this, ChooseLockGenericFragment.class.getName(), 655 R.string.lock_settings_picker_title, SET_OR_CHANGE_LOCK_METHOD_REQUEST, null); 656 } else if (KEY_UNLOCK_SET_OR_CHANGE_PROFILE.equals(key)) { 657 if (Utils.startQuietModeDialogIfNecessary(this.getActivity(), mUm, 658 mProfileChallengeUserId)) { 659 return false; 660 } 661 Bundle extras = new Bundle(); 662 extras.putInt(Intent.EXTRA_USER_ID, mProfileChallengeUserId); 663 startFragment(this, ChooseLockGenericFragment.class.getName(), 664 R.string.lock_settings_picker_title_profile, 665 SET_OR_CHANGE_LOCK_METHOD_REQUEST_PROFILE, extras); 666 } else if (KEY_TRUST_AGENT.equals(key)) { 667 ChooseLockSettingsHelper helper = 668 new ChooseLockSettingsHelper(this.getActivity(), this); 669 mTrustAgentClickIntent = preference.getIntent(); 670 boolean confirmationLaunched = helper.launchConfirmationActivity( 671 CHANGE_TRUST_AGENT_SETTINGS, preference.getTitle()); 672 if (!confirmationLaunched&& mTrustAgentClickIntent != null) { 673 // If this returns false, it means no password confirmation is required. 674 startActivity(mTrustAgentClickIntent); 675 mTrustAgentClickIntent = null; 676 } 677 } else { 678 // If we didn't handle it, let preferences handle it. 679 return super.onPreferenceTreeClick(preference); 680 } 681 return true; 682 } 683 684 /** 685 * see confirmPatternThenDisableAndClear 686 */ 687 @Override 688 public void onActivityResult(int requestCode, int resultCode, Intent data) { 689 super.onActivityResult(requestCode, resultCode, data); 690 if (requestCode == CHANGE_TRUST_AGENT_SETTINGS && resultCode == Activity.RESULT_OK) { 691 if (mTrustAgentClickIntent != null) { 692 startActivity(mTrustAgentClickIntent); 693 mTrustAgentClickIntent = null; 694 } 695 return; 696 } else if (requestCode == UNIFY_LOCK_CONFIRM_DEVICE_REQUEST 697 && resultCode == Activity.RESULT_OK) { 698 mCurrentDevicePassword = 699 data.getStringExtra(ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD); 700 launchConfirmProfileLockForUnification(); 701 return; 702 } else if (requestCode == UNIFY_LOCK_CONFIRM_PROFILE_REQUEST 703 && resultCode == Activity.RESULT_OK) { 704 mCurrentProfilePassword = 705 data.getStringExtra(ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD); 706 unifyLocks(); 707 return; 708 } else if (requestCode == UNUNIFY_LOCK_CONFIRM_DEVICE_REQUEST 709 && resultCode == Activity.RESULT_OK) { 710 ununifyLocks(); 711 return; 712 } 713 createPreferenceHierarchy(); 714 } 715 716 private void launchConfirmDeviceLockForUnification() { 717 final String title = getActivity().getString( 718 R.string.unlock_set_unlock_launch_picker_title); 719 final ChooseLockSettingsHelper helper = 720 new ChooseLockSettingsHelper(getActivity(), this); 721 if (!helper.launchConfirmationActivity( 722 UNIFY_LOCK_CONFIRM_DEVICE_REQUEST, title, true, MY_USER_ID)) { 723 launchConfirmProfileLockForUnification(); 724 } 725 } 726 727 private void launchConfirmProfileLockForUnification() { 728 final String title = getActivity().getString( 729 R.string.unlock_set_unlock_launch_picker_title_profile); 730 final ChooseLockSettingsHelper helper = 731 new ChooseLockSettingsHelper(getActivity(), this); 732 if (!helper.launchConfirmationActivity( 733 UNIFY_LOCK_CONFIRM_PROFILE_REQUEST, title, true, mProfileChallengeUserId)) { 734 unifyLocks(); 735 createPreferenceHierarchy(); 736 } 737 } 738 739 private void unifyLocks() { 740 int profileQuality = 741 mLockPatternUtils.getKeyguardStoredPasswordQuality(mProfileChallengeUserId); 742 if (profileQuality == DevicePolicyManager.PASSWORD_QUALITY_SOMETHING) { 743 mLockPatternUtils.saveLockPattern( 744 LockPatternUtils.stringToPattern(mCurrentProfilePassword), 745 mCurrentDevicePassword, MY_USER_ID); 746 } else { 747 mLockPatternUtils.saveLockPassword( 748 mCurrentProfilePassword, mCurrentDevicePassword, 749 profileQuality, MY_USER_ID); 750 } 751 mLockPatternUtils.setSeparateProfileChallengeEnabled(mProfileChallengeUserId, false, 752 mCurrentProfilePassword); 753 final boolean profilePatternVisibility = 754 mLockPatternUtils.isVisiblePatternEnabled(mProfileChallengeUserId); 755 mLockPatternUtils.setVisiblePatternEnabled(profilePatternVisibility, MY_USER_ID); 756 mCurrentDevicePassword = null; 757 mCurrentProfilePassword = null; 758 } 759 760 private void unifyUncompliantLocks() { 761 mLockPatternUtils.setSeparateProfileChallengeEnabled(mProfileChallengeUserId, false, 762 mCurrentProfilePassword); 763 startFragment(this, ChooseLockGenericFragment.class.getName(), 764 R.string.lock_settings_picker_title, SET_OR_CHANGE_LOCK_METHOD_REQUEST, null); 765 } 766 767 private void ununifyLocks() { 768 Bundle extras = new Bundle(); 769 extras.putInt(Intent.EXTRA_USER_ID, mProfileChallengeUserId); 770 startFragment(this, 771 ChooseLockGenericFragment.class.getName(), 772 R.string.lock_settings_picker_title_profile, 773 SET_OR_CHANGE_LOCK_METHOD_REQUEST_PROFILE, extras); 774 } 775 776 @Override 777 public boolean onPreferenceChange(Preference preference, Object value) { 778 boolean result = true; 779 final String key = preference.getKey(); 780 final LockPatternUtils lockPatternUtils = mChooseLockSettingsHelper.utils(); 781 if (KEY_VISIBLE_PATTERN_PROFILE.equals(key)) { 782 if (Utils.startQuietModeDialogIfNecessary(this.getActivity(), mUm, 783 mProfileChallengeUserId)) { 784 return false; 785 } 786 lockPatternUtils.setVisiblePatternEnabled((Boolean) value, mProfileChallengeUserId); 787 } else if (KEY_UNIFICATION.equals(key)) { 788 if (Utils.startQuietModeDialogIfNecessary(this.getActivity(), mUm, 789 mProfileChallengeUserId)) { 790 return false; 791 } 792 if ((Boolean) value) { 793 final boolean compliantForDevice = 794 (mLockPatternUtils.getKeyguardStoredPasswordQuality(mProfileChallengeUserId) 795 >= DevicePolicyManager.PASSWORD_QUALITY_SOMETHING 796 && mLockPatternUtils.isSeparateProfileChallengeAllowedToUnify( 797 mProfileChallengeUserId)); 798 UnificationConfirmationDialog dialog = 799 UnificationConfirmationDialog.newIntance(compliantForDevice); 800 dialog.show(getChildFragmentManager(), TAG_UNIFICATION_DIALOG); 801 } else { 802 final String title = getActivity().getString( 803 R.string.unlock_set_unlock_launch_picker_title); 804 final ChooseLockSettingsHelper helper = 805 new ChooseLockSettingsHelper(getActivity(), this); 806 if(!helper.launchConfirmationActivity( 807 UNUNIFY_LOCK_CONFIRM_DEVICE_REQUEST, title, true, MY_USER_ID)) { 808 ununifyLocks(); 809 } 810 } 811 } else if (KEY_SHOW_PASSWORD.equals(key)) { 812 Settings.System.putInt(getContentResolver(), Settings.System.TEXT_SHOW_PASSWORD, 813 ((Boolean) value) ? 1 : 0); 814 lockPatternUtils.setVisiblePasswordEnabled((Boolean) value, MY_USER_ID); 815 } 816 return result; 817 } 818 819 @Override 820 protected int getHelpResource() { 821 return R.string.help_url_security; 822 } 823 824 /** 825 * For Search. Please keep it in sync when updating "createPreferenceHierarchy()" 826 */ 827 public static final SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = 828 new SecuritySearchIndexProvider(); 829 830 private static class SecuritySearchIndexProvider extends BaseSearchIndexProvider { 831 832 @Override 833 public List<SearchIndexableResource> getXmlResourcesToIndex( 834 Context context, boolean enabled) { 835 final List<SearchIndexableResource> index = new ArrayList<SearchIndexableResource>(); 836 837 final LockPatternUtils lockPatternUtils = new LockPatternUtils(context); 838 final ManagedLockPasswordProvider managedPasswordProvider = 839 ManagedLockPasswordProvider.get(context, MY_USER_ID); 840 final DevicePolicyManager dpm = (DevicePolicyManager) 841 context.getSystemService(Context.DEVICE_POLICY_SERVICE); 842 final UserManager um = UserManager.get(context); 843 final int profileUserId = Utils.getManagedProfileId(um, MY_USER_ID); 844 845 // To add option for unlock screen, user's password must not be managed and 846 // must not be unified with managed profile, whose password is managed. 847 if (!isPasswordManaged(MY_USER_ID, context, dpm) 848 && (profileUserId == UserHandle.USER_NULL 849 || lockPatternUtils.isSeparateProfileChallengeAllowed(profileUserId) 850 || !isPasswordManaged(profileUserId, context, dpm))) { 851 // Add options for lock/unlock screen 852 final int resId = getResIdForLockUnlockScreen(context, lockPatternUtils, 853 managedPasswordProvider, MY_USER_ID); 854 index.add(getSearchResource(context, resId)); 855 } 856 857 if (profileUserId != UserHandle.USER_NULL 858 && lockPatternUtils.isSeparateProfileChallengeAllowed(profileUserId) 859 && !isPasswordManaged(profileUserId, context, dpm)) { 860 index.add(getSearchResource(context, getResIdForLockUnlockScreen(context, 861 lockPatternUtils, managedPasswordProvider, profileUserId))); 862 } 863 864 final SearchIndexableResource sir = getSearchResource(context, 865 SecuritySubSettings.getResIdForLockUnlockSubScreen(context, lockPatternUtils, 866 managedPasswordProvider)); 867 sir.className = SecuritySubSettings.class.getName(); 868 index.add(sir); 869 870 // Append the rest of the settings 871 index.add(getSearchResource(context, R.xml.security_settings_misc)); 872 873 return index; 874 } 875 876 private SearchIndexableResource getSearchResource(Context context, int xmlResId) { 877 final SearchIndexableResource sir = new SearchIndexableResource(context); 878 sir.xmlResId = xmlResId; 879 return sir; 880 } 881 882 private boolean isPasswordManaged(int userId, Context context, DevicePolicyManager dpm) { 883 final EnforcedAdmin admin = RestrictedLockUtils.checkIfPasswordQualityIsSet( 884 context, userId); 885 return admin != null && dpm.getPasswordQuality(admin.component, userId) == 886 DevicePolicyManager.PASSWORD_QUALITY_MANAGED; 887 } 888 889 @Override 890 public List<SearchIndexableRaw> getRawDataToIndex(Context context, boolean enabled) { 891 final List<SearchIndexableRaw> result = new ArrayList<SearchIndexableRaw>(); 892 final Resources res = context.getResources(); 893 894 final String screenTitle = res.getString(R.string.security_settings_title); 895 896 SearchIndexableRaw data = new SearchIndexableRaw(context); 897 data.title = screenTitle; 898 data.screenTitle = screenTitle; 899 result.add(data); 900 901 final UserManager um = UserManager.get(context); 902 903 // Fingerprint 904 final FingerprintManager fpm = Utils.getFingerprintManagerOrNull(context); 905 if (fpm != null && fpm.isHardwareDetected()) { 906 // This catches the title which can be overloaded in an overlay 907 data = new SearchIndexableRaw(context); 908 data.title = res.getString(R.string.security_settings_fingerprint_preference_title); 909 data.screenTitle = screenTitle; 910 result.add(data); 911 // Fallback for when the above doesn't contain "fingerprint" 912 data = new SearchIndexableRaw(context); 913 data.title = res.getString(R.string.fingerprint_manage_category_title); 914 data.screenTitle = screenTitle; 915 result.add(data); 916 } 917 918 final LockPatternUtils lockPatternUtils = new LockPatternUtils(context); 919 final int profileUserId = Utils.getManagedProfileId(um, MY_USER_ID); 920 if (profileUserId != UserHandle.USER_NULL 921 && lockPatternUtils.isSeparateProfileChallengeAllowed(profileUserId)) { 922 if (lockPatternUtils.getKeyguardStoredPasswordQuality(profileUserId) 923 >= DevicePolicyManager.PASSWORD_QUALITY_SOMETHING 924 && lockPatternUtils.isSeparateProfileChallengeAllowedToUnify( 925 profileUserId)) { 926 data = new SearchIndexableRaw(context); 927 data.title = res.getString(R.string.lock_settings_profile_unification_title); 928 data.screenTitle = screenTitle; 929 result.add(data); 930 } 931 } 932 933 // Advanced 934 if (lockPatternUtils.isSecure(MY_USER_ID)) { 935 final TrustAgentManager trustAgentManager = 936 FeatureFactory.getFactory(context).getSecurityFeatureProvider() 937 .getTrustAgentManager(); 938 final List<TrustAgentComponentInfo> agents = 939 getActiveTrustAgents(context, trustAgentManager, lockPatternUtils, 940 context.getSystemService(DevicePolicyManager.class)); 941 for (int i = 0; i < agents.size(); i++) { 942 final TrustAgentComponentInfo agent = agents.get(i); 943 data = new SearchIndexableRaw(context); 944 data.title = agent.title; 945 data.screenTitle = screenTitle; 946 result.add(data); 947 } 948 } 949 return result; 950 } 951 952 @Override 953 public List<String> getNonIndexableKeys(Context context) { 954 final List<String> keys = super.getNonIndexableKeys(context); 955 956 LockPatternUtils lockPatternUtils = new LockPatternUtils(context); 957 958 // Do not display SIM lock for devices without an Icc card 959 final UserManager um = UserManager.get(context); 960 final TelephonyManager tm = TelephonyManager.from(context); 961 if (!um.isAdminUser() || !tm.hasIccCard()) { 962 keys.add(KEY_SIM_LOCK); 963 } 964 965 // TrustAgent settings disappear when the user has no primary security. 966 if (!lockPatternUtils.isSecure(MY_USER_ID)) { 967 keys.add(KEY_TRUST_AGENT); 968 keys.add(KEY_MANAGE_TRUST_AGENTS); 969 } 970 971 if (!(new EnterprisePrivacyPreferenceController(context, null /* lifecycle */)) 972 .isAvailable()) { 973 keys.add(KEY_ENTERPRISE_PRIVACY); 974 } 975 976 // Duplicate in special app access 977 keys.add(KEY_MANAGE_DEVICE_ADMIN); 978 // Duplicates between parent-child 979 keys.add(KEY_LOCATION); 980 keys.add(KEY_ENCRYPTION_AND_CREDENTIALS); 981 keys.add(KEY_SCREEN_PINNING); 982 keys.add(KEY_LOCATION_SCANNING); 983 984 return keys; 985 } 986 } 987 988 public static class SecuritySubSettings extends SettingsPreferenceFragment 989 implements OnPreferenceChangeListener, OwnerInfoPreferenceController.OwnerInfoCallback { 990 991 private static final String KEY_VISIBLE_PATTERN = "visiblepattern"; 992 private static final String KEY_LOCK_AFTER_TIMEOUT = "lock_after_timeout"; 993 private static final String KEY_POWER_INSTANTLY_LOCKS = "power_button_instantly_locks"; 994 995 // These switch preferences need special handling since they're not all stored in Settings. 996 private static final String SWITCH_PREFERENCE_KEYS[] = { KEY_LOCK_AFTER_TIMEOUT, 997 KEY_VISIBLE_PATTERN, KEY_POWER_INSTANTLY_LOCKS }; 998 999 private TimeoutListPreference mLockAfter; 1000 private SwitchPreference mVisiblePattern; 1001 private SwitchPreference mPowerButtonInstantlyLocks; 1002 1003 private TrustAgentManager mTrustAgentManager; 1004 private LockPatternUtils mLockPatternUtils; 1005 private DevicePolicyManager mDPM; 1006 private OwnerInfoPreferenceController mOwnerInfoPreferenceController; 1007 1008 @Override 1009 public int getMetricsCategory() { 1010 return MetricsEvent.SECURITY; 1011 } 1012 1013 @Override 1014 public void onCreate(Bundle icicle) { 1015 super.onCreate(icicle); 1016 SecurityFeatureProvider securityFeatureProvider = 1017 FeatureFactory.getFactory(getActivity()).getSecurityFeatureProvider(); 1018 mTrustAgentManager = securityFeatureProvider.getTrustAgentManager(); 1019 mLockPatternUtils = new LockPatternUtils(getContext()); 1020 mDPM = getContext().getSystemService(DevicePolicyManager.class); 1021 mOwnerInfoPreferenceController = 1022 new OwnerInfoPreferenceController(getContext(), this, null /* lifecycle */); 1023 createPreferenceHierarchy(); 1024 } 1025 1026 @Override 1027 public void onResume() { 1028 super.onResume(); 1029 1030 createPreferenceHierarchy(); 1031 1032 if (mVisiblePattern != null) { 1033 mVisiblePattern.setChecked(mLockPatternUtils.isVisiblePatternEnabled( 1034 MY_USER_ID)); 1035 } 1036 if (mPowerButtonInstantlyLocks != null) { 1037 mPowerButtonInstantlyLocks.setChecked( 1038 mLockPatternUtils.getPowerButtonInstantlyLocks(MY_USER_ID)); 1039 } 1040 1041 mOwnerInfoPreferenceController.updateSummary(); 1042 } 1043 1044 @Override 1045 public void onActivityResult(int requestCode, int resultCode, Intent data) { 1046 super.onActivityResult(requestCode, resultCode, data); 1047 1048 createPreferenceHierarchy(); 1049 } 1050 1051 private void createPreferenceHierarchy() { 1052 PreferenceScreen root = getPreferenceScreen(); 1053 if (root != null) { 1054 root.removeAll(); 1055 } 1056 1057 final int resid = getResIdForLockUnlockSubScreen(getActivity(), 1058 new LockPatternUtils(getContext()), 1059 ManagedLockPasswordProvider.get(getContext(), MY_USER_ID)); 1060 addPreferencesFromResource(resid); 1061 1062 // lock after preference 1063 mLockAfter = (TimeoutListPreference) findPreference(KEY_LOCK_AFTER_TIMEOUT); 1064 if (mLockAfter != null) { 1065 setupLockAfterPreference(); 1066 updateLockAfterPreferenceSummary(); 1067 } 1068 1069 // visible pattern 1070 mVisiblePattern = (SwitchPreference) findPreference(KEY_VISIBLE_PATTERN); 1071 1072 // lock instantly on power key press 1073 mPowerButtonInstantlyLocks = (SwitchPreference) findPreference( 1074 KEY_POWER_INSTANTLY_LOCKS); 1075 CharSequence trustAgentLabel = getActiveTrustAgentLabel(getContext(), 1076 mTrustAgentManager, mLockPatternUtils, mDPM); 1077 if (mPowerButtonInstantlyLocks != null && !TextUtils.isEmpty(trustAgentLabel)) { 1078 mPowerButtonInstantlyLocks.setSummary(getString( 1079 R.string.lockpattern_settings_power_button_instantly_locks_summary, 1080 trustAgentLabel)); 1081 } 1082 1083 mOwnerInfoPreferenceController.displayPreference(getPreferenceScreen()); 1084 mOwnerInfoPreferenceController.updateEnableState(); 1085 1086 for (int i = 0; i < SWITCH_PREFERENCE_KEYS.length; i++) { 1087 final Preference pref = findPreference(SWITCH_PREFERENCE_KEYS[i]); 1088 if (pref != null) pref.setOnPreferenceChangeListener(this); 1089 } 1090 } 1091 1092 private void setupLockAfterPreference() { 1093 // Compatible with pre-Froyo 1094 long currentTimeout = Settings.Secure.getLong(getContentResolver(), 1095 Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT, 5000); 1096 mLockAfter.setValue(String.valueOf(currentTimeout)); 1097 mLockAfter.setOnPreferenceChangeListener(this); 1098 if (mDPM != null) { 1099 final EnforcedAdmin admin = RestrictedLockUtils.checkIfMaximumTimeToLockIsSet( 1100 getActivity()); 1101 final long adminTimeout = mDPM 1102 .getMaximumTimeToLockForUserAndProfiles(UserHandle.myUserId()); 1103 final long displayTimeout = Math.max(0, 1104 Settings.System.getInt(getContentResolver(), SCREEN_OFF_TIMEOUT, 0)); 1105 // This setting is a slave to display timeout when a device policy is enforced. 1106 // As such, maxLockTimeout = adminTimeout - displayTimeout. 1107 // If there isn't enough time, shows "immediately" setting. 1108 final long maxTimeout = Math.max(0, adminTimeout - displayTimeout); 1109 mLockAfter.removeUnusableTimeouts(maxTimeout, admin); 1110 } 1111 } 1112 1113 private void updateLockAfterPreferenceSummary() { 1114 final String summary; 1115 if (mLockAfter.isDisabledByAdmin()) { 1116 summary = getString(R.string.disabled_by_policy_title); 1117 } else { 1118 // Update summary message with current value 1119 long currentTimeout = Settings.Secure.getLong(getContentResolver(), 1120 Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT, 5000); 1121 final CharSequence[] entries = mLockAfter.getEntries(); 1122 final CharSequence[] values = mLockAfter.getEntryValues(); 1123 int best = 0; 1124 for (int i = 0; i < values.length; i++) { 1125 long timeout = Long.valueOf(values[i].toString()); 1126 if (currentTimeout >= timeout) { 1127 best = i; 1128 } 1129 } 1130 1131 CharSequence trustAgentLabel = getActiveTrustAgentLabel(getContext(), 1132 mTrustAgentManager, mLockPatternUtils, mDPM); 1133 if (!TextUtils.isEmpty(trustAgentLabel)) { 1134 if (Long.valueOf(values[best].toString()) == 0) { 1135 summary = getString(R.string.lock_immediately_summary_with_exception, 1136 trustAgentLabel); 1137 } else { 1138 summary = getString(R.string.lock_after_timeout_summary_with_exception, 1139 entries[best], trustAgentLabel); 1140 } 1141 } else { 1142 summary = getString(R.string.lock_after_timeout_summary, entries[best]); 1143 } 1144 } 1145 mLockAfter.setSummary(summary); 1146 } 1147 1148 @Override 1149 public void onOwnerInfoUpdated() { 1150 mOwnerInfoPreferenceController.updateSummary(); 1151 } 1152 1153 private static int getResIdForLockUnlockSubScreen(Context context, 1154 LockPatternUtils lockPatternUtils, 1155 ManagedLockPasswordProvider managedPasswordProvider) { 1156 if (lockPatternUtils.isSecure(MY_USER_ID)) { 1157 switch (lockPatternUtils.getKeyguardStoredPasswordQuality(MY_USER_ID)) { 1158 case DevicePolicyManager.PASSWORD_QUALITY_SOMETHING: 1159 return R.xml.security_settings_pattern_sub; 1160 case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC: 1161 case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC_COMPLEX: 1162 return R.xml.security_settings_pin_sub; 1163 case DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC: 1164 case DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC: 1165 case DevicePolicyManager.PASSWORD_QUALITY_COMPLEX: 1166 return R.xml.security_settings_password_sub; 1167 case DevicePolicyManager.PASSWORD_QUALITY_MANAGED: 1168 return managedPasswordProvider.getResIdForLockUnlockSubScreen(); 1169 } 1170 } else if (!lockPatternUtils.isLockScreenDisabled(MY_USER_ID)) { 1171 return R.xml.security_settings_slide_sub; 1172 } 1173 return 0; 1174 } 1175 1176 @Override 1177 public boolean onPreferenceChange(Preference preference, Object value) { 1178 String key = preference.getKey(); 1179 if (KEY_POWER_INSTANTLY_LOCKS.equals(key)) { 1180 mLockPatternUtils.setPowerButtonInstantlyLocks((Boolean) value, MY_USER_ID); 1181 } else if (KEY_LOCK_AFTER_TIMEOUT.equals(key)) { 1182 int timeout = Integer.parseInt((String) value); 1183 try { 1184 Settings.Secure.putInt(getContentResolver(), 1185 Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT, timeout); 1186 } catch (NumberFormatException e) { 1187 Log.e("SecuritySettings", "could not persist lockAfter timeout setting", e); 1188 } 1189 setupLockAfterPreference(); 1190 updateLockAfterPreferenceSummary(); 1191 } else if (KEY_VISIBLE_PATTERN.equals(key)) { 1192 mLockPatternUtils.setVisiblePatternEnabled((Boolean) value, MY_USER_ID); 1193 } 1194 return true; 1195 } 1196 } 1197 1198 public static class UnificationConfirmationDialog extends InstrumentedDialogFragment { 1199 private static final String EXTRA_COMPLIANT = "compliant"; 1200 1201 public static UnificationConfirmationDialog newIntance(boolean compliant) { 1202 UnificationConfirmationDialog dialog = new UnificationConfirmationDialog(); 1203 Bundle args = new Bundle(); 1204 args.putBoolean(EXTRA_COMPLIANT, compliant); 1205 dialog.setArguments(args); 1206 return dialog; 1207 } 1208 1209 @Override 1210 public void show(FragmentManager manager, String tag) { 1211 if (manager.findFragmentByTag(tag) == null) { 1212 // Prevent opening multiple dialogs if tapped on button quickly 1213 super.show(manager, tag); 1214 } 1215 } 1216 1217 @Override 1218 public Dialog onCreateDialog(Bundle savedInstanceState) { 1219 final SecuritySettings parentFragment = ((SecuritySettings) getParentFragment()); 1220 final boolean compliant = getArguments().getBoolean(EXTRA_COMPLIANT); 1221 return new AlertDialog.Builder(getActivity()) 1222 .setTitle(R.string.lock_settings_profile_unification_dialog_title) 1223 .setMessage(compliant ? R.string.lock_settings_profile_unification_dialog_body 1224 : R.string.lock_settings_profile_unification_dialog_uncompliant_body) 1225 .setPositiveButton( 1226 compliant ? R.string.lock_settings_profile_unification_dialog_confirm 1227 : R.string.lock_settings_profile_unification_dialog_uncompliant_confirm, 1228 new DialogInterface.OnClickListener() { 1229 @Override 1230 public void onClick(DialogInterface dialog, int whichButton) { 1231 if (compliant) { 1232 parentFragment.launchConfirmDeviceLockForUnification(); 1233 } else { 1234 parentFragment.unifyUncompliantLocks(); 1235 } 1236 } 1237 } 1238 ) 1239 .setNegativeButton(R.string.cancel, null) 1240 .create(); 1241 } 1242 1243 @Override 1244 public void onDismiss(DialogInterface dialog) { 1245 super.onDismiss(dialog); 1246 ((SecuritySettings) getParentFragment()).updateUnificationPreference(); 1247 } 1248 1249 @Override 1250 public int getMetricsCategory() { 1251 return MetricsEvent.DIALOG_UNIFICATION_CONFIRMATION; 1252 } 1253 } 1254 1255 static class SummaryProvider implements SummaryLoader.SummaryProvider { 1256 1257 private final Context mContext; 1258 private final SummaryLoader mSummaryLoader; 1259 1260 public SummaryProvider(Context context, SummaryLoader summaryLoader) { 1261 mContext = context; 1262 mSummaryLoader = summaryLoader; 1263 } 1264 1265 @Override 1266 public void setListening(boolean listening) { 1267 if (listening) { 1268 final FingerprintManager fpm = 1269 Utils.getFingerprintManagerOrNull(mContext); 1270 if (fpm != null && fpm.isHardwareDetected()) { 1271 mSummaryLoader.setSummary(this, 1272 mContext.getString(R.string.security_dashboard_summary)); 1273 } else { 1274 mSummaryLoader.setSummary(this, mContext.getString( 1275 R.string.security_dashboard_summary_no_fingerprint)); 1276 } 1277 } 1278 } 1279 } 1280 1281 public static final SummaryLoader.SummaryProviderFactory SUMMARY_PROVIDER_FACTORY = 1282 new SummaryLoader.SummaryProviderFactory() { 1283 @Override 1284 public SummaryLoader.SummaryProvider createSummaryProvider(Activity activity, 1285 SummaryLoader summaryLoader) { 1286 return new SummaryProvider(activity, summaryLoader); 1287 } 1288 }; 1289 1290} 1291