android:value="com.android.settings.category.ia.homepage"/>
</activity>
- <activity-alias android:name="LocationDashboardAlias"
- android:targetActivity="Settings$LocationSettingsActivity">
- <intent-filter>
- <action android:name="com.android.settings.action.SETTINGS" />
- </intent-filter>
- <meta-data android:name="com.android.settings.category"
- android:value="com.android.settings.category.ia.security" />
- <meta-data android:name="com.android.settings.FRAGMENT_CLASS"
- android:value="com.android.settings.location.LocationSettings" />
- <meta-data android:name="com.android.settings.PRIMARY_PROFILE_CONTROLLED"
- android:value="true" />
- </activity-alias>
-
<activity-alias android:name="AccessibilityDashboardAlias"
android:targetActivity="Settings$AccessibilitySettingsActivity">
<intent-filter android:priority="2">
<string name="account_settings_title">Accounts</string>
<!-- Main Settings screen setting option title for the item to take you to the security screen -->
<string name="security_settings_title">Security & screen lock</string>
+ <!-- Security Settings screen setting option title for the item to take you to the encryption and credential screen -->
+ <string name="encryption_and_credential_settings_title">Encryption & credentials</string>
<!-- Main Settings screen setting option summary text for the item tot ake you to the security and location screen -->
<string name="security_settings_summary">Set My Location, screen unlock, SIM card lock, credential storage lock</string>
<!-- Main Settings screen setting option summary text for the item to take you to the CDMA security and location screen -->
<string name="cdma_security_settings_summary">Set My Location, screen unlock, credential storage lock</string>
<!-- In the security screen, the header title for settings related to Passwords-->
- <string name="security_passwords_title">Passwords</string>
+ <string name="security_passwords_title">Privacy</string>
<!-- Summary for settings preference disabled by administrator [CHAR LIMIT=50] -->
<string name="disabled_by_administrator_summary">Disabled by administrator</string>
<!-- In the security screen, the header title for security statuses -->
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 The Android Open Source Project
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"
+ android:title="@string/encryption_and_credential_settings_title">
+
+ <PreferenceCategory android:key="credentials_management"
+ android:title="@string/credentials_title"
+ android:persistent="false"
+ android:order="100">
+
+ <com.android.settingslib.RestrictedPreference android:key="credential_storage_type"
+ android:title="@string/credential_storage_type"
+ android:persistent="false" />
+
+ <Preference android:key="trusted_credentials"
+ android:title="@string/trusted_credentials"
+ android:summary="@string/trusted_credentials_summary"
+ android:persistent="false"
+ android:fragment="com.android.settings.TrustedCredentialsSettings"/>
+
+ <com.android.settingslib.RestrictedPreference android:key="user_credentials"
+ android:title="@string/user_credentials"
+ android:summary="@string/user_credentials_summary"
+ android:persistent="false"
+ android:fragment="com.android.settings.UserCredentialsSettings"/>
+
+ <com.android.settingslib.RestrictedPreference android:key="credentials_install"
+ android:title="@string/credentials_install"
+ android:summary="@string/credentials_install_summary"
+ android:persistent="false">
+
+ <intent android:action="android.credentials.INSTALL"
+ android:targetPackage="com.android.certinstaller"
+ android:targetClass="com.android.certinstaller.CertInstallerMain"/>
+
+ </com.android.settingslib.RestrictedPreference>
+
+ <com.android.settingslib.RestrictedPreference android:key="credentials_reset"
+ android:title="@string/credentials_reset"
+ android:summary="@string/credentials_reset_summary"
+ android:persistent="false">
+
+ <intent android:action="com.android.credentials.RESET"
+ android:targetPackage="com.android.settings"
+ android:targetClass="com.android.settings.CredentialStorage"/>
+
+ </com.android.settingslib.RestrictedPreference>
+
+ </PreferenceCategory>
+
+</PreferenceScreen>
-->
<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"
- xmlns:settings="http://schemas.android.com/apk/res/com.android.settings"
android:title="@string/security_settings_title">
- <PreferenceCategory android:key="sim_lock"
- android:title="@string/sim_lock_settings_title"
+ <PreferenceCategory android:title="@string/security_passwords_title"
android:persistent="false">
- <Preference android:key="sim_lock_settings"
- android:title="@string/sim_lock_settings_category"
- android:persistent="false">
-
- <intent android:action="android.intent.action.MAIN"
- android:targetPackage="com.android.settings"
- android:targetClass="com.android.settings.Settings$IccLockSettingsActivity"/>
-
+ <Preference
+ android:key="location"
+ android:title="@string/location_settings_title">
+ <intent android:action="android.settings.LOCATION_SOURCE_SETTINGS"/>
</Preference>
- </PreferenceCategory>
-
- <PreferenceCategory android:title="@string/security_passwords_title"
- android:persistent="false">
-
<SwitchPreference android:key="show_password"
android:title="@string/show_password"/>
</PreferenceCategory>
- <PreferenceCategory android:key="credentials_management"
- android:title="@string/credentials_title"
- android:persistent="false">
-
- <com.android.settingslib.RestrictedPreference android:key="credential_storage_type"
- android:title="@string/credential_storage_type"
- android:persistent="false" />
-
- <Preference android:key="trusted_credentials"
- android:title="@string/trusted_credentials"
- android:summary="@string/trusted_credentials_summary"
- android:persistent="false"
- android:fragment="com.android.settings.TrustedCredentialsSettings"/>
-
- <com.android.settingslib.RestrictedPreference android:key="user_credentials"
- android:title="@string/user_credentials"
- android:summary="@string/user_credentials_summary"
- android:persistent="false"
- android:fragment="com.android.settings.UserCredentialsSettings"/>
-
- <com.android.settingslib.RestrictedPreference android:key="credentials_install"
- android:title="@string/credentials_install"
- android:summary="@string/credentials_install_summary"
- android:persistent="false">
-
- <intent android:action="android.credentials.INSTALL"
- android:targetPackage="com.android.certinstaller"
- android:targetClass="com.android.certinstaller.CertInstallerMain"/>
-
- </com.android.settingslib.RestrictedPreference>
-
- <com.android.settingslib.RestrictedPreference android:key="credentials_reset"
- android:title="@string/credentials_reset"
- android:summary="@string/credentials_reset_summary"
- android:persistent="false">
-
- <intent android:action="com.android.credentials.RESET"
- android:targetPackage="com.android.settings"
- android:targetClass="com.android.settings.CredentialStorage"/>
-
- </com.android.settingslib.RestrictedPreference>
-
- </PreferenceCategory>
-
- <PreferenceCategory android:key="advanced_security"
- android:title="@string/advanced_security_title"
- android:persistent="false">
-
- <Preference android:key="manage_trust_agents"
- android:title="@string/manage_trust_agents"
- android:summary="@string/manage_trust_agents_summary"
- android:persistent="false"
- android:fragment="com.android.settings.TrustAgentSettings"/>
-
- <Preference
- android:key="screen_pinning_settings"
- android:title="@string/screen_pinning_title"
- android:summary="@string/switch_off_text"
- android:fragment="com.android.settings.ScreenPinningSettings"/>
-
- <Preference android:key="usage_access"
- android:title="@string/usage_access_title"
- android:fragment="com.android.settings.applications.ManageApplications">
- <extra
- android:name="classname"
- android:value="com.android.settings.Settings$UsageAccessSettingsActivity" />
- </Preference>
-
- </PreferenceCategory>
+ <Preference android:key="sim_lock_settings"
+ android:title="@string/sim_lock_settings_category"
+ android:persistent="false">
+
+ <intent android:action="android.intent.action.MAIN"
+ android:targetPackage="com.android.settings"
+ android:targetClass="com.android.settings.Settings$IccLockSettingsActivity"/>
+
+ </Preference>
+
+ <Preference
+ android:key="encryption_and_credential"
+ android:title="@string/encryption_and_credential_settings_title"
+ android:fragment="com.android.settings.EncryptionAndCredential"/>
+
+ <Preference android:key="manage_trust_agents"
+ android:title="@string/manage_trust_agents"
+ android:summary="@string/manage_trust_agents_summary"
+ android:persistent="false"
+ android:fragment="com.android.settings.TrustAgentSettings"/>
+
+ <Preference
+ android:key="screen_pinning_settings"
+ android:title="@string/screen_pinning_title"
+ android:summary="@string/switch_off_text"
+ android:fragment="com.android.settings.ScreenPinningSettings"/>
+
+ <Preference android:key="usage_access"
+ android:title="@string/usage_access_title"
+ android:fragment="com.android.settings.applications.ManageApplications">
+ <extra
+ android:name="classname"
+ android:value="com.android.settings.Settings$UsageAccessSettingsActivity" />
+ </Preference>
</PreferenceScreen>
--- /dev/null
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.settings;
+
+import android.app.Activity;
+import android.app.admin.DevicePolicyManager;
+import android.content.Context;
+import android.content.Intent;
+import android.content.res.Resources;
+import android.os.Bundle;
+import android.os.UserHandle;
+import android.os.UserManager;
+import android.provider.SearchIndexableResource;
+import android.security.KeyStore;
+import android.support.v7.preference.PreferenceGroup;
+import android.support.v7.preference.PreferenceScreen;
+
+import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
+import com.android.internal.widget.LockPatternUtils;
+import com.android.settings.dashboard.DashboardFragment;
+import com.android.settings.search.BaseSearchIndexProvider;
+import com.android.settings.search.Indexable;
+import com.android.settings.search.SearchIndexableRaw;
+import com.android.settingslib.RestrictedLockUtils;
+import com.android.settingslib.RestrictedPreference;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Encryption and Credential settings.
+ * TODO: Extends this from {@link DashboardFragment} instead
+ */
+public class EncryptionAndCredential extends SettingsPreferenceFragment implements Indexable {
+
+ private static final String TAG = "EncryptionAndCredential";
+
+ // Misc Settings
+ private static final String KEY_CREDENTIAL_STORAGE_TYPE = "credential_storage_type";
+ private static final String KEY_USER_CREDENTIALS = "user_credentials";
+ private static final String KEY_RESET_CREDENTIALS = "credentials_reset";
+ private static final String KEY_CREDENTIALS_INSTALL = "credentials_install";
+ private static final String KEY_CREDENTIALS_MANAGER = "credentials_management";
+
+ private static final int MY_USER_ID = UserHandle.myUserId();
+
+ private UserManager mUm;
+
+ private KeyStore mKeyStore;
+ private RestrictedPreference mResetCredentials;
+
+ private boolean mIsAdmin;
+
+ @Override
+ public int getMetricsCategory() {
+ return MetricsEvent.SECURITY;
+ }
+
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+
+ final Activity activity = getActivity();
+
+ mUm = UserManager.get(activity);
+ }
+
+ /**
+ * Important!
+ *
+ * Don't forget to update the SecuritySearchIndexProvider if you are doing any change in the
+ * logic or adding/removing preferences here.
+ */
+ private PreferenceScreen createPreferenceHierarchy() {
+ PreferenceScreen root = getPreferenceScreen();
+ if (root != null) {
+ root.removeAll();
+ }
+ addPreferencesFromResource(R.xml.encryption_and_credential);
+ root = getPreferenceScreen();
+
+ // Add options for device encryption
+ mIsAdmin = mUm.isAdminUser();
+
+ if (mIsAdmin) {
+ if (LockPatternUtils.isDeviceEncryptionEnabled()) {
+ // The device is currently encrypted.
+ addPreferencesFromResource(R.xml.security_settings_encrypted);
+ } else {
+ // This device supports encryption but isn't encrypted.
+ addPreferencesFromResource(R.xml.security_settings_unencrypted);
+ }
+ }
+
+
+ // Credential storage
+ mKeyStore = KeyStore.getInstance(); // needs to be initialized for onResume()
+
+ if (!RestrictedLockUtils.hasBaseUserRestriction(getActivity(),
+ UserManager.DISALLOW_CONFIG_CREDENTIALS, MY_USER_ID)) {
+ RestrictedPreference userCredentials = (RestrictedPreference) root.findPreference(
+ KEY_USER_CREDENTIALS);
+ userCredentials.checkRestrictionAndSetDisabled(
+ UserManager.DISALLOW_CONFIG_CREDENTIALS);
+ RestrictedPreference credentialStorageType = (RestrictedPreference) root.findPreference(
+ KEY_CREDENTIAL_STORAGE_TYPE);
+ credentialStorageType.checkRestrictionAndSetDisabled(
+ UserManager.DISALLOW_CONFIG_CREDENTIALS);
+ RestrictedPreference installCredentials = (RestrictedPreference) root.findPreference(
+ KEY_CREDENTIALS_INSTALL);
+ installCredentials.checkRestrictionAndSetDisabled(
+ UserManager.DISALLOW_CONFIG_CREDENTIALS);
+ mResetCredentials = (RestrictedPreference) root.findPreference(KEY_RESET_CREDENTIALS);
+ mResetCredentials.checkRestrictionAndSetDisabled(
+ UserManager.DISALLOW_CONFIG_CREDENTIALS);
+
+ final int storageSummaryRes =
+ mKeyStore.isHardwareBacked() ? R.string.credential_storage_type_hardware
+ : R.string.credential_storage_type_software;
+ credentialStorageType.setSummary(storageSummaryRes);
+ } else {
+ PreferenceGroup credentialsManager = (PreferenceGroup)
+ root.findPreference(KEY_CREDENTIALS_MANAGER);
+ credentialsManager.removePreference(root.findPreference(KEY_RESET_CREDENTIALS));
+ credentialsManager.removePreference(root.findPreference(KEY_CREDENTIALS_INSTALL));
+ credentialsManager.removePreference(root.findPreference(KEY_CREDENTIAL_STORAGE_TYPE));
+ credentialsManager.removePreference(root.findPreference(KEY_USER_CREDENTIALS));
+ }
+
+ return root;
+ }
+
+ @Override
+ public void onResume() {
+ super.onResume();
+
+ // Make sure we reload the preference hierarchy since some of these settings
+ // depend on others...
+ createPreferenceHierarchy();
+
+ if (mResetCredentials != null && !mResetCredentials.isDisabledByAdmin()) {
+ mResetCredentials.setEnabled(!mKeyStore.isEmpty());
+ }
+ }
+
+ /**
+ * see confirmPatternThenDisableAndClear
+ */
+ @Override
+ public void onActivityResult(int requestCode, int resultCode, Intent data) {
+ super.onActivityResult(requestCode, resultCode, data);
+ createPreferenceHierarchy();
+ }
+
+ @Override
+ protected int getHelpResource() {
+ return R.string.help_url_security;
+ }
+
+ /**
+ * For Search. Please keep it in sync when updating "createPreferenceHierarchy()"
+ */
+ public static final SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
+ new SecuritySearchIndexProvider();
+
+ private static class SecuritySearchIndexProvider extends BaseSearchIndexProvider {
+
+ @Override
+ public List<SearchIndexableResource> getXmlResourcesToIndex(
+ Context context, boolean enabled) {
+ final List<SearchIndexableResource> index = new ArrayList<SearchIndexableResource>();
+
+ final DevicePolicyManager dpm = (DevicePolicyManager)
+ context.getSystemService(Context.DEVICE_POLICY_SERVICE);
+ final UserManager um = UserManager.get(context);
+
+ if (um.isAdminUser()) {
+ switch (dpm.getStorageEncryptionStatus()) {
+ case DevicePolicyManager.ENCRYPTION_STATUS_ACTIVE:
+ // The device is currently encrypted.
+ index.add(getSearchResource(context, R.xml.security_settings_encrypted));
+ break;
+ case DevicePolicyManager.ENCRYPTION_STATUS_INACTIVE:
+ // This device supports encryption but isn't encrypted.
+ index.add(getSearchResource(context, R.xml.security_settings_unencrypted));
+ break;
+ }
+ }
+
+ return index;
+ }
+
+ private SearchIndexableResource getSearchResource(Context context, int xmlResId) {
+ final SearchIndexableResource sir = new SearchIndexableResource(context);
+ sir.xmlResId = xmlResId;
+ return sir;
+ }
+
+ @Override
+ public List<SearchIndexableRaw> getRawDataToIndex(Context context, boolean enabled) {
+ final List<SearchIndexableRaw> result = new ArrayList<SearchIndexableRaw>();
+ final Resources res = context.getResources();
+
+ final String screenTitle = res.getString(
+ R.string.encryption_and_credential_settings_title);
+
+ SearchIndexableRaw data = new SearchIndexableRaw(context);
+ data.title = screenTitle;
+ data.screenTitle = screenTitle;
+ result.add(data);
+
+ final UserManager um = UserManager.get(context);
+ if (!um.isAdminUser()) {
+ int resId = um.isLinkedUser() ?
+ R.string.profile_info_settings_title : R.string.user_info_settings_title;
+
+ data = new SearchIndexableRaw(context);
+ data.title = res.getString(resId);
+ data.screenTitle = screenTitle;
+ result.add(data);
+ }
+
+ // Credential storage
+ if (!um.hasUserRestriction(UserManager.DISALLOW_CONFIG_CREDENTIALS)) {
+ KeyStore keyStore = KeyStore.getInstance();
+
+ final int storageSummaryRes = keyStore.isHardwareBacked() ?
+ R.string.credential_storage_type_hardware :
+ R.string.credential_storage_type_software;
+
+ data = new SearchIndexableRaw(context);
+ data.title = res.getString(storageSummaryRes);
+ data.screenTitle = screenTitle;
+ result.add(data);
+ }
+
+ return result;
+ }
+
+ @Override
+ public List<String> getNonIndexableKeys(Context context) {
+ final List<String> keys = new ArrayList<String>();
+
+ final UserManager um = UserManager.get(context);
+
+ if (um.hasUserRestriction(UserManager.DISALLOW_CONFIG_CREDENTIALS)) {
+ keys.add(KEY_CREDENTIALS_MANAGER);
+ }
+
+ return keys;
+ }
+ }
+
+}
import android.content.ComponentName;
import android.content.Context;
import android.content.DialogInterface;
-import android.content.IContentProvider;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.os.UserManager;
import android.provider.SearchIndexableResource;
import android.provider.Settings;
-import android.security.KeyStore;
import android.service.trust.TrustAgentService;
import android.support.annotation.VisibleForTesting;
import android.support.v14.preference.SwitchPreference;
import com.android.settings.dashboard.DashboardFeatureProvider;
import com.android.settings.dashboard.SummaryLoader;
import com.android.settings.fingerprint.FingerprintSettings;
+import com.android.settings.location.LocationPreferenceController;
import com.android.settings.overlay.FeatureFactory;
import com.android.settings.search.BaseSearchIndexProvider;
import com.android.settings.search.Index;
private static final String KEY_VISIBLE_PATTERN_PROFILE = "visiblepattern_profile";
private static final String KEY_SECURITY_CATEGORY = "security_category";
private static final String KEY_DEVICE_ADMIN_CATEGORY = "device_admin_category";
- private static final String KEY_ADVANCED_SECURITY = "advanced_security";
private static final String KEY_MANAGE_TRUST_AGENTS = "manage_trust_agents";
private static final String KEY_UNIFICATION = "unification";
private static final String TAG_UNIFICATION_DIALOG = "unification_dialog";
// Misc Settings
- private static final String KEY_SIM_LOCK = "sim_lock";
+ private static final String KEY_SIM_LOCK = "sim_lock_settings";
private static final String KEY_SHOW_PASSWORD = "show_password";
- private static final String KEY_CREDENTIAL_STORAGE_TYPE = "credential_storage_type";
- private static final String KEY_USER_CREDENTIALS = "user_credentials";
- private static final String KEY_RESET_CREDENTIALS = "credentials_reset";
- private static final String KEY_CREDENTIALS_INSTALL = "credentials_install";
- private static final String KEY_CREDENTIALS_MANAGER = "credentials_management";
- private static final String PACKAGE_MIME_TYPE = "application/vnd.android.package-archive";
private static final String KEY_TRUST_AGENT = "trust_agent";
private static final String KEY_SCREEN_PINNING = "screen_pinning_settings";
private SwitchPreference mShowPassword;
- private KeyStore mKeyStore;
- private RestrictedPreference mResetCredentials;
-
private boolean mIsAdmin;
private Intent mTrustAgentClickIntent;
private String mCurrentDevicePassword;
private String mCurrentProfilePassword;
+ private LocationPreferenceController mLocationcontroller;
+
@Override
public int getMetricsCategory() {
return MetricsEvent.SECURITY;
&& savedInstanceState.containsKey(TRUST_AGENT_CLICK_INTENT)) {
mTrustAgentClickIntent = savedInstanceState.getParcelable(TRUST_AGENT_CLICK_INTENT);
}
+
+ mLocationcontroller = new LocationPreferenceController(activity);
}
private static int getResIdForLockUnlockScreen(Context context,
((GearPreference) unlockSetOrChange).setOnGearClickListener(this);
}
- // Add options for device encryption
mIsAdmin = mUm.isAdminUser();
- if (mIsAdmin) {
- if (LockPatternUtils.isDeviceEncryptionEnabled()) {
- // The device is currently encrypted.
- addPreferencesFromResource(R.xml.security_settings_encrypted);
- } else {
- // This device supports encryption but isn't encrypted.
- addPreferencesFromResource(R.xml.security_settings_unencrypted);
- }
- }
-
// Fingerprint and trust agents
PreferenceGroup securityCategory = (PreferenceGroup)
root.findPreference(KEY_SECURITY_CATEGORY);
// Show password
mShowPassword = (SwitchPreference) root.findPreference(KEY_SHOW_PASSWORD);
- mResetCredentials = (RestrictedPreference) root.findPreference(KEY_RESET_CREDENTIALS);
// Credential storage
final UserManager um = (UserManager) getActivity().getSystemService(Context.USER_SERVICE);
- mKeyStore = KeyStore.getInstance(); // needs to be initialized for onResume()
-
- if (!RestrictedLockUtils.hasBaseUserRestriction(getActivity(),
- UserManager.DISALLOW_CONFIG_CREDENTIALS, MY_USER_ID)) {
- RestrictedPreference userCredentials = (RestrictedPreference) root.findPreference(
- KEY_USER_CREDENTIALS);
- userCredentials.checkRestrictionAndSetDisabled(
- UserManager.DISALLOW_CONFIG_CREDENTIALS);
- RestrictedPreference credentialStorageType = (RestrictedPreference) root.findPreference(
- KEY_CREDENTIAL_STORAGE_TYPE);
- credentialStorageType.checkRestrictionAndSetDisabled(
- UserManager.DISALLOW_CONFIG_CREDENTIALS);
- RestrictedPreference installCredentials = (RestrictedPreference) root.findPreference(
- KEY_CREDENTIALS_INSTALL);
- installCredentials.checkRestrictionAndSetDisabled(
- UserManager.DISALLOW_CONFIG_CREDENTIALS);
- mResetCredentials.checkRestrictionAndSetDisabled(
- UserManager.DISALLOW_CONFIG_CREDENTIALS);
-
- final int storageSummaryRes =
- mKeyStore.isHardwareBacked() ? R.string.credential_storage_type_hardware
- : R.string.credential_storage_type_software;
- credentialStorageType.setSummary(storageSummaryRes);
- } else {
- PreferenceGroup credentialsManager = (PreferenceGroup)
- root.findPreference(KEY_CREDENTIALS_MANAGER);
- credentialsManager.removePreference(root.findPreference(KEY_RESET_CREDENTIALS));
- credentialsManager.removePreference(root.findPreference(KEY_CREDENTIALS_INSTALL));
- credentialsManager.removePreference(root.findPreference(KEY_CREDENTIAL_STORAGE_TYPE));
- credentialsManager.removePreference(root.findPreference(KEY_USER_CREDENTIALS));
- }
-
// Application install
PreferenceGroup deviceAdminCategory = (PreferenceGroup)
root.findPreference(KEY_DEVICE_ADMIN_CATEGORY);
// Advanced Security features
- PreferenceGroup advancedCategory =
- (PreferenceGroup)root.findPreference(KEY_ADVANCED_SECURITY);
- if (advancedCategory != null) {
- Preference manageAgents = advancedCategory.findPreference(KEY_MANAGE_TRUST_AGENTS);
- if (manageAgents != null && !mLockPatternUtils.isSecure(MY_USER_ID)) {
- manageAgents.setEnabled(false);
- manageAgents.setSummary(R.string.disabled_because_no_backup_security);
- }
+ Preference manageAgents = root.findPreference(KEY_MANAGE_TRUST_AGENTS);
+ if (manageAgents != null && !mLockPatternUtils.isSecure(MY_USER_ID)) {
+ manageAgents.setEnabled(false);
+ manageAgents.setSummary(R.string.disabled_because_no_backup_security);
}
// The above preferences come and go based on security state, so we need to update
final Preference pref = findPreference(SWITCH_PREFERENCE_KEYS[i]);
if (pref != null) pref.setOnPreferenceChangeListener(this);
}
+
+ mLocationcontroller.displayPreference(root);
return root;
}
Settings.System.TEXT_SHOW_PASSWORD, 1) != 0);
}
- if (mResetCredentials != null && !mResetCredentials.isDisabledByAdmin()) {
- mResetCredentials.setEnabled(!mKeyStore.isEmpty());
- }
+ mLocationcontroller.updateSummary();
}
private void updateUnificationPreference() {
lockPatternUtils, managedPasswordProvider, profileUserId)));
}
- if (um.isAdminUser()) {
- switch (dpm.getStorageEncryptionStatus()) {
- case DevicePolicyManager.ENCRYPTION_STATUS_ACTIVE:
- // The device is currently encrypted.
- index.add(getSearchResource(context, R.xml.security_settings_encrypted));
- break;
- case DevicePolicyManager.ENCRYPTION_STATUS_INACTIVE:
- // This device supports encryption but isn't encrypted.
- index.add(getSearchResource(context, R.xml.security_settings_unencrypted));
- break;
- }
- }
-
final SearchIndexableResource sir = getSearchResource(context,
SecuritySubSettings.getResIdForLockUnlockSubScreen(context, lockPatternUtils,
managedPasswordProvider));
result.add(data);
final UserManager um = UserManager.get(context);
- if (!um.isAdminUser()) {
- int resId = um.isLinkedUser() ?
- R.string.profile_info_settings_title : R.string.user_info_settings_title;
-
- data = new SearchIndexableRaw(context);
- data.title = res.getString(resId);
- data.screenTitle = screenTitle;
- result.add(data);
- }
// Fingerprint
final FingerprintManager fpm = Utils.getFingerprintManagerOrNull(context);
}
}
- // Credential storage
- if (!um.hasUserRestriction(UserManager.DISALLOW_CONFIG_CREDENTIALS)) {
- KeyStore keyStore = KeyStore.getInstance();
-
- final int storageSummaryRes = keyStore.isHardwareBacked() ?
- R.string.credential_storage_type_hardware :
- R.string.credential_storage_type_software;
-
- data = new SearchIndexableRaw(context);
- data.title = res.getString(storageSummaryRes);
- data.screenTitle = screenTitle;
- result.add(data);
- }
-
// Advanced
if (lockPatternUtils.isSecure(MY_USER_ID)) {
final TrustAgentManager trustAgentManager =
keys.add(KEY_SIM_LOCK);
}
- if (um.hasUserRestriction(UserManager.DISALLOW_CONFIG_CREDENTIALS)) {
- keys.add(KEY_CREDENTIALS_MANAGER);
- }
-
// TrustAgent settings disappear when the user has no primary security.
if (!lockPatternUtils.isSecure(MY_USER_ID)) {
keys.add(KEY_TRUST_AGENT);
"com.android.settings.PaymentSettingsDashboardAlias",
// Home page > Network & Internet
"com.android.settings.DataUsageDashboardAlias",
- // Home page > Security
- "com.android.settings.LocationDashboardAlias",
// Home page > System
Settings.LanguageAndInputSettingsActivity.class.getName(),
"com.android.settings.DateTimeDashboardAlias",
--- /dev/null
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.settings.location;
+
+import android.content.Context;
+import android.provider.Settings.Secure;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceScreen;
+import com.android.settings.R;
+import com.android.settings.core.PreferenceController;
+
+public class LocationPreferenceController extends PreferenceController {
+
+ private static final String KEY_LOCATION = "location";
+ private Preference mPreference;
+
+ public LocationPreferenceController(Context context) {
+ super(context);
+ }
+
+ @Override
+ public void displayPreference(PreferenceScreen screen) {
+ super.displayPreference(screen);
+ mPreference = screen.findPreference(KEY_LOCATION);
+ }
+
+ @Override
+ public void updateState(Preference preference) {
+ preference.setSummary(getLocationSummary(mContext));
+ }
+
+ @Override
+ public String getPreferenceKey() {
+ return KEY_LOCATION;
+ }
+
+ @Override
+ public boolean isAvailable() {
+ return true;
+ }
+
+ public void updateSummary() {
+ updateState(mPreference);
+ }
+
+ public static String getLocationSummary(Context context) {
+ int mode = Secure.getInt(context.getContentResolver(),
+ Secure.LOCATION_MODE, Secure.LOCATION_MODE_OFF);
+ if (mode != Secure.LOCATION_MODE_OFF) {
+ return context.getString(R.string.location_on_summary,
+ context.getString(getLocationString(mode)));
+ }
+ return context.getString(R.string.location_off_summary);
+ }
+
+ public static int getLocationString(int mode) {
+ switch (mode) {
+ case Secure.LOCATION_MODE_OFF:
+ return R.string.location_mode_location_off_title;
+ case Secure.LOCATION_MODE_SENSORS_ONLY:
+ return R.string.location_mode_sensors_only_title;
+ case Secure.LOCATION_MODE_BATTERY_SAVING:
+ return R.string.location_mode_battery_saving_title;
+ case Secure.LOCATION_MODE_HIGH_ACCURACY:
+ return R.string.location_mode_high_accuracy_title;
+ }
+ return 0;
+ }
+
+}
return R.string.help_url_location_access;
}
- private static int getLocationString(int mode) {
- switch (mode) {
- case android.provider.Settings.Secure.LOCATION_MODE_OFF:
- return R.string.location_mode_location_off_title;
- case android.provider.Settings.Secure.LOCATION_MODE_SENSORS_ONLY:
- return R.string.location_mode_sensors_only_title;
- case android.provider.Settings.Secure.LOCATION_MODE_BATTERY_SAVING:
- return R.string.location_mode_battery_saving_title;
- case android.provider.Settings.Secure.LOCATION_MODE_HIGH_ACCURACY:
- return R.string.location_mode_high_accuracy_title;
- }
- return 0;
- }
-
@Override
public void onModeChanged(int mode, boolean restricted) {
- int modeDescription = getLocationString(mode);
+ int modeDescription = LocationPreferenceController.getLocationString(mode);
if (modeDescription != 0) {
mLocationMode.setSummary(modeDescription);
}
@Override
public void setListening(boolean listening) {
if (listening) {
- int mode = Settings.Secure.getInt(mContext.getContentResolver(),
- Settings.Secure.LOCATION_MODE, Settings.Secure.LOCATION_MODE_OFF);
- if (mode != Settings.Secure.LOCATION_MODE_OFF) {
- mSummaryLoader.setSummary(this, mContext.getString(R.string.location_on_summary,
- mContext.getString(getLocationString(mode))));
- } else {
- mSummaryLoader.setSummary(this,
- mContext.getString(R.string.location_off_summary));
- }
+ mSummaryLoader.setSummary(
+ this, LocationPreferenceController.getLocationSummary(mContext));
}
}
}
import com.android.settings.DevelopmentSettings;
import com.android.settings.DeviceInfoSettings;
import com.android.settings.DisplaySettings;
+import com.android.settings.EncryptionAndCredential;
import com.android.settings.LegalSettings;
import com.android.settings.PrivacySettings;
import com.android.settings.R;
addIndex(LocationSettings.class, R.xml.location_settings, R.drawable.ic_settings_location);
addIndex(ScanningSettings.class, R.xml.location_scanning, R.drawable.ic_settings_location);
addIndex(SecuritySettings.class, NO_DATA_RES_ID, R.drawable.ic_settings_security);
+ addIndex(EncryptionAndCredential.class, R.xml.encryption_and_credential,
+ R.drawable.ic_settings_security);
addIndex(ScreenPinningSettings.class, NO_DATA_RES_ID, R.drawable.ic_settings_security);
addIndex(AccountSettings.class, NO_DATA_RES_ID, R.drawable.ic_settings_accounts);
addIndex(UserAndAccountDashboardFragment.class, NO_DATA_RES_ID,
--- /dev/null
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.settings.location;
+
+import android.content.Context;
+import android.provider.Settings.Secure;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceScreen;
+
+import com.android.settings.R;
+import com.android.settings.SettingsRobolectricTestRunner;
+import com.android.settings.TestConfig;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Answers;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.annotation.Config;
+import org.robolectric.shadows.ShadowApplication;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
+public class LocationPreferenceControllerTest {
+ @Mock
+ private Preference mPreference;
+ @Mock
+ private PreferenceScreen mScreen;
+
+ private LocationPreferenceController mController;
+
+ @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+ private Context mContext;
+
+ @Before
+ public void setUp() {
+ MockitoAnnotations.initMocks(this);
+ mController = new LocationPreferenceController(mContext);
+ when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference);
+ }
+
+ @Test
+ public void isAvailable_shouldReturnTrue() {
+ assertThat(mController.isAvailable()).isTrue();
+ }
+
+ @Test
+ public void updateState_shouldSetSummary() {
+ mController.updateState(mPreference);
+
+ verify(mPreference).setSummary(anyString());
+ }
+
+ @Test
+ public void updateSummary_shouldSetSummary() {
+ mController.displayPreference(mScreen);
+ mController.updateSummary();
+
+ verify(mPreference).setSummary(anyString());
+ }
+
+ @Test
+ public void getLocationSummary_locationOff_shouldSetSummaryOff() {
+ Secure.putInt(mContext.getContentResolver(),
+ Secure.LOCATION_MODE, Secure.LOCATION_MODE_OFF);
+
+ assertThat(mController.getLocationSummary(mContext)).isEqualTo(
+ mContext.getString(R.string.location_off_summary));
+ }
+
+ @Test
+ public void getLocationSummary_sensorsOnly_shouldSetSummarySensorsOnly() {
+ Secure.putInt(mContext.getContentResolver(),
+ Secure.LOCATION_MODE, Secure.LOCATION_MODE_SENSORS_ONLY);
+
+ assertThat(mController.getLocationSummary(mContext)).isEqualTo(
+ mContext.getString(R.string.location_on_summary,
+ mContext.getString(R.string.location_mode_sensors_only_title)));
+ }
+
+ @Test
+ public void getLocationSummary_highAccuracy_shouldSetSummarHighAccuracy() {
+ Secure.putInt(mContext.getContentResolver(),
+ Secure.LOCATION_MODE, Secure.LOCATION_MODE_HIGH_ACCURACY);
+
+ assertThat(mController.getLocationSummary(mContext)).isEqualTo(
+ mContext.getString(R.string.location_on_summary,
+ mContext.getString(R.string.location_mode_high_accuracy_title)));
+ }
+
+ @Test
+ public void getLocationSummary_batterySaving_shouldSetSummaryBatterySaving() {
+ Secure.putInt(mContext.getContentResolver(),
+ Secure.LOCATION_MODE, Secure.LOCATION_MODE_BATTERY_SAVING);
+
+ assertThat(mController.getLocationSummary(mContext)).isEqualTo(
+ mContext.getString(R.string.location_on_summary,
+ mContext.getString(R.string.location_mode_battery_saving_title)));
+ }
+
+ @Test
+ public void getLocationString_shouldCorrectString() {
+ assertThat(mController.getLocationString(Secure.LOCATION_MODE_OFF)).isEqualTo(
+ R.string.location_mode_location_off_title);
+ assertThat(mController.getLocationString(Secure.LOCATION_MODE_SENSORS_ONLY)).isEqualTo(
+ R.string.location_mode_sensors_only_title);
+ assertThat(mController.getLocationString(Secure.LOCATION_MODE_BATTERY_SAVING)).isEqualTo(
+ R.string.location_mode_battery_saving_title);
+ assertThat(mController.getLocationString(Secure.LOCATION_MODE_HIGH_ACCURACY)).isEqualTo(
+ R.string.location_mode_high_accuracy_title);
+ }
+
+}
OSDN Git Service
