a2633d0232
- Add activity-alias for the Activity. - Copy the Activity from AccountsAndSyncSettings. - Fragmentize ManageAccountsSettings. - Remove dependency toward AccountPreferenceBase, which is used in AccountsAndSyncSettings widely. - Add missing implementation derived from AccountPrefernceBase. - Copy dependent drawables. - Copy dependent xmls - Copy AccountPrefernce.java. - Copy strings, adding CHAR LIMIT. - Remove the logic which remove the preference when its destination Activity is missing. We already have the destination as Fragment, and it never disappear. Change-Id: Id41c63d7064aebeaae31bcd84bf4fd20a5636dfe
374 lines
16 KiB
Java
374 lines
16 KiB
Java
/*
|
|
* 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;
|
|
|
|
import com.google.android.collect.Maps;
|
|
|
|
import com.android.settings.SettingsPreferenceFragment.SettingsDialogFragment;
|
|
|
|
import android.accounts.Account;
|
|
import android.accounts.AccountManager;
|
|
import android.accounts.AuthenticatorDescription;
|
|
import android.accounts.OnAccountsUpdateListener;
|
|
import android.app.Activity;
|
|
import android.app.AlertDialog;
|
|
import android.app.Dialog;
|
|
import android.content.ContentResolver;
|
|
import android.content.Context;
|
|
import android.content.DialogInterface;
|
|
import android.content.Intent;
|
|
import android.content.SyncAdapterType;
|
|
import android.content.SyncInfo;
|
|
import android.content.SyncStatusInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.net.ConnectivityManager;
|
|
import android.os.Bundle;
|
|
import android.preference.CheckBoxPreference;
|
|
import android.preference.Preference;
|
|
import android.preference.PreferenceCategory;
|
|
import android.preference.PreferenceFragment;
|
|
import android.preference.PreferenceScreen;
|
|
import android.util.Log;
|
|
import android.view.LayoutInflater;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.widget.Button;
|
|
import android.widget.TextView;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Map;
|
|
|
|
public class ManageAccountsSettings extends PreferenceFragment
|
|
implements View.OnClickListener, OnAccountsUpdateListener, DialogCreatable {
|
|
private static final String TAG = ManageAccountsSettings.class.getSimpleName();
|
|
|
|
private static final String AUTHORITIES_FILTER_KEY = "authorities";
|
|
private static final boolean LDEBUG = Log.isLoggable(TAG, Log.DEBUG);
|
|
|
|
private static final String AUTO_SYNC_CHECKBOX_KEY = "syncAutomaticallyCheckBox";
|
|
private static final String MANAGE_ACCOUNTS_CATEGORY_KEY = "manageAccountsCategory";
|
|
private static final String BACKGROUND_DATA_CHECKBOX_KEY = "backgroundDataCheckBox";
|
|
private static final int DIALOG_DISABLE_BACKGROUND_DATA = 1;
|
|
|
|
private CheckBoxPreference mBackgroundDataCheckBox;
|
|
private PreferenceCategory mManageAccountsCategory;
|
|
private String[] mAuthorities;
|
|
private TextView mErrorInfoView;
|
|
private Button mAddAccountButton;
|
|
private CheckBoxPreference mAutoSyncCheckbox;
|
|
|
|
private SettingsDialogFragment mDialogFragment;
|
|
|
|
private AuthenticatorDescription[] mAuthDescs;
|
|
private Map<String, AuthenticatorDescription> mTypeToAuthDescription
|
|
= new HashMap<String, AuthenticatorDescription>();
|
|
private HashMap<String, ArrayList<String>> mAccountTypeToAuthorities = null;
|
|
|
|
@Override
|
|
public void onCreate(Bundle icicle) {
|
|
super.onCreate(icicle);
|
|
}
|
|
|
|
@Override
|
|
public View onCreateView(LayoutInflater inflater, ViewGroup container,
|
|
Bundle savedInstanceState) {
|
|
final View view = inflater.inflate(R.layout.manage_accounts_screen, container, false);
|
|
return view;
|
|
}
|
|
|
|
@Override
|
|
public void onActivityCreated(Bundle savedInstanceState) {
|
|
super.onActivityCreated(savedInstanceState);
|
|
|
|
final Activity activity = getActivity();
|
|
addPreferencesFromResource(R.xml.manage_accounts_settings);
|
|
final View view = getView();
|
|
|
|
mErrorInfoView = (TextView)view.findViewById(R.id.sync_settings_error_info);
|
|
mErrorInfoView.setVisibility(View.GONE);
|
|
mErrorInfoView.setCompoundDrawablesWithIntrinsicBounds(
|
|
activity.getResources().getDrawable(R.drawable.ic_list_syncerror),
|
|
null, null, null);
|
|
|
|
mBackgroundDataCheckBox = (CheckBoxPreference) findPreference(BACKGROUND_DATA_CHECKBOX_KEY);
|
|
mAutoSyncCheckbox = (CheckBoxPreference) findPreference(AUTO_SYNC_CHECKBOX_KEY);
|
|
|
|
mManageAccountsCategory = (PreferenceCategory)findPreference(MANAGE_ACCOUNTS_CATEGORY_KEY);
|
|
mAuthorities = activity.getIntent().getStringArrayExtra(AUTHORITIES_FILTER_KEY);
|
|
mAddAccountButton = (Button)view.findViewById(R.id.add_account_button);
|
|
mAddAccountButton.setOnClickListener(this);
|
|
|
|
AccountManager.get(activity).addOnAccountsUpdatedListener(this, null, true);
|
|
updateAuthDescriptions(activity);
|
|
}
|
|
|
|
@Override
|
|
public void onDestroy() {
|
|
AccountManager.get(getActivity()).removeOnAccountsUpdatedListener(this);
|
|
super.onDestroy();
|
|
}
|
|
|
|
@Override
|
|
public boolean onPreferenceTreeClick(PreferenceScreen preferences, Preference preference) {
|
|
if (preference == mBackgroundDataCheckBox) {
|
|
final ConnectivityManager connManager = (ConnectivityManager)
|
|
getActivity().getSystemService(Context.CONNECTIVITY_SERVICE);
|
|
final boolean oldBackgroundDataSetting = connManager.getBackgroundDataSetting();
|
|
final boolean backgroundDataSetting = mBackgroundDataCheckBox.isChecked();
|
|
if (oldBackgroundDataSetting != backgroundDataSetting) {
|
|
if (backgroundDataSetting) {
|
|
setBackgroundDataInt(true);
|
|
onSyncStateUpdated();
|
|
} else {
|
|
// This will get unchecked only if the user hits "Ok"
|
|
mBackgroundDataCheckBox.setChecked(true);
|
|
showDialog(DIALOG_DISABLE_BACKGROUND_DATA);
|
|
}
|
|
}
|
|
} else if (preference == mAutoSyncCheckbox) {
|
|
ContentResolver.setMasterSyncAutomatically(mAutoSyncCheckbox.isChecked());
|
|
onSyncStateUpdated();
|
|
} else {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public Dialog onCreateDialog(int id) {
|
|
switch (id) {
|
|
case DIALOG_DISABLE_BACKGROUND_DATA:
|
|
final CheckBoxPreference pref =
|
|
(CheckBoxPreference) findPreference(BACKGROUND_DATA_CHECKBOX_KEY);
|
|
return new AlertDialog.Builder(getActivity())
|
|
.setTitle(R.string.background_data_dialog_title)
|
|
.setIcon(android.R.drawable.ic_dialog_alert)
|
|
.setMessage(R.string.background_data_dialog_message)
|
|
.setPositiveButton(android.R.string.ok,
|
|
new DialogInterface.OnClickListener() {
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
setBackgroundDataInt(false);
|
|
pref.setChecked(false);
|
|
onSyncStateUpdated();
|
|
}
|
|
})
|
|
.setNegativeButton(android.R.string.cancel, null)
|
|
.create();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
void showDialog(int dialogId) {
|
|
if (mDialogFragment != null) {
|
|
Log.e(TAG, "Old dialog fragment not null!");
|
|
}
|
|
mDialogFragment = new SettingsDialogFragment(this, dialogId);
|
|
mDialogFragment.show(getActivity().getFragmentManager(), Integer.toString(dialogId));
|
|
}
|
|
|
|
private void setBackgroundDataInt(boolean enabled) {
|
|
final ConnectivityManager connManager = (ConnectivityManager)
|
|
getActivity().getSystemService(Context.CONNECTIVITY_SERVICE);
|
|
connManager.setBackgroundDataSetting(enabled);
|
|
}
|
|
|
|
private void onSyncStateUpdated() {
|
|
// Set background connection state
|
|
final ConnectivityManager connManager = (ConnectivityManager)
|
|
getActivity().getSystemService(Context.CONNECTIVITY_SERVICE);
|
|
final boolean backgroundDataSetting = connManager.getBackgroundDataSetting();
|
|
mBackgroundDataCheckBox.setChecked(backgroundDataSetting);
|
|
boolean masterSyncAutomatically = ContentResolver.getMasterSyncAutomatically();
|
|
mAutoSyncCheckbox.setChecked(masterSyncAutomatically);
|
|
|
|
// iterate over all the preferences, setting the state properly for each
|
|
SyncInfo currentSync = ContentResolver.getCurrentSync();
|
|
|
|
boolean anySyncFailed = false; // true if sync on any account failed
|
|
|
|
// only track userfacing sync adapters when deciding if account is synced or not
|
|
final SyncAdapterType[] syncAdapters = ContentResolver.getSyncAdapterTypes();
|
|
HashSet<String> userFacing = new HashSet<String>();
|
|
for (int k = 0, n = syncAdapters.length; k < n; k++) {
|
|
final SyncAdapterType sa = syncAdapters[k];
|
|
if (sa.isUserVisible()) {
|
|
userFacing.add(sa.authority);
|
|
}
|
|
}
|
|
for (int i = 0, count = mManageAccountsCategory.getPreferenceCount(); i < count; i++) {
|
|
Preference pref = mManageAccountsCategory.getPreference(i);
|
|
if (! (pref instanceof AccountPreference)) {
|
|
continue;
|
|
}
|
|
|
|
AccountPreference accountPref = (AccountPreference) pref;
|
|
Account account = accountPref.getAccount();
|
|
int syncCount = 0;
|
|
boolean syncIsFailing = false;
|
|
final ArrayList<String> authorities = accountPref.getAuthorities();
|
|
if (authorities != null) {
|
|
for (String authority : authorities) {
|
|
SyncStatusInfo status = ContentResolver.getSyncStatus(account, authority);
|
|
boolean syncEnabled = ContentResolver.getSyncAutomatically(account, authority)
|
|
&& masterSyncAutomatically
|
|
&& backgroundDataSetting
|
|
&& (ContentResolver.getIsSyncable(account, authority) > 0);
|
|
boolean authorityIsPending = ContentResolver.isSyncPending(account, authority);
|
|
boolean activelySyncing = currentSync != null
|
|
&& currentSync.authority.equals(authority)
|
|
&& new Account(currentSync.account.name, currentSync.account.type)
|
|
.equals(account);
|
|
boolean lastSyncFailed = status != null
|
|
&& syncEnabled
|
|
&& status.lastFailureTime != 0
|
|
&& status.getLastFailureMesgAsInt(0)
|
|
!= ContentResolver.SYNC_ERROR_SYNC_ALREADY_IN_PROGRESS;
|
|
if (lastSyncFailed && !activelySyncing && !authorityIsPending) {
|
|
syncIsFailing = true;
|
|
anySyncFailed = true;
|
|
}
|
|
syncCount += syncEnabled && userFacing.contains(authority) ? 1 : 0;
|
|
}
|
|
} else {
|
|
if (Log.isLoggable(TAG, Log.VERBOSE)) {
|
|
Log.v(TAG, "no syncadapters found for " + account);
|
|
}
|
|
}
|
|
int syncStatus = AccountPreference.SYNC_DISABLED;
|
|
if (syncIsFailing) {
|
|
syncStatus = AccountPreference.SYNC_ERROR;
|
|
} else if (syncCount == 0) {
|
|
syncStatus = AccountPreference.SYNC_DISABLED;
|
|
} else if (syncCount > 0) {
|
|
syncStatus = AccountPreference.SYNC_ENABLED;
|
|
}
|
|
accountPref.setSyncStatus(syncStatus);
|
|
}
|
|
|
|
mErrorInfoView.setVisibility(anySyncFailed ? View.VISIBLE : View.GONE);
|
|
}
|
|
|
|
@Override
|
|
public void onAccountsUpdated(Account[] accounts) {
|
|
mManageAccountsCategory.removeAll();
|
|
for (int i = 0, n = accounts.length; i < n; i++) {
|
|
final Account account = accounts[i];
|
|
final ArrayList<String> auths = getAuthoritiesForAccountType(account.type);
|
|
|
|
boolean showAccount = true;
|
|
if (mAuthorities != null && auths != null) {
|
|
showAccount = false;
|
|
for (String requestedAuthority : mAuthorities) {
|
|
if (auths.contains(requestedAuthority)) {
|
|
showAccount = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (showAccount) {
|
|
final Drawable icon = getDrawableForType(account.type);
|
|
final AccountPreference preference =
|
|
new AccountPreference(getActivity(), account, icon, auths);
|
|
mManageAccountsCategory.addPreference(preference);
|
|
}
|
|
}
|
|
onSyncStateUpdated();
|
|
}
|
|
|
|
private void onAuthDescriptionsUpdated() {
|
|
// Update account icons for all account preference items
|
|
for (int i = 0; i < mManageAccountsCategory.getPreferenceCount(); i++) {
|
|
AccountPreference pref = (AccountPreference) mManageAccountsCategory.getPreference(i);
|
|
pref.setProviderIcon(getDrawableForType(pref.getAccount().type));
|
|
pref.setSummary(getLabelForType(pref.getAccount().type));
|
|
}
|
|
}
|
|
|
|
public void onClick(View v) {
|
|
if (v == mAddAccountButton) {
|
|
Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS");
|
|
intent.putExtra(AUTHORITIES_FILTER_KEY, mAuthorities);
|
|
startActivity(intent);
|
|
}
|
|
}
|
|
|
|
/* The logic below is copied from AcountPrefernceBase */
|
|
|
|
private Drawable getDrawableForType(final String accountType) {
|
|
Drawable icon = null;
|
|
if (mTypeToAuthDescription.containsKey(accountType)) {
|
|
try {
|
|
AuthenticatorDescription desc = mTypeToAuthDescription.get(accountType);
|
|
Context authContext = getActivity().createPackageContext(desc.packageName, 0);
|
|
icon = authContext.getResources().getDrawable(desc.iconId);
|
|
} catch (PackageManager.NameNotFoundException e) {
|
|
// TODO: place holder icon for missing account icons?
|
|
Log.w(TAG, "No icon for account type " + accountType);
|
|
}
|
|
}
|
|
return icon;
|
|
}
|
|
|
|
private CharSequence getLabelForType(final String accountType) {
|
|
CharSequence label = null;
|
|
if (mTypeToAuthDescription.containsKey(accountType)) {
|
|
try {
|
|
AuthenticatorDescription desc = mTypeToAuthDescription.get(accountType);
|
|
Context authContext = getActivity().createPackageContext(desc.packageName, 0);
|
|
label = authContext.getResources().getText(desc.labelId);
|
|
} catch (PackageManager.NameNotFoundException e) {
|
|
Log.w(TAG, "No label for account type " + ", type " + accountType);
|
|
}
|
|
}
|
|
return label;
|
|
}
|
|
|
|
private ArrayList<String> getAuthoritiesForAccountType(String type) {
|
|
if (mAccountTypeToAuthorities == null) {
|
|
mAccountTypeToAuthorities = Maps.newHashMap();
|
|
SyncAdapterType[] syncAdapters = ContentResolver.getSyncAdapterTypes();
|
|
for (int i = 0, n = syncAdapters.length; i < n; i++) {
|
|
final SyncAdapterType sa = syncAdapters[i];
|
|
ArrayList<String> authorities = mAccountTypeToAuthorities.get(sa.accountType);
|
|
if (authorities == null) {
|
|
authorities = new ArrayList<String>();
|
|
mAccountTypeToAuthorities.put(sa.accountType, authorities);
|
|
}
|
|
if (LDEBUG) {
|
|
Log.d(TAG, "added authority " + sa.authority + " to accountType "
|
|
+ sa.accountType);
|
|
}
|
|
authorities.add(sa.authority);
|
|
}
|
|
}
|
|
return mAccountTypeToAuthorities.get(type);
|
|
}
|
|
|
|
private void updateAuthDescriptions(Context context) {
|
|
mAuthDescs = AccountManager.get(context).getAuthenticatorTypes();
|
|
for (int i = 0; i < mAuthDescs.length; i++) {
|
|
mTypeToAuthDescription.put(mAuthDescs[i].type, mAuthDescs[i]);
|
|
}
|
|
onAuthDescriptionsUpdated();
|
|
}
|
|
}
|