PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Removed AccountSettings used in old IA only."

Browse Source
This commit is contained in:
TreeHugger Robot
2017-02-25 03:04:05 +00:00
committed by Android (Google) Code Review
parent 7450c35828 f074f0f6dd
commit b7c595a636
16 changed files with 37 additions and 851 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/com/android/settings/Settings.java
View File

@@ -83,11 +83,9 @@ public class Settings extends SettingsActivity {
public static class PrivacySettingsActivity extends SettingsActivity { /* empty */ }
public static class FactoryResetActivity extends SettingsActivity { /* empty */ }
public static class RunningServicesActivity extends SettingsActivity { /* empty */ }
public static class ManageAccountsSettingsActivity extends SettingsActivity { /* empty */ }
public static class PowerUsageSummaryActivity extends SettingsActivity { /* empty */ }
public static class BatterySaverSettingsActivity extends SettingsActivity { /* empty */ }
public static class AccountSyncSettingsActivity extends SettingsActivity { /* empty */ }
public static class AccountSettingsActivity extends SettingsActivity { /* empty */ }
public static class AccountSyncSettingsInAddAccountActivity extends SettingsActivity { /* empty */ }
public static class GestureSettingsActivity extends SettingsActivity { /* empty */ }
public static class CryptKeeperSettingsActivity extends SettingsActivity { /* empty */ }

2
src/com/android/settings/accounts/AccountPreferenceBase.java
View File

@@ -46,7 +46,7 @@ import java.util.Date;
abstract class AccountPreferenceBase extends SettingsPreferenceFragment
implements AuthenticatorHelper.OnAccountsUpdateListener {
protected static final String TAG = "AccountSettings";
protected static final String TAG = "AccountPreferenceBase";
protected static final boolean VERBOSE = Log.isLoggable(TAG, Log.VERBOSE);
public static final String AUTHORITIES_FILTER_KEY = "authorities";

89
src/com/android/settings/accounts/AccountPreferenceController.java
View File

@@ -30,7 +30,6 @@ import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.UserHandle;
import android.os.UserManager;
import android.support.v14.preference.PreferenceFragment;
import android.support.v7.preference.Preference;
import android.support.v7.preference.Preference.OnPreferenceClickListener;
import android.support.v7.preference.PreferenceGroup;
@@ -43,6 +42,7 @@ import com.android.settings.AccessiblePreferenceCategory;
import com.android.settings.DimmableIconPreference;
import com.android.settings.R;
import com.android.settings.SettingsActivity;
import com.android.settings.SettingsPreferenceFragment;
import com.android.settings.Utils;
import com.android.settings.core.PreferenceController;
import com.android.settings.core.instrumentation.MetricsFeatureProvider;
@@ -53,6 +53,7 @@ import com.android.settings.dashboard.DashboardFeatureProvider;
import com.android.settings.overlay.FeatureFactory;
import com.android.settings.search.Index;
import com.android.settings.search.SearchIndexableRaw;
import com.android.settings.search2.SearchFeatureProviderImpl;
import com.android.settingslib.RestrictedPreference;
import com.android.settingslib.accounts.AuthenticatorHelper;
@@ -85,8 +86,7 @@ public class AccountPreferenceController extends PreferenceController
private Preference mProfileNotAvailablePreference;
private String[] mAuthorities;
private int mAuthoritiesCount = 0;
private PreferenceFragment mParent;
private boolean mIAEnabled;
private SettingsPreferenceFragment mParent;
private int mAccountProfileOrder = ORDER_ACCOUNT_PROFILES;
private AccountRestrictionHelper mHelper;
private DashboardFeatureProvider mDashboardFeatureProvider;
@@ -122,13 +122,13 @@ public class AccountPreferenceController extends PreferenceController
public UserInfo userInfo;
}
public AccountPreferenceController(Context context, PreferenceFragment parent,
public AccountPreferenceController(Context context, SettingsPreferenceFragment parent,
String[] authorities) {
this(context, parent, authorities, new AccountRestrictionHelper(context));
}
@VisibleForTesting
AccountPreferenceController(Context context, PreferenceFragment parent,
AccountPreferenceController(Context context, SettingsPreferenceFragment parent,
String[] authorities, AccountRestrictionHelper helper) {
super(context);
mUm = (UserManager) context.getSystemService(Context.USER_SERVICE);
@@ -140,7 +140,6 @@ public class AccountPreferenceController extends PreferenceController
final FeatureFactory featureFactory = FeatureFactory.getFactory(mContext);
mDashboardFeatureProvider = featureFactory.getDashboardFeatureProvider(mContext);
mMetricsFeatureProvider = featureFactory.getMetricsFeatureProvider();
mIAEnabled = mDashboardFeatureProvider.isEnabled();
mHelper = helper;
}
@@ -255,17 +254,9 @@ public class AccountPreferenceController extends PreferenceController
if (!isAvailable()) {
// This should not happen
Log.e(TAG, "We should not be showing settings for a managed profile");
if (!mIAEnabled) {
((AccountSettings) mParent).finish();
}
return;
}
if (!mIAEnabled) {
// Load the preferences from an XML resource
mParent.addPreferencesFromResource(R.xml.account_settings);
}
if (mUm.isLinkedUser()) {
// Restricted user or similar
UserInfo userInfo = mUm.getUserInfo(UserHandle.myUserId());
@@ -330,8 +321,8 @@ public class AccountPreferenceController extends PreferenceController
DISALLOW_MODIFY_ACCOUNTS, userInfo.id);
}
mProfiles.put(userInfo.id, profileData);
Index.getInstance(mContext).updateFromClassNameResource(
AccountSettings.class.getName(), true, true);
new SearchFeatureProviderImpl().getIndexingManager(mContext).updateFromClassNameResource(
UserAndAccountDashboardFragment.class.getName(), true, true);
}
private DimmableIconPreference newAddAccountPreference(Context context) {
@@ -471,52 +462,29 @@ public class AccountPreferenceController extends PreferenceController
final Drawable icon = helper.getDrawableForType(mContext, accountType);
final Context prefContext = mParent.getPreferenceManager().getContext();
if (mIAEnabled) {
// Add a preference row for each individual account
for (Account account : accounts) {
final ArrayList<String> auths =
helper.getAuthoritiesForAccountType(account.type);
if (!AccountRestrictionHelper.showAccount(mAuthorities, auths)) {
continue;
}
final Bundle fragmentArguments = new Bundle();
fragmentArguments.putParcelable(AccountDetailDashboardFragment.KEY_ACCOUNT,
account);
fragmentArguments.putParcelable(AccountDetailDashboardFragment.KEY_USER_HANDLE,
userHandle);
fragmentArguments.putString(AccountDetailDashboardFragment.KEY_ACCOUNT_TYPE,
accountType);
fragmentArguments.putString(AccountDetailDashboardFragment.KEY_ACCOUNT_LABEL,
label.toString());
fragmentArguments.putInt(AccountDetailDashboardFragment.KEY_ACCOUNT_TITLE_RES,
titleResId);
fragmentArguments.putParcelable(EXTRA_USER, userHandle);
accountTypePreferences.add(new AccountTypePreference(
prefContext, mMetricsFeatureProvider.getMetricsCategory(mParent),
account.name, titleResPackageName, titleResId, label,
AccountDetailDashboardFragment.class.getName(), fragmentArguments, icon));
// Add a preference row for each individual account
for (Account account : accounts) {
final ArrayList<String> auths =
helper.getAuthoritiesForAccountType(account.type);
if (!AccountRestrictionHelper.showAccount(mAuthorities, auths)) {
continue;
}
} else if (skipToAccount) {
final Bundle fragmentArguments = new Bundle();
fragmentArguments.putParcelable(AccountSyncSettings.ACCOUNT_KEY,
accounts[0]);
fragmentArguments.putParcelable(AccountDetailDashboardFragment.KEY_ACCOUNT,
account);
fragmentArguments.putParcelable(AccountDetailDashboardFragment.KEY_USER_HANDLE,
userHandle);
fragmentArguments.putString(AccountDetailDashboardFragment.KEY_ACCOUNT_TYPE,
accountType);
fragmentArguments.putString(AccountDetailDashboardFragment.KEY_ACCOUNT_LABEL,
label.toString());
fragmentArguments.putInt(AccountDetailDashboardFragment.KEY_ACCOUNT_TITLE_RES,
titleResId);
fragmentArguments.putParcelable(EXTRA_USER, userHandle);
accountTypePreferences.add(new AccountTypePreference(
prefContext, mMetricsFeatureProvider.getMetricsCategory(mParent),
label, titleResPackageName, titleResId, AccountSyncSettings.class.getName(),
fragmentArguments, icon));
} else {
final Bundle fragmentArguments = new Bundle();
fragmentArguments.putString(ManageAccountsSettings.KEY_ACCOUNT_TYPE, accountType);
fragmentArguments.putString(ManageAccountsSettings.KEY_ACCOUNT_LABEL,
label.toString());
fragmentArguments.putParcelable(EXTRA_USER, userHandle);
accountTypePreferences.add(new AccountTypePreference(
prefContext, mMetricsFeatureProvider.getMetricsCategory(mParent), label,
titleResPackageName, titleResId, ManageAccountsSettings.class.getName(),
fragmentArguments, icon));
prefContext, mMetricsFeatureProvider.getMetricsCategory(mParent),
account.name, titleResPackageName, titleResId, label,
AccountDetailDashboardFragment.class.getName(), fragmentArguments, icon));
}
helper.preloadDrawableForType(mContext, accountType);
}
@@ -524,10 +492,7 @@ public class AccountPreferenceController extends PreferenceController
Collections.sort(accountTypePreferences, new Comparator<AccountTypePreference>() {
@Override
public int compare(AccountTypePreference t1, AccountTypePreference t2) {
int result = 0;
if (mIAEnabled) {
result = t1.getSummary().toString().compareTo(t2.getSummary().toString());
}
int result = t1.getSummary().toString().compareTo(t2.getSummary().toString());
return result != 0
? result : t1.getTitle().toString().compareTo(t2.getTitle().toString());
}

151
src/com/android/settings/accounts/AccountSettings.java
View File

@@ -1,151 +0,0 @@
/*
* Copyright (C) 2014 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.accounts;
import android.app.ActivityManager;
import android.content.ContentResolver;
import android.content.Context;
import android.os.Bundle;
import android.os.Process;
import android.os.UserHandle;
import android.provider.SearchIndexableResource;
import android.util.Log;
import android.util.SparseArray;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.settings.R;
import com.android.settings.SettingsPreferenceFragment;
import com.android.settings.search.BaseSearchIndexProvider;
import com.android.settings.search.Indexable;
import com.android.settings.search.SearchIndexableRaw;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static android.provider.Settings.EXTRA_AUTHORITIES;
/**
* Settings screen for the account types on the device.
* This shows all account types available for personal and work profiles.
*
* An extra {@link UserHandle} can be specified in the intent as {@link EXTRA_USER}, if the user for
* which the action needs to be performed is different to the one the Settings App will run in.
*/
public class AccountSettings extends SettingsPreferenceFragment implements Indexable {
public static final String TAG = "AccountSettings";
private String[] mAuthorities;
private AccountPreferenceController mAccountPreferenceController;
@Override
public int getMetricsCategory() {
return MetricsEvent.ACCOUNT;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mAuthorities = getActivity().getIntent().getStringArrayExtra(EXTRA_AUTHORITIES);
setHasOptionsMenu(true);
mAccountPreferenceController =
new AccountPreferenceController(getActivity(), this, mAuthorities);
getLifecycle().addObserver(mAccountPreferenceController);
}
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
inflater.inflate(R.menu.account_settings, menu);
super.onCreateOptionsMenu(menu, inflater);
}
@Override
public void onPrepareOptionsMenu(Menu menu) {
final UserHandle currentProfile = Process.myUserHandle();
SparseArray<AccountPreferenceController.ProfileData> profiles =
mAccountPreferenceController.getProfileData();
if (profiles.size() == 1) {
menu.findItem(R.id.account_settings_menu_auto_sync)
.setVisible(true)
.setOnMenuItemClickListener(new MasterSyncStateClickListener(currentProfile))
.setChecked(ContentResolver.getMasterSyncAutomaticallyAsUser(
currentProfile.getIdentifier()));
menu.findItem(R.id.account_settings_menu_auto_sync_personal).setVisible(false);
menu.findItem(R.id.account_settings_menu_auto_sync_work).setVisible(false);
} else if (profiles.size() > 1) {
// We assume there's only one managed profile, otherwise UI needs to change
final UserHandle managedProfile = profiles.valueAt(1).userInfo.getUserHandle();
menu.findItem(R.id.account_settings_menu_auto_sync_personal)
.setVisible(true)
.setOnMenuItemClickListener(new MasterSyncStateClickListener(currentProfile))
.setChecked(ContentResolver.getMasterSyncAutomaticallyAsUser(
currentProfile.getIdentifier()));
menu.findItem(R.id.account_settings_menu_auto_sync_work)
.setVisible(true)
.setOnMenuItemClickListener(new MasterSyncStateClickListener(managedProfile))
.setChecked(ContentResolver.getMasterSyncAutomaticallyAsUser(
managedProfile.getIdentifier()));
menu.findItem(R.id.account_settings_menu_auto_sync).setVisible(false);
} else {
Log.w(TAG, "Method onPrepareOptionsMenu called before profiles was initialized");
}
}
private class MasterSyncStateClickListener implements MenuItem.OnMenuItemClickListener {
private final UserHandle mUserHandle;
public MasterSyncStateClickListener(UserHandle userHandle) {
mUserHandle = userHandle;
}
@Override
public boolean onMenuItemClick(MenuItem item) {
if (ActivityManager.isUserAMonkey()) {
Log.d(TAG, "ignoring monkey's attempt to flip sync state");
} else {
AutoSyncDataPreferenceController.ConfirmAutoSyncChangeFragment.show(
AccountSettings.this, !item.isChecked(), mUserHandle, null/*preference*/);
}
return true;
}
}
public static final SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
new BaseSearchIndexProvider() {
@Override
public List<SearchIndexableResource> getXmlResourcesToIndex(
Context context, boolean enabled) {
final SearchIndexableResource sir = new SearchIndexableResource(context);
sir.xmlResId = R.xml.account_settings;
return Arrays.asList(sir);
}
@Override
public List<SearchIndexableRaw> getRawDataToIndex(Context context, boolean enabled) {
final List<SearchIndexableRaw> result = new ArrayList<SearchIndexableRaw>();
new AccountPreferenceController(context, null, null).updateRawDataToIndex(result);
return result;
}
};
}

2
src/com/android/settings/accounts/AddAccountSettings.java
View File

@@ -72,7 +72,7 @@ public class AddAccountSettings extends Activity {
private static final String KEY_CALLER_IDENTITY = "pendingIntent";
private static final String SHOULD_NOT_RESOLVE = "SHOULDN'T RESOLVE!";
private static final String TAG = "AccountSettings";
private static final String TAG = "AddAccountSettings";
/* package */ static final String EXTRA_SELECTED_ACCOUNT = "selected_account";

426
src/com/android/settings/accounts/ManageAccountsSettings.java
View File

@@ -1,426 +0,0 @@
/*
* Copyright (C) 2008 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.accounts;
import android.accounts.Account;
import android.accounts.AccountManager;
import android.app.ActionBar;
import android.app.Activity;
import android.content.ContentResolver;
import android.content.SyncAdapterType;
import android.content.SyncInfo;
import android.content.SyncStatusInfo;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.UserHandle;
import android.support.annotation.VisibleForTesting;
import android.support.v7.preference.Preference;
import android.support.v7.preference.PreferenceScreen;
import android.util.ArraySet;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.settings.R;
import com.android.settings.SettingsActivity;
import com.android.settings.Utils;
import com.android.settingslib.accounts.AuthenticatorHelper;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Set;
import static android.content.Intent.EXTRA_USER;
/** Manages settings for Google Account. */
public class ManageAccountsSettings extends AccountPreferenceBase
implements AuthenticatorHelper.OnAccountsUpdateListener {
public static final String KEY_ACCOUNT_TYPE = "account_type";
public static final String KEY_ACCOUNT_LABEL = "account_label";
private static final int MENU_SYNC_NOW_ID = Menu.FIRST;
private static final int MENU_SYNC_CANCEL_ID = Menu.FIRST + 1;
private static final int REQUEST_SHOW_SYNC_SETTINGS = 1;
private String[] mAuthorities;
private TextView mErrorInfoView;
// If an account type is set, then show only accounts of that type
private String mAccountType;
// Temporary hack, to deal with backward compatibility
// mFirstAccount is used for the injected preferences
private Account mFirstAccount;
protected Set<String> mUserFacingSyncAuthorities;
@Override
public int getMetricsCategory() {
return MetricsEvent.ACCOUNTS_MANAGE_ACCOUNTS;
}
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
Bundle args = getArguments();
if (args != null && args.containsKey(KEY_ACCOUNT_TYPE)) {
mAccountType = args.getString(KEY_ACCOUNT_TYPE);
}
addPreferencesFromResource(R.xml.manage_accounts_settings);
setHasOptionsMenu(true);
}
@Override
public void onResume() {
super.onResume();
mAuthenticatorHelper.listenToAccountUpdates();
updateAuthDescriptions();
showAccountsIfNeeded();
showSyncState();
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
final View view = inflater.inflate(R.layout.manage_accounts_screen, container, false);
final ViewGroup prefs_container = (ViewGroup) view.findViewById(R.id.prefs_container);
Utils.prepareCustomPreferencesList(container, view, prefs_container, false);
View prefs = super.onCreateView(inflater, prefs_container, savedInstanceState);
prefs_container.addView(prefs);
return view;
}
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
final Activity activity = getActivity();
final View view = getView();
mErrorInfoView = (TextView) view.findViewById(R.id.sync_settings_error_info);
mErrorInfoView.setVisibility(View.GONE);
mAuthorities = activity.getIntent().getStringArrayExtra(AUTHORITIES_FILTER_KEY);
Bundle args = getArguments();
if (args != null && args.containsKey(KEY_ACCOUNT_LABEL)) {
getActivity().setTitle(args.getString(KEY_ACCOUNT_LABEL));
}
}
@Override
public void onPause() {
super.onPause();
mAuthenticatorHelper.stopListeningToAccountUpdates();
}
@Override
public void onStop() {
super.onStop();
final Activity activity = getActivity();
activity.getActionBar().setDisplayOptions(0, ActionBar.DISPLAY_SHOW_CUSTOM);
activity.getActionBar().setCustomView(null);
}
@Override
public boolean onPreferenceTreeClick(Preference preference) {
if (preference instanceof AccountPreference) {
startAccountSettings((AccountPreference) preference);
} else {
return false;
}
return true;
}
private void startAccountSettings(AccountPreference acctPref) {
Bundle args = new Bundle();
args.putParcelable(AccountSyncSettings.ACCOUNT_KEY, acctPref.getAccount());
args.putParcelable(EXTRA_USER, mUserHandle);
((SettingsActivity) getActivity()).startPreferencePanel(this,
AccountSyncSettings.class.getCanonicalName(), args,
R.string.account_sync_settings_title, acctPref.getAccount().name,
this, REQUEST_SHOW_SYNC_SETTINGS);
}
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
menu.add(0, MENU_SYNC_NOW_ID, 0, getString(R.string.sync_menu_sync_now))
.setIcon(R.drawable.ic_menu_refresh_holo_dark);
menu.add(0, MENU_SYNC_CANCEL_ID, 0, getString(R.string.sync_menu_sync_cancel))
.setIcon(com.android.internal.R.drawable.ic_menu_close_clear_cancel);
super.onCreateOptionsMenu(menu, inflater);
}
@Override
public void onPrepareOptionsMenu(Menu menu) {
super.onPrepareOptionsMenu(menu);
boolean syncActive = !getCurrentSyncs(mUserHandle.getIdentifier()).isEmpty();
menu.findItem(MENU_SYNC_NOW_ID).setVisible(!syncActive);
menu.findItem(MENU_SYNC_CANCEL_ID).setVisible(syncActive);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case MENU_SYNC_NOW_ID:
requestOrCancelSyncForAccounts(true);
return true;
case MENU_SYNC_CANCEL_ID:
requestOrCancelSyncForAccounts(false);
return true;
}
return super.onOptionsItemSelected(item);
}
private void requestOrCancelSyncForAccounts(boolean sync) {
final int userId = mUserHandle.getIdentifier();
SyncAdapterType[] syncAdapters = ContentResolver.getSyncAdapterTypesAsUser(userId);
Bundle extras = new Bundle();
extras.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);
int count = getPreferenceScreen().getPreferenceCount();
// For each account
for (int i = 0; i < count; i++) {
Preference pref = getPreferenceScreen().getPreference(i);
if (pref instanceof AccountPreference) {
Account account = ((AccountPreference) pref).getAccount();
// For all available sync authorities, sync those that are enabled for the account
for (int j = 0; j < syncAdapters.length; j++) {
SyncAdapterType sa = syncAdapters[j];
if (syncAdapters[j].accountType.equals(mAccountType)
&& ContentResolver.getSyncAutomaticallyAsUser(account, sa.authority,
userId)) {
if (sync) {
ContentResolver.requestSyncAsUser(account, sa.authority, userId,
extras);
} else {
ContentResolver.cancelSyncAsUser(account, sa.authority, userId);
}
}
}
}
}
}
@Override
protected void onSyncStateUpdated() {
final Activity activity = getActivity();
// Catch any delayed delivery of update messages
if (activity == null || activity.isFinishing()) {
return;
}
showSyncState();
activity.invalidateOptionsMenu();
}
private void tryInitUserFacingSyncAuthorities(int userId) {
if (mUserFacingSyncAuthorities != null) {
return;
}
mUserFacingSyncAuthorities = new ArraySet<>();
// only track userfacing sync adapters when deciding if account is synced or not
final SyncAdapterType[] syncAdapters = ContentResolver.getSyncAdapterTypesAsUser(userId);
for (int k = 0, n = syncAdapters.length; k < n; k++) {
final SyncAdapterType sa = syncAdapters[k];
if (sa.isUserVisible()) {
mUserFacingSyncAuthorities.add(sa.authority);
}
}
}
/**
* Shows the sync state of the accounts. Note: it must be called after the accounts have been
* loaded.
*
* @see {@link #showAccountsIfNeeded()}.
*/
@VisibleForTesting
void showSyncState() {
final int userId = mUserHandle.getIdentifier();
tryInitUserFacingSyncAuthorities(userId);
// iterate over all the preferences, setting the state properly for each
final List<SyncInfo> currentSyncs = getCurrentSyncs(userId);
boolean anySyncFailed = false; // true if sync on any account failed
Date date = new Date();
final PreferenceScreen screen = getPreferenceScreen();
final int prefCount = screen.getPreferenceCount();
for (int i = 0; i < prefCount; i++) {
Preference pref = screen.getPreference(i);
if (!(pref instanceof AccountPreference)) {
continue;
}
final AccountPreference accountPref = (AccountPreference) pref;
final Account account = accountPref.getAccount();
int syncCount = 0;
long lastSuccessTime = 0;
boolean syncIsFailing = false;
final ArrayList<String> authorities = accountPref.getAuthorities();
boolean syncingNow = false;
if (authorities != null) {
for (String authority : authorities) {
SyncStatusInfo status = getSyncStatusInfo(account, authority, userId);
boolean syncEnabled = isSyncEnabled(userId, account, authority);
boolean activelySyncing = isSyncing(currentSyncs, account, authority);
boolean lastSyncFailed = status != null
&& syncEnabled
&& status.lastFailureTime != 0
&& status.getLastFailureMesgAsInt(0)
!= ContentResolver.SYNC_ERROR_SYNC_ALREADY_IN_PROGRESS;
if (lastSyncFailed && !activelySyncing
&& !ContentResolver.isSyncPending(account, authority)) {
syncIsFailing = true;
anySyncFailed = true;
break;
}
if (status != null && lastSuccessTime < status.lastSuccessTime) {
lastSuccessTime = status.lastSuccessTime;
}
syncCount += syncEnabled && mUserFacingSyncAuthorities.contains(authority)
? 1 : 0;
syncingNow |= activelySyncing;
if (syncingNow) {
break;
}
}
} else {
if (VERBOSE) {
Log.v(TAG, "no syncadapters found for " + account);
}
}
if (syncIsFailing) {
accountPref.setSyncStatus(AccountPreference.SYNC_ERROR, true);
} else if (syncCount == 0) {
accountPref.setSyncStatus(AccountPreference.SYNC_DISABLED, true);
} else if (syncCount > 0) {
if (syncingNow) {
accountPref.setSyncStatus(AccountPreference.SYNC_IN_PROGRESS, true);
} else {
accountPref.setSyncStatus(AccountPreference.SYNC_ENABLED, true);
if (lastSuccessTime > 0) {
accountPref.setSyncStatus(AccountPreference.SYNC_ENABLED, false);
date.setTime(lastSuccessTime);
final String timeString = formatSyncDate(date);
accountPref.setSummary(getResources().getString(
R.string.last_synced, timeString));
}
}
} else {
accountPref.setSyncStatus(AccountPreference.SYNC_DISABLED, true);
}
}
if (mErrorInfoView != null) {
mErrorInfoView.setVisibility(anySyncFailed ? View.VISIBLE : View.GONE);
}
}
private boolean isSyncing(List<SyncInfo> currentSyncs, Account account, String authority) {
final int count = currentSyncs.size();
for (int i = 0; i < count; i++) {
SyncInfo syncInfo = currentSyncs.get(i);
if (syncInfo.account.equals(account) && syncInfo.authority.equals(authority)) {
return true;
}
}
return false;
}
@VisibleForTesting
protected boolean isSyncEnabled(int userId, Account account, String authority) {
return ContentResolver.getSyncAutomaticallyAsUser(account, authority, userId)
&& ContentResolver.getMasterSyncAutomaticallyAsUser(userId)
&& (ContentResolver.getIsSyncableAsUser(account, authority, userId) > 0);
}
@Override
public void onAccountsUpdate(UserHandle userHandle) {
showAccountsIfNeeded();
onSyncStateUpdated();
}
private void showAccountsIfNeeded() {
if (getActivity() == null) return;
Account[] accounts = AccountManager.get(getActivity()).getAccountsAsUser(
mUserHandle.getIdentifier());
getPreferenceScreen().removeAll();
mFirstAccount = null;
addPreferencesFromResource(R.xml.manage_accounts_settings);
for (int i = 0, n = accounts.length; i < n; i++) {
final Account account = accounts[i];
// If an account type is specified for this screen, skip other types
if (mAccountType != null && !account.type.equals(mAccountType)) continue;
final ArrayList<String> auths = getAuthoritiesForAccountType(account.type);
if (AccountRestrictionHelper.showAccount(mAuthorities, auths)) {
final Drawable icon = getDrawableForType(account.type);
final AccountPreference preference =
new AccountPreference(getPrefContext(), account, icon, auths, false);
getPreferenceScreen().addPreference(preference);
if (mFirstAccount == null) {
mFirstAccount = account;
}
}
}
if (mAccountType != null && mFirstAccount != null) {
addAuthenticatorSettings();
} else {
// There's no account, close activity
finish();
}
}
private void addAuthenticatorSettings() {
PreferenceScreen prefs = addPreferencesForType(mAccountType, getPreferenceScreen());
if (prefs != null) {
mAccountTypePreferenceLoader.updatePreferenceIntents(prefs, mAccountType, mFirstAccount);
}
}
@Override
protected void onAuthDescriptionsUpdated() {
// Update account icons for all account preference items
for (int i = 0; i < getPreferenceScreen().getPreferenceCount(); i++) {
Preference pref = getPreferenceScreen().getPreference(i);
if (pref instanceof AccountPreference) {
AccountPreference accPref = (AccountPreference) pref;
accPref.setSummary(getLabelForType(accPref.getAccount().type));
}
}
}
@VisibleForTesting
protected List<SyncInfo> getCurrentSyncs(int userId) {
return ContentResolver.getCurrentSyncsAsUser(userId);
}
@VisibleForTesting
protected SyncStatusInfo getSyncStatusInfo(Account account, String authority, int userId) {
return ContentResolver.getSyncStatusAsUser(account, authority, userId);
}
}

