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