1 /* 2 * Copyright (C) 2014 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.accounts; 18 19 20 import android.accounts.Account; 21 import android.accounts.AccountManager; 22 import android.app.ActivityManager; 23 import android.app.AlertDialog; 24 import android.app.Dialog; 25 import android.app.DialogFragment; 26 import android.content.BroadcastReceiver; 27 import android.content.ContentResolver; 28 import android.content.Context; 29 import android.content.DialogInterface; 30 import android.content.Intent; 31 import android.content.IntentFilter; 32 import android.content.pm.UserInfo; 33 import android.graphics.drawable.Drawable; 34 import android.os.Bundle; 35 import android.os.UserHandle; 36 import android.os.UserManager; 37 import android.os.Process; 38 import android.util.Log; 39 import android.util.SparseArray; 40 import android.view.Menu; 41 import android.view.MenuInflater; 42 import android.view.MenuItem; 43 import android.preference.Preference; 44 import android.preference.Preference.OnPreferenceClickListener; 45 import android.preference.PreferenceGroup; 46 import android.preference.PreferenceCategory; 47 import android.preference.PreferenceScreen; 48 49 import com.android.settings.R; 50 import com.android.settings.SettingsPreferenceFragment; 51 import com.android.settings.Utils; 52 53 import java.util.ArrayList; 54 import java.util.Collections; 55 import java.util.Comparator; 56 import java.util.List; 57 58 import static android.content.Intent.EXTRA_USER; 59 import static android.os.UserManager.DISALLOW_MODIFY_ACCOUNTS; 60 import static android.provider.Settings.EXTRA_AUTHORITIES; 61 62 /** 63 * Settings screen for the account types on the device. 64 * This shows all account types available for personal and work profiles. 65 * 66 * An extra {@link UserHandle} can be specified in the intent as {@link EXTRA_USER}, if the user for 67 * which the action needs to be performed is different to the one the Settings App will run in. 68 */ 69 public class AccountSettings extends SettingsPreferenceFragment 70 implements AuthenticatorHelper.OnAccountsUpdateListener, 71 OnPreferenceClickListener { 72 public static final String TAG = "AccountSettings"; 73 74 private static final String KEY_ACCOUNT = "account"; 75 76 private static final String ADD_ACCOUNT_ACTION = "android.settings.ADD_ACCOUNT_SETTINGS"; 77 private static final String TAG_CONFIRM_AUTO_SYNC_CHANGE = "confirmAutoSyncChange"; 78 79 private static final int ORDER_LAST = 1001; 80 private static final int ORDER_NEXT_TO_LAST = 1000; 81 82 private UserManager mUm; 83 private SparseArray<ProfileData> mProfiles = new SparseArray<ProfileData>(); 84 private ManagedProfileBroadcastReceiver mManagedProfileBroadcastReceiver 85 = new ManagedProfileBroadcastReceiver(); 86 private Preference mProfileNotAvailablePreference; 87 private String[] mAuthorities; 88 private int mAuthoritiesCount = 0; 89 90 /** 91 * Holds data related to the accounts belonging to one profile. 92 */ 93 private static class ProfileData { 94 /** 95 * The preference that displays the accounts. 96 */ 97 public PreferenceGroup preferenceGroup; 98 /** 99 * The preference that displays the add account button. 100 */ 101 public Preference addAccountPreference; 102 /** 103 * The preference that displays the button to remove the managed profile 104 */ 105 public Preference removeWorkProfilePreference; 106 /** 107 * The {@link AuthenticatorHelper} that holds accounts data for this profile. 108 */ 109 public AuthenticatorHelper authenticatorHelper; 110 /** 111 * The {@link UserInfo} of the profile. 112 */ 113 public UserInfo userInfo; 114 } 115 116 @Override 117 public void onCreate(Bundle savedInstanceState) { 118 super.onCreate(savedInstanceState); 119 mUm = (UserManager) getSystemService(Context.USER_SERVICE); 120 mProfileNotAvailablePreference = new Preference(getActivity()); 121 mAuthorities = getActivity().getIntent().getStringArrayExtra(EXTRA_AUTHORITIES); 122 if (mAuthorities != null) { 123 mAuthoritiesCount = mAuthorities.length; 124 } 125 setHasOptionsMenu(true); 126 } 127 128 @Override 129 public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) { 130 inflater.inflate(R.menu.account_settings, menu); 131 super.onCreateOptionsMenu(menu, inflater); 132 } 133 134 @Override 135 public void onPrepareOptionsMenu(Menu menu) { 136 final UserHandle currentProfile = Process.myUserHandle(); 137 if (mProfiles.size() == 1) { 138 menu.findItem(R.id.account_settings_menu_auto_sync) 139 .setVisible(true) 140 .setOnMenuItemClickListener(new MasterSyncStateClickListener(currentProfile)) 141 .setChecked(ContentResolver.getMasterSyncAutomaticallyAsUser( 142 currentProfile.getIdentifier())); 143 menu.findItem(R.id.account_settings_menu_auto_sync_personal).setVisible(false); 144 menu.findItem(R.id.account_settings_menu_auto_sync_work).setVisible(false); 145 } else if (mProfiles.size() > 1) { 146 // We assume there's only one managed profile, otherwise UI needs to change 147 final UserHandle managedProfile = mProfiles.valueAt(1).userInfo.getUserHandle(); 148 149 menu.findItem(R.id.account_settings_menu_auto_sync_personal) 150 .setVisible(true) 151 .setOnMenuItemClickListener(new MasterSyncStateClickListener(currentProfile)) 152 .setChecked(ContentResolver.getMasterSyncAutomaticallyAsUser( 153 currentProfile.getIdentifier())); 154 menu.findItem(R.id.account_settings_menu_auto_sync_work) 155 .setVisible(true) 156 .setOnMenuItemClickListener(new MasterSyncStateClickListener(managedProfile)) 157 .setChecked(ContentResolver.getMasterSyncAutomaticallyAsUser( 158 managedProfile.getIdentifier())); 159 menu.findItem(R.id.account_settings_menu_auto_sync).setVisible(false); 160 } else { 161 Log.w(TAG, "Method onPrepareOptionsMenu called before mProfiles was initialized"); 162 } 163 } 164 165 @Override 166 public void onResume() { 167 super.onResume(); 168 updateUi(); 169 mManagedProfileBroadcastReceiver.register(getActivity()); 170 listenToAccountUpdates(); 171 } 172 173 @Override 174 public void onPause() { 175 super.onPause(); 176 stopListeningToAccountUpdates(); 177 mManagedProfileBroadcastReceiver.unregister(getActivity()); 178 cleanUpPreferences(); 179 } 180 181 @Override 182 public void onAccountsUpdate(UserHandle userHandle) { 183 final ProfileData profileData = mProfiles.get(userHandle.getIdentifier()); 184 if (profileData != null) { 185 updateAccountTypes(profileData); 186 } else { 187 Log.w(TAG, "Missing Settings screen for: " + userHandle.getIdentifier()); 188 } 189 } 190 191 @Override 192 public boolean onPreferenceClick(Preference preference) { 193 // Check the preference 194 final int count = mProfiles.size(); 195 for (int i = 0; i < count; i++) { 196 ProfileData profileData = mProfiles.valueAt(i); 197 if (preference == profileData.addAccountPreference) { 198 Intent intent = new Intent(ADD_ACCOUNT_ACTION); 199 intent.putExtra(EXTRA_USER, profileData.userInfo.getUserHandle()); 200 intent.putExtra(EXTRA_AUTHORITIES, mAuthorities); 201 startActivity(intent); 202 return true; 203 } 204 if (preference == profileData.removeWorkProfilePreference) { 205 final int userId = profileData.userInfo.id; 206 Utils.createRemoveConfirmationDialog(getActivity(), userId, 207 new DialogInterface.OnClickListener() { 208 @Override 209 public void onClick(DialogInterface dialog, int which) { 210 mUm.removeUser(userId); 211 } 212 } 213 ).show(); 214 return true; 215 } 216 } 217 return false; 218 } 219 220 void updateUi() { 221 // Load the preferences from an XML resource 222 addPreferencesFromResource(R.xml.account_settings); 223 224 if (Utils.isManagedProfile(mUm)) { 225 // This should not happen 226 Log.e(TAG, "We should not be showing settings for a managed profile"); 227 finish(); 228 return; 229 } 230 231 final PreferenceScreen preferenceScreen = (PreferenceScreen) findPreference(KEY_ACCOUNT); 232 if(mUm.isLinkedUser()) { 233 // Restricted user or similar 234 UserInfo userInfo = mUm.getUserInfo(UserHandle.myUserId()); 235 updateProfileUi(userInfo, false /* no category needed */, preferenceScreen); 236 } else { 237 List<UserInfo> profiles = mUm.getProfiles(UserHandle.myUserId()); 238 final int profilesCount = profiles.size(); 239 final boolean addCategory = profilesCount > 1; 240 for (int i = 0; i < profilesCount; i++) { 241 updateProfileUi(profiles.get(i), addCategory, preferenceScreen); 242 } 243 } 244 245 // Add all preferences, starting with one for the primary profile. 246 // Note that we're relying on the ordering given by the SparseArray keys, and on the 247 // value of UserHandle.USER_OWNER being smaller than all the rest. 248 final int profilesCount = mProfiles.size(); 249 for (int i = 0; i < profilesCount; i++) { 250 ProfileData profileData = mProfiles.valueAt(i); 251 if (!profileData.preferenceGroup.equals(preferenceScreen)) { 252 preferenceScreen.addPreference(profileData.preferenceGroup); 253 } 254 updateAccountTypes(profileData); 255 } 256 } 257 258 private void updateProfileUi(final UserInfo userInfo, boolean addCategory, 259 PreferenceScreen parent) { 260 final Context context = getActivity(); 261 final ProfileData profileData = new ProfileData(); 262 profileData.userInfo = userInfo; 263 if (addCategory) { 264 profileData.preferenceGroup = new PreferenceCategory(context); 265 profileData.preferenceGroup.setTitle(userInfo.isManagedProfile() 266 ? R.string.category_work : R.string.category_personal); 267 parent.addPreference(profileData.preferenceGroup); 268 } else { 269 profileData.preferenceGroup = parent; 270 } 271 if (userInfo.isEnabled()) { 272 profileData.authenticatorHelper = new AuthenticatorHelper(context, 273 userInfo.getUserHandle(), mUm, this); 274 if (!mUm.hasUserRestriction(DISALLOW_MODIFY_ACCOUNTS, userInfo.getUserHandle())) { 275 profileData.addAccountPreference = newAddAccountPreference(context); 276 } 277 } 278 if (userInfo.isManagedProfile()) { 279 profileData.removeWorkProfilePreference = newRemoveWorkProfilePreference(context); 280 } 281 mProfiles.put(userInfo.id, profileData); 282 } 283 284 private Preference newAddAccountPreference(Context context) { 285 Preference preference = new Preference(context); 286 preference.setTitle(R.string.add_account_label); 287 preference.setIcon(R.drawable.ic_menu_add_dark); 288 preference.setOnPreferenceClickListener(this); 289 preference.setOrder(ORDER_NEXT_TO_LAST); 290 return preference; 291 } 292 293 private Preference newRemoveWorkProfilePreference(Context context) { 294 Preference preference = new Preference(context); 295 preference.setTitle(R.string.remove_managed_profile_label); 296 preference.setIcon(R.drawable.ic_menu_delete); 297 preference.setOnPreferenceClickListener(this); 298 preference.setOrder(ORDER_LAST); 299 return preference; 300 } 301 302 private void cleanUpPreferences() { 303 PreferenceScreen preferenceScreen = getPreferenceScreen(); 304 if (preferenceScreen != null) { 305 preferenceScreen.removeAll(); 306 } 307 mProfiles.clear(); 308 } 309 310 private void listenToAccountUpdates() { 311 final int count = mProfiles.size(); 312 for (int i = 0; i < count; i++) { 313 AuthenticatorHelper authenticatorHelper = mProfiles.valueAt(i).authenticatorHelper; 314 if (authenticatorHelper != null) { 315 authenticatorHelper.listenToAccountUpdates(); 316 } 317 } 318 } 319 320 private void stopListeningToAccountUpdates() { 321 final int count = mProfiles.size(); 322 for (int i = 0; i < count; i++) { 323 AuthenticatorHelper authenticatorHelper = mProfiles.valueAt(i).authenticatorHelper; 324 if (authenticatorHelper != null) { 325 authenticatorHelper.stopListeningToAccountUpdates(); 326 } 327 } 328 } 329 330 private void updateAccountTypes(ProfileData profileData) { 331 profileData.preferenceGroup.removeAll(); 332 if (profileData.userInfo.isEnabled()) { 333 final ArrayList<AccountPreference> preferences = getAccountTypePreferences( 334 profileData.authenticatorHelper, profileData.userInfo.getUserHandle()); 335 final int count = preferences.size(); 336 for (int i = 0; i < count; i++) { 337 profileData.preferenceGroup.addPreference(preferences.get(i)); 338 } 339 if (profileData.addAccountPreference != null) { 340 profileData.preferenceGroup.addPreference(profileData.addAccountPreference); 341 } 342 } else { 343 // Put a label instead of the accounts list 344 mProfileNotAvailablePreference.setEnabled(false); 345 mProfileNotAvailablePreference.setIcon(R.drawable.empty_icon); 346 mProfileNotAvailablePreference.setTitle(null); 347 mProfileNotAvailablePreference.setSummary( 348 R.string.managed_profile_not_available_label); 349 profileData.preferenceGroup.addPreference(mProfileNotAvailablePreference); 350 } 351 if (profileData.removeWorkProfilePreference != null) { 352 profileData.preferenceGroup.addPreference(profileData.removeWorkProfilePreference); 353 } 354 } 355 356 private ArrayList<AccountPreference> getAccountTypePreferences(AuthenticatorHelper helper, 357 UserHandle userHandle) { 358 final String[] accountTypes = helper.getEnabledAccountTypes(); 359 final ArrayList<AccountPreference> accountTypePreferences = 360 new ArrayList<AccountPreference>(accountTypes.length); 361 362 for (int i = 0; i < accountTypes.length; i++) { 363 final String accountType = accountTypes[i]; 364 // Skip showing any account that does not have any of the requested authorities 365 if (!accountTypeHasAnyRequestedAuthorities(helper, accountType)) { 366 continue; 367 } 368 final CharSequence label = helper.getLabelForType(getActivity(), accountType); 369 if (label == null) { 370 continue; 371 } 372 373 final Account[] accounts = AccountManager.get(getActivity()) 374 .getAccountsByTypeAsUser(accountType, userHandle); 375 final boolean skipToAccount = accounts.length == 1 376 && !helper.hasAccountPreferences(accountType); 377 378 if (skipToAccount) { 379 final Bundle fragmentArguments = new Bundle(); 380 fragmentArguments.putParcelable(AccountSyncSettings.ACCOUNT_KEY, 381 accounts[0]); 382 fragmentArguments.putParcelable(EXTRA_USER, userHandle); 383 384 accountTypePreferences.add(new AccountPreference(getActivity(), label, 385 AccountSyncSettings.class.getName(), fragmentArguments, 386 helper.getDrawableForType(getActivity(), accountType))); 387 } else { 388 final Bundle fragmentArguments = new Bundle(); 389 fragmentArguments.putString(ManageAccountsSettings.KEY_ACCOUNT_TYPE, accountType); 390 fragmentArguments.putString(ManageAccountsSettings.KEY_ACCOUNT_LABEL, 391 label.toString()); 392 fragmentArguments.putParcelable(EXTRA_USER, userHandle); 393 394 accountTypePreferences.add(new AccountPreference(getActivity(), label, 395 ManageAccountsSettings.class.getName(), fragmentArguments, 396 helper.getDrawableForType(getActivity(), accountType))); 397 } 398 helper.preloadDrawableForType(getActivity(), accountType); 399 } 400 // Sort by label 401 Collections.sort(accountTypePreferences, new Comparator<AccountPreference>() { 402 @Override 403 public int compare(AccountPreference t1, AccountPreference t2) { 404 return t1.mTitle.toString().compareTo(t2.mTitle.toString()); 405 } 406 }); 407 return accountTypePreferences; 408 } 409 410 private boolean accountTypeHasAnyRequestedAuthorities(AuthenticatorHelper helper, 411 String accountType) { 412 if (mAuthoritiesCount == 0) { 413 // No authorities required 414 return true; 415 } 416 final ArrayList<String> authoritiesForType = helper.getAuthoritiesForAccountType( 417 accountType); 418 if (authoritiesForType == null) { 419 Log.d(TAG, "No sync authorities for account type: " + accountType); 420 return false; 421 } 422 for (int j = 0; j < mAuthoritiesCount; j++) { 423 if (authoritiesForType.contains(mAuthorities[j])) { 424 return true; 425 } 426 } 427 return false; 428 } 429 430 private class AccountPreference extends Preference implements OnPreferenceClickListener { 431 /** 432 * Title of the tile that is shown to the user. 433 * @attr ref android.R.styleable#PreferenceHeader_title 434 */ 435 private final CharSequence mTitle; 436 437 /** 438 * Full class name of the fragment to display when this tile is 439 * selected. 440 * @attr ref android.R.styleable#PreferenceHeader_fragment 441 */ 442 private final String mFragment; 443 444 /** 445 * Optional arguments to supply to the fragment when it is 446 * instantiated. 447 */ 448 private final Bundle mFragmentArguments; 449 450 public AccountPreference(Context context, CharSequence title, String fragment, 451 Bundle fragmentArguments, Drawable icon) { 452 super(context); 453 mTitle = title; 454 mFragment = fragment; 455 mFragmentArguments = fragmentArguments; 456 setWidgetLayoutResource(R.layout.account_type_preference); 457 458 setTitle(title); 459 setIcon(icon); 460 461 setOnPreferenceClickListener(this); 462 } 463 464 @Override 465 public boolean onPreferenceClick(Preference preference) { 466 if (mFragment != null) { 467 Utils.startWithFragment( 468 getContext(), mFragment, mFragmentArguments, null, 0, 0, mTitle); 469 return true; 470 } 471 return false; 472 } 473 } 474 475 private class ManagedProfileBroadcastReceiver extends BroadcastReceiver { 476 private boolean listeningToManagedProfileEvents; 477 478 @Override 479 public void onReceive(Context context, Intent intent) { 480 if (intent.getAction().equals(Intent.ACTION_MANAGED_PROFILE_REMOVED) 481 || intent.getAction().equals(Intent.ACTION_MANAGED_PROFILE_ADDED)) { 482 Log.v(TAG, "Received broadcast: " + intent.getAction()); 483 // Clean old state 484 stopListeningToAccountUpdates(); 485 cleanUpPreferences(); 486 // Build new state 487 updateUi(); 488 listenToAccountUpdates(); 489 // Force the menu to update. Note that #onPrepareOptionsMenu uses data built by 490 // #updateUi so we must call this later 491 getActivity().invalidateOptionsMenu(); 492 return; 493 } 494 Log.w(TAG, "Cannot handle received broadcast: " + intent.getAction()); 495 } 496 497 public void register(Context context) { 498 if (!listeningToManagedProfileEvents) { 499 IntentFilter intentFilter = new IntentFilter(); 500 intentFilter.addAction(Intent.ACTION_MANAGED_PROFILE_REMOVED); 501 intentFilter.addAction(Intent.ACTION_MANAGED_PROFILE_ADDED); 502 context.registerReceiver(this, intentFilter); 503 listeningToManagedProfileEvents = true; 504 } 505 } 506 507 public void unregister(Context context) { 508 if (listeningToManagedProfileEvents) { 509 context.unregisterReceiver(this); 510 listeningToManagedProfileEvents = false; 511 } 512 } 513 } 514 515 private class MasterSyncStateClickListener implements MenuItem.OnMenuItemClickListener { 516 private final UserHandle mUserHandle; 517 518 public MasterSyncStateClickListener(UserHandle userHandle) { 519 mUserHandle = userHandle; 520 } 521 522 @Override 523 public boolean onMenuItemClick(MenuItem item) { 524 if (ActivityManager.isUserAMonkey()) { 525 Log.d(TAG, "ignoring monkey's attempt to flip sync state"); 526 } else { 527 ConfirmAutoSyncChangeFragment.show(AccountSettings.this, !item.isChecked(), 528 mUserHandle); 529 } 530 return true; 531 } 532 } 533 534 /** 535 * Dialog to inform user about changing auto-sync setting 536 */ 537 public static class ConfirmAutoSyncChangeFragment extends DialogFragment { 538 private static final String SAVE_ENABLING = "enabling"; 539 private boolean mEnabling; 540 private UserHandle mUserHandle; 541 542 public static void show(AccountSettings parent, boolean enabling, UserHandle userHandle) { 543 if (!parent.isAdded()) return; 544 545 final ConfirmAutoSyncChangeFragment dialog = new ConfirmAutoSyncChangeFragment(); 546 dialog.mEnabling = enabling; 547 dialog.mUserHandle = userHandle; 548 dialog.setTargetFragment(parent, 0); 549 dialog.show(parent.getFragmentManager(), TAG_CONFIRM_AUTO_SYNC_CHANGE); 550 } 551 552 @Override 553 public Dialog onCreateDialog(Bundle savedInstanceState) { 554 final Context context = getActivity(); 555 if (savedInstanceState != null) { 556 mEnabling = savedInstanceState.getBoolean(SAVE_ENABLING); 557 } 558 559 final AlertDialog.Builder builder = new AlertDialog.Builder(context); 560 if (!mEnabling) { 561 builder.setTitle(R.string.data_usage_auto_sync_off_dialog_title); 562 builder.setMessage(R.string.data_usage_auto_sync_off_dialog); 563 } else { 564 builder.setTitle(R.string.data_usage_auto_sync_on_dialog_title); 565 builder.setMessage(R.string.data_usage_auto_sync_on_dialog); 566 } 567 568 builder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() { 569 @Override 570 public void onClick(DialogInterface dialog, int which) { 571 ContentResolver.setMasterSyncAutomaticallyAsUser(mEnabling, 572 mUserHandle.getIdentifier()); 573 } 574 }); 575 builder.setNegativeButton(android.R.string.cancel, null); 576 577 return builder.create(); 578 } 579 580 @Override 581 public void onSaveInstanceState(Bundle outState) { 582 super.onSaveInstanceState(outState); 583 outState.putBoolean(SAVE_ENABLING, mEnabling); 584 } 585 } 586 // TODO Implement a {@link SearchIndexProvider} to allow Indexing and Search of account types 587 // See http://b/15403806 588 } 589