3
src/com/android/settings/core/gateway/SettingsGateway.java
View File

@@ -44,7 +44,6 @@ import com.android.settings.accessibility.AccessibilitySettings;
import com.android.settings.accessibility.AccessibilitySettingsForSetupWizard;
import com.android.settings.accessibility.CaptionPropertiesFragment;
import com.android.settings.accessibility.ToggleDaltonizerPreferenceFragment;
import com.android.settings.accounts.AccountSettings;
import com.android.settings.accounts.AccountSyncSettings;
import com.android.settings.accounts.ChooseAccountActivity;
import com.android.settings.accounts.ManagedProfileSettings;
@@ -181,7 +180,6 @@ public class SettingsGateway {
WifiDisplaySettings.class.getName(),
PowerUsageSummary.class.getName(),
AccountSyncSettings.class.getName(),
AccountSettings.class.getName(),
GestureSettings.class.getName(),
AssistGestureSettings.class.getName(),
SwipeToNotificationSettings.class.getName(),
@@ -271,7 +269,6 @@ public class SettingsGateway {
Settings.SecuritySettingsActivity.class.getName(),
Settings.InputMethodAndLanguageSettingsActivity.class.getName(),
Settings.UserSettingsActivity.class.getName(),
Settings.AccountSettingsActivity.class.getName(),
//system_section
Settings.DateTimeSettingsActivity.class.getName(),
Settings.DeviceInfoSettingsActivity.class.getName(),

2
src/com/android/settings/dashboard/conditional/WorkModeCondition.java
View File

@@ -84,7 +84,7 @@ public class WorkModeCondition extends Condition {
@Override
public void onPrimaryClick() {
mManager.getContext().startActivity(new Intent(mManager.getContext(),
Settings.AccountSettingsActivity.class));
Settings.UserAndAccountDashboardActivity.class));
}
@Override

4
src/com/android/settings/search/Ranking.java
View File

@@ -28,7 +28,7 @@ import com.android.settings.SecuritySettings;
import com.android.settings.WallpaperTypeSettings;
import com.android.settings.WirelessSettings;
import com.android.settings.accessibility.AccessibilitySettings;
import com.android.settings.accounts.AccountSettings;
import com.android.settings.accounts.UserAndAccountDashboardFragment;
import com.android.settings.applications.AdvancedAppSettings;
import com.android.settings.applications.SpecialAccessSettings;
import com.android.settings.bluetooth.BluetoothSettings;
@@ -166,7 +166,7 @@ public final class Ranking {
sRankMap.put(ScreenPinningSettings.class.getName(), RANK_SECURITY);
// Accounts
sRankMap.put(AccountSettings.class.getName(), RANK_ACCOUNT);
sRankMap.put(UserAndAccountDashboardFragment.class.getName(), RANK_ACCOUNT);
// IMEs
sRankMap.put(InputMethodAndLanguageSettings.class.getName(), RANK_IME);

2
src/com/android/settings/search/SearchIndexableResources.java
View File

@@ -33,7 +33,6 @@ import com.android.settings.SecuritySettings;
import com.android.settings.WallpaperTypeSettings;
import com.android.settings.WirelessSettings;
import com.android.settings.accessibility.AccessibilitySettings;
import com.android.settings.accounts.AccountSettings;
import com.android.settings.accounts.UserAndAccountDashboardFragment;
import com.android.settings.applications.AdvancedAppSettings;
import com.android.settings.applications.AppAndNotificationDashboardFragment;
@@ -155,7 +154,6 @@ public final class SearchIndexableResources {
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,
R.drawable.ic_settings_accounts);
addIndex(InputMethodAndLanguageSettings.class,