src/com/android/settings/PrivacySettings.java

   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
  17 package com.android.settings;
  18
  19 import android.app.backup.IBackupManager;
  20 import android.content.ContentResolver;
  21 import android.content.Context;
  22 import android.content.Intent;
  23 import android.content.pm.PackageManager;
  24 import android.content.pm.ResolveInfo;
  25 import android.os.Bundle;
  26 import android.os.RemoteException;
  27 import android.os.ServiceManager;
  28 import android.os.UserHandle;
  29 import android.os.UserManager;
  30 import android.provider.SearchIndexableResource;
  31 import android.provider.Settings;
  32 import android.support.annotation.VisibleForTesting;
  33 import android.support.v14.preference.SwitchPreference;
  34 import android.support.v7.preference.Preference;
  35 import android.support.v7.preference.Preference.OnPreferenceChangeListener;
  36 import android.support.v7.preference.PreferenceScreen;
  37 import android.util.Log;
  38
  39 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
  40 import com.android.settings.search.BaseSearchIndexProvider;
  41 import com.android.settings.search.Indexable;
  42 import com.android.settingslib.RestrictedLockUtils;
  43
  44 import java.util.ArrayList;
  45 import java.util.Collection;
  46 import java.util.HashSet;
  47 import java.util.List;
  48 import java.util.Set;
  49
  50 /**
  51  * Gesture lock pattern settings.
  52  */
  53 public class PrivacySettings extends SettingsPreferenceFragment {
  54
  55     // Vendor specific
  56     private static final String GSETTINGS_PROVIDER = "com.google.settings";
  57     @VisibleForTesting
  58     static final String BACKUP_DATA = "backup_data";
  59     @VisibleForTesting
  60     static final String AUTO_RESTORE = "auto_restore";
  61     @VisibleForTesting
  62     static final String CONFIGURE_ACCOUNT = "configure_account";
  63     @VisibleForTesting
  64     static final String DATA_MANAGEMENT = "data_management";
  65     private static final String BACKUP_INACTIVE = "backup_inactive";
  66     private static final String FACTORY_RESET = "factory_reset";
  67     private static final String TAG = "PrivacySettings";
  68     private IBackupManager mBackupManager;
  69     private Preference mBackup;
  70     private SwitchPreference mAutoRestore;
  71     private Preference mConfigure;
  72     private Preference mManageData;
  73     private boolean mEnabled;
  74
  75     @Override
  76     public int getMetricsCategory() {
  77         return MetricsEvent.PRIVACY;
  78     }
  79
  80     @Override
  81     public void onCreate(Bundle savedInstanceState) {
  82         super.onCreate(savedInstanceState);
  83         // Don't allow any access if this is not an admin user.
  84         // TODO: backup/restore currently only works with owner user b/22760572
  85         mEnabled = UserManager.get(getActivity()).isAdminUser();
  86         if (!mEnabled) {
  87             return;
  88         }
  89
  90         addPreferencesFromResource(R.xml.privacy_settings);
  91         final PreferenceScreen screen = getPreferenceScreen();
  92         mBackupManager = IBackupManager.Stub.asInterface(
  93                 ServiceManager.getService(Context.BACKUP_SERVICE));
  94
  95         setPreferenceReferences(screen);
  96
  97         Set<String> keysToRemove = new HashSet<>();
  98         getNonVisibleKeys(getActivity(), keysToRemove);
  99         final int screenPreferenceCount = screen.getPreferenceCount();
 100         for (int i = screenPreferenceCount - 1; i >= 0; --i) {
 101             Preference preference = screen.getPreference(i);
 102             if (keysToRemove.contains(preference.getKey())) {
 103                 screen.removePreference(preference);
 104             }
 105         }
 106
 107         updateToggles();
 108     }
 109
 110     @Override
 111     public void onResume() {
 112         super.onResume();
 113
 114         // Refresh UI
 115         if (mEnabled) {
 116             updateToggles();
 117         }
 118     }
 119
 120     @VisibleForTesting
 121     void setPreferenceReferences(PreferenceScreen screen) {
 122         mBackup = screen.findPreference(BACKUP_DATA);
 123
 124         mAutoRestore = (SwitchPreference) screen.findPreference(AUTO_RESTORE);
 125         mAutoRestore.setOnPreferenceChangeListener(preferenceChangeListener);
 126
 127         mConfigure = screen.findPreference(CONFIGURE_ACCOUNT);
 128         mManageData = screen.findPreference(DATA_MANAGEMENT);
 129     }
 130
 131     private OnPreferenceChangeListener preferenceChangeListener = new OnPreferenceChangeListener() {
 132         @Override
 133         public boolean onPreferenceChange(Preference preference, Object newValue) {
 134             if (!(preference instanceof SwitchPreference)) {
 135                 return true;
 136             }
 137             boolean nextValue = (Boolean) newValue;
 138             boolean result = false;
 139             if (preference == mAutoRestore) {
 140                 try {
 141                     mBackupManager.setAutoRestore(nextValue);
 142                     result = true;
 143                 } catch (RemoteException e) {
 144                     mAutoRestore.setChecked(!nextValue);
 145                 }
 146             }
 147             return result;
 148         }
 149     };
 150
 151
 152     /*
 153      * Creates toggles for each backup/reset preference.
 154      */
 155     private void updateToggles() {
 156         ContentResolver res = getContentResolver();
 157
 158         boolean backupEnabled = false;
 159         Intent configIntent = null;
 160         String configSummary = null;
 161         Intent manageIntent = null;
 162         String manageLabel = null;
 163         try {
 164             backupEnabled = mBackupManager.isBackupEnabled();
 165             String transport = mBackupManager.getCurrentTransport();
 166             configIntent = validatedActivityIntent(
 167                     mBackupManager.getConfigurationIntent(transport), "config");
 168             configSummary = mBackupManager.getDestinationString(transport);
 169             manageIntent = validatedActivityIntent(
 170                     mBackupManager.getDataManagementIntent(transport), "management");
 171             manageLabel = mBackupManager.getDataManagementLabel(transport);
 172
 173             mBackup.setSummary(backupEnabled
 174                     ? R.string.accessibility_feature_state_on
 175                     : R.string.accessibility_feature_state_off);
 176         } catch (RemoteException e) {
 177             // leave it 'false' and disable the UI; there's no backup manager
 178             mBackup.setEnabled(false);
 179         }
 180
 181         mAutoRestore.setChecked(Settings.Secure.getInt(res,
 182                 Settings.Secure.BACKUP_AUTO_RESTORE, 1) == 1);
 183         mAutoRestore.setEnabled(backupEnabled);
 184
 185         final boolean configureEnabled = (configIntent != null) && backupEnabled;
 186         mConfigure.setEnabled(configureEnabled);
 187         mConfigure.setIntent(configIntent);
 188         setConfigureSummary(configSummary);
 189
 190         final boolean manageEnabled = (manageIntent != null) && backupEnabled;
 191         if (manageEnabled) {
 192             mManageData.setIntent(manageIntent);
 193             if (manageLabel != null) {
 194                 mManageData.setTitle(manageLabel);
 195             }
 196         } else {
 197             // Hide the item if data management intent is not supported by transport.
 198             getPreferenceScreen().removePreference(mManageData);
 199         }
 200     }
 201
 202     private Intent validatedActivityIntent(Intent intent, String logLabel) {
 203         if (intent != null) {
 204             PackageManager pm = getPackageManager();
 205             List<ResolveInfo> resolved = pm.queryIntentActivities(intent, 0);
 206             if (resolved == null || resolved.isEmpty()) {
 207                 intent = null;
 208                 Log.e(TAG, "Backup " + logLabel + " intent " + intent
 209                         + " fails to resolve; ignoring");
 210             }
 211         }
 212         return intent;
 213     }
 214
 215     private void setConfigureSummary(String summary) {
 216         if (summary != null) {
 217             mConfigure.setSummary(summary);
 218         } else {
 219             mConfigure.setSummary(R.string.backup_configure_account_default_summary);
 220         }
 221     }
 222
 223     @Override
 224     protected int getHelpResource() {
 225         return R.string.help_url_backup_reset;
 226     }
 227
 228     private static void getNonVisibleKeys(Context context, Collection<String> nonVisibleKeys) {
 229         final IBackupManager backupManager = IBackupManager.Stub.asInterface(
 230                 ServiceManager.getService(Context.BACKUP_SERVICE));
 231         boolean isServiceActive = false;
 232         try {
 233             isServiceActive = backupManager.isBackupServiceActive(UserHandle.myUserId());
 234         } catch (RemoteException e) {
 235             Log.w(TAG, "Failed querying backup manager service activity status. " +
 236                     "Assuming it is inactive.");
 237         }
 238         boolean vendorSpecific = context.getPackageManager().
 239                 resolveContentProvider(GSETTINGS_PROVIDER, 0) == null;
 240         if (vendorSpecific || isServiceActive) {
 241             nonVisibleKeys.add(BACKUP_INACTIVE);
 242         }
 243         if (vendorSpecific || !isServiceActive) {
 244             nonVisibleKeys.add(BACKUP_DATA);
 245             nonVisibleKeys.add(AUTO_RESTORE);
 246             nonVisibleKeys.add(CONFIGURE_ACCOUNT);
 247         }
 248         if (RestrictedLockUtils.hasBaseUserRestriction(context,
 249                 UserManager.DISALLOW_FACTORY_RESET, UserHandle.myUserId())) {
 250             nonVisibleKeys.add(FACTORY_RESET);
 251         }
 252     }
 253 }