PrivacySettings.java revision ddb953fb730fd0c0645561cb237cba0199a89534
1/* 2 * Copyright (C) 2009 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 android.app.Activity; 20import android.app.backup.IBackupManager; 21import android.content.ContentResolver; 22import android.content.Context; 23import android.content.Intent; 24import android.os.Bundle; 25import android.os.RemoteException; 26import android.os.ServiceManager; 27import android.os.UserHandle; 28import android.os.UserManager; 29import android.provider.SearchIndexableResource; 30import android.provider.Settings; 31import android.support.v14.preference.SwitchPreference; 32import android.support.v7.preference.Preference; 33import android.support.v7.preference.Preference.OnPreferenceChangeListener; 34import android.support.v7.preference.PreferenceScreen; 35import android.util.Log; 36 37import com.android.internal.logging.MetricsLogger; 38import com.android.settings.dashboard.SummaryLoader; 39import com.android.settings.search.BaseSearchIndexProvider; 40import com.android.settings.search.Indexable; 41import com.android.settingslib.RestrictedPreference; 42 43import java.util.ArrayList; 44import java.util.Collection; 45import java.util.HashSet; 46import java.util.List; 47import java.util.Set; 48 49/** 50 * Gesture lock pattern settings. 51 */ 52public class PrivacySettings extends SettingsPreferenceFragment implements Indexable { 53 54 // Vendor specific 55 private static final String GSETTINGS_PROVIDER = "com.google.settings"; 56 private static final String BACKUP_DATA = "backup_data"; 57 private static final String AUTO_RESTORE = "auto_restore"; 58 private static final String CONFIGURE_ACCOUNT = "configure_account"; 59 private static final String DATA_MANAGEMENT = "data_management"; 60 private static final String BACKUP_INACTIVE = "backup_inactive"; 61 private static final String NETWORK_RESET = "network_reset"; 62 private static final String FACTORY_RESET = "factory_reset"; 63 private static final String TAG = "PrivacySettings"; 64 private IBackupManager mBackupManager; 65 private PreferenceScreen mBackup; 66 private SwitchPreference mAutoRestore; 67 private PreferenceScreen mConfigure; 68 private PreferenceScreen mManageData; 69 private boolean mEnabled; 70 71 @Override 72 protected int getMetricsCategory() { 73 return MetricsLogger.PRIVACY; 74 } 75 76 @Override 77 public void onCreate(Bundle savedInstanceState) { 78 super.onCreate(savedInstanceState); 79 // Don't allow any access if this is not an admin user. 80 // TODO: backup/restore currently only works with owner user b/22760572 81 mEnabled = UserManager.get(getActivity()).isAdminUser(); 82 if (!mEnabled) { 83 return; 84 } 85 86 addPreferencesFromResource(R.xml.privacy_settings); 87 final PreferenceScreen screen = getPreferenceScreen(); 88 mBackupManager = IBackupManager.Stub.asInterface( 89 ServiceManager.getService(Context.BACKUP_SERVICE)); 90 91 mBackup = (PreferenceScreen) screen.findPreference(BACKUP_DATA); 92 93 mAutoRestore = (SwitchPreference) screen.findPreference(AUTO_RESTORE); 94 mAutoRestore.setOnPreferenceChangeListener(preferenceChangeListener); 95 96 mConfigure = (PreferenceScreen) screen.findPreference(CONFIGURE_ACCOUNT); 97 mManageData = (PreferenceScreen) screen.findPreference(DATA_MANAGEMENT); 98 99 Set<String> keysToRemove = new HashSet<>(); 100 getNonVisibleKeys(getActivity(), keysToRemove); 101 final int screenPreferenceCount = screen.getPreferenceCount(); 102 for (int i = screenPreferenceCount - 1; i >= 0; --i) { 103 Preference preference = screen.getPreference(i); 104 if (keysToRemove.contains(preference.getKey())) { 105 screen.removePreference(preference); 106 } 107 } 108 109 updateToggles(); 110 } 111 112 @Override 113 public void onResume() { 114 super.onResume(); 115 116 // Refresh UI 117 if (mEnabled) { 118 updateToggles(); 119 } 120 } 121 122 private OnPreferenceChangeListener preferenceChangeListener = new OnPreferenceChangeListener() { 123 @Override 124 public boolean onPreferenceChange(Preference preference, Object newValue) { 125 if (!(preference instanceof SwitchPreference)) { 126 return true; 127 } 128 boolean nextValue = (Boolean) newValue; 129 boolean result = false; 130 if (preference == mAutoRestore) { 131 try { 132 mBackupManager.setAutoRestore(nextValue); 133 result = true; 134 } catch (RemoteException e) { 135 mAutoRestore.setChecked(!nextValue); 136 } 137 } 138 return result; 139 } 140 }; 141 142 143 /* 144 * Creates toggles for each backup/reset preference. 145 */ 146 private void updateToggles() { 147 ContentResolver res = getContentResolver(); 148 149 boolean backupEnabled = false; 150 Intent configIntent = null; 151 String configSummary = null; 152 Intent manageIntent = null; 153 String manageLabel = null; 154 try { 155 backupEnabled = mBackupManager.isBackupEnabled(); 156 String transport = mBackupManager.getCurrentTransport(); 157 configIntent = mBackupManager.getConfigurationIntent(transport); 158 configSummary = mBackupManager.getDestinationString(transport); 159 manageIntent = mBackupManager.getDataManagementIntent(transport); 160 manageLabel = mBackupManager.getDataManagementLabel(transport); 161 162 mBackup.setSummary(backupEnabled 163 ? R.string.accessibility_feature_state_on 164 : R.string.accessibility_feature_state_off); 165 } catch (RemoteException e) { 166 // leave it 'false' and disable the UI; there's no backup manager 167 mBackup.setEnabled(false); 168 } 169 170 mAutoRestore.setChecked(Settings.Secure.getInt(res, 171 Settings.Secure.BACKUP_AUTO_RESTORE, 1) == 1); 172 mAutoRestore.setEnabled(backupEnabled); 173 174 final boolean configureEnabled = (configIntent != null) && backupEnabled; 175 mConfigure.setEnabled(configureEnabled); 176 mConfigure.setIntent(configIntent); 177 setConfigureSummary(configSummary); 178 179 final boolean manageEnabled = (manageIntent != null) && backupEnabled; 180 if (manageEnabled) { 181 mManageData.setIntent(manageIntent); 182 if (manageLabel != null) { 183 mManageData.setTitle(manageLabel); 184 } 185 } else { 186 // Hide the item if data management intent is not supported by transport. 187 getPreferenceScreen().removePreference(mManageData); 188 } 189 190 RestrictedPreference networkResetPref = (RestrictedPreference) findPreference( 191 NETWORK_RESET); 192 if (networkResetPref != null) { 193 networkResetPref.checkRestrictionAndSetDisabled(UserManager.DISALLOW_NETWORK_RESET); 194 } 195 } 196 197 private void setConfigureSummary(String summary) { 198 if (summary != null) { 199 mConfigure.setSummary(summary); 200 } else { 201 mConfigure.setSummary(R.string.backup_configure_account_default_summary); 202 } 203 } 204 205 @Override 206 protected int getHelpResource() { 207 return R.string.help_url_backup_reset; 208 } 209 210 private static class SummaryProvider implements SummaryLoader.SummaryProvider { 211 212 private final Context mContext; 213 private final SummaryLoader mSummaryLoader; 214 215 public SummaryProvider(Context context, SummaryLoader summaryLoader) { 216 mContext = context; 217 mSummaryLoader = summaryLoader; 218 } 219 220 @Override 221 public void setListening(boolean listening) { 222 if (listening) { 223 IBackupManager backupManager = IBackupManager.Stub.asInterface( 224 ServiceManager.getService(Context.BACKUP_SERVICE)); 225 try { 226 boolean backupEnabled = backupManager.isBackupEnabled(); 227 if (backupEnabled) { 228 String transport = backupManager.getCurrentTransport(); 229 String configSummary = backupManager.getDestinationString(transport); 230 if (configSummary != null) { 231 mSummaryLoader.setSummary(this, configSummary); 232 } else { 233 mSummaryLoader.setSummary(this, mContext.getString( 234 R.string.backup_configure_account_default_summary)); 235 } 236 } else { 237 mSummaryLoader.setSummary(this, mContext.getString( 238 R.string.backup_disabled)); 239 } 240 } catch (RemoteException e) { 241 } 242 } 243 } 244 } 245 246 public static final SummaryLoader.SummaryProviderFactory SUMMARY_PROVIDER_FACTORY 247 = new SummaryLoader.SummaryProviderFactory() { 248 @Override 249 public SummaryLoader.SummaryProvider createSummaryProvider(Activity activity, 250 SummaryLoader summaryLoader) { 251 return new SummaryProvider(activity, summaryLoader); 252 } 253 }; 254 255 /** 256 * For Search. 257 */ 258 public static final SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = 259 new PrivacySearchIndexProvider(); 260 261 private static class PrivacySearchIndexProvider extends BaseSearchIndexProvider { 262 263 boolean mIsPrimary; 264 265 public PrivacySearchIndexProvider() { 266 super(); 267 268 mIsPrimary = UserHandle.myUserId() == UserHandle.USER_SYSTEM; 269 } 270 271 @Override 272 public List<SearchIndexableResource> getXmlResourcesToIndex( 273 Context context, boolean enabled) { 274 275 List<SearchIndexableResource> result = new ArrayList<SearchIndexableResource>(); 276 277 // For non-primary user, no backup or reset is available 278 // TODO: http://b/22388012 279 if (!mIsPrimary) { 280 return result; 281 } 282 283 SearchIndexableResource sir = new SearchIndexableResource(context); 284 sir.xmlResId = R.xml.privacy_settings; 285 result.add(sir); 286 287 return result; 288 } 289 290 @Override 291 public List<String> getNonIndexableKeys(Context context) { 292 final List<String> nonVisibleKeys = new ArrayList<>(); 293 getNonVisibleKeys(context, nonVisibleKeys); 294 return nonVisibleKeys; 295 } 296 } 297 298 private static void getNonVisibleKeys(Context context, Collection<String> nonVisibleKeys) { 299 final IBackupManager backupManager = IBackupManager.Stub.asInterface( 300 ServiceManager.getService(Context.BACKUP_SERVICE)); 301 boolean isServiceActive = false; 302 try { 303 isServiceActive = backupManager.isBackupServiceActive(UserHandle.myUserId()); 304 } catch (RemoteException e) { 305 Log.w(TAG, "Failed querying backup manager service activity status. " + 306 "Assuming it is inactive."); 307 } 308 boolean vendorSpecific = context.getPackageManager(). 309 resolveContentProvider(GSETTINGS_PROVIDER, 0) == null; 310 if (vendorSpecific || isServiceActive) { 311 nonVisibleKeys.add(BACKUP_INACTIVE); 312 } 313 if (vendorSpecific || !isServiceActive) { 314 nonVisibleKeys.add(BACKUP_DATA); 315 nonVisibleKeys.add(AUTO_RESTORE); 316 nonVisibleKeys.add(CONFIGURE_ACCOUNT); 317 } 318 } 319} 320