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