package com.android.settingslib.accounts;
import android.accounts.Account;
import android.accounts.AccountManager;
import android.accounts.AuthenticatorDescription;
import android.content.BroadcastReceiver;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SyncAdapterType;
import android.content.pm.PackageManager;
import android.content.res.Resources;
import android.graphics.drawable.Drawable;
import android.os.AsyncTask;
import android.os.UserHandle;
import android.util.Log;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
final public class AuthenticatorHelper extends BroadcastReceiver {
private static final String TAG = "AuthenticatorHelper";
private final Map<String, AuthenticatorDescription> mTypeToAuthDescription = new HashMap<>();
private final ArrayList<String> mEnabledAccountTypes = new ArrayList<>();
private final Map<String, Drawable> mAccTypeIconCache = new HashMap<>();
private final HashMap<String, ArrayList<String>> mAccountTypeToAuthorities = new HashMap<>();
private final UserHandle mUserHandle;
private final Context mContext;
private final OnAccountsUpdateListener mListener;
private boolean mListeningToAccountUpdates;
public interface OnAccountsUpdateListener {
void onAccountsUpdate(UserHandle userHandle);
}
public AuthenticatorHelper(Context context, UserHandle userHandle,
OnAccountsUpdateListener listener) {
mContext = context;
mUserHandle = userHandle;
mListener = listener;
onAccountsUpdated(null);
}
public String[] getEnabledAccountTypes() {
return mEnabledAccountTypes.toArray(new String[mEnabledAccountTypes.size()]);
}
public void preloadDrawableForType(final Context context, final String accountType) {
new AsyncTask<Void, Void, Void>() {
@Override
protected Void doInBackground(Void... params) {
getDrawableForType(context, accountType);
return null;
}
}.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void[]) null);
}
public Drawable getDrawableForType(Context context, final String accountType) {
Drawable icon = null;
synchronized (mAccTypeIconCache) {
if (mAccTypeIconCache.containsKey(accountType)) {
return mAccTypeIconCache.get(accountType);
}
}
if (mTypeToAuthDescription.containsKey(accountType)) {
try {
AuthenticatorDescription desc = mTypeToAuthDescription.get(accountType);
Context authContext = context.createPackageContextAsUser(desc.packageName, 0,
mUserHandle);
icon = mContext.getPackageManager().getUserBadgedIcon(
authContext.getDrawable(desc.iconId), mUserHandle);
synchronized (mAccTypeIconCache) {
mAccTypeIconCache.put(accountType, icon);
}
} catch (PackageManager.NameNotFoundException|Resources.NotFoundException e) {
}
}
if (icon == null) {
icon = context.getPackageManager().getDefaultActivityIcon();
}
return icon;
}
public CharSequence getLabelForType(Context context, final String accountType) {
CharSequence label = null;
if (mTypeToAuthDescription.containsKey(accountType)) {
try {
AuthenticatorDescription desc = mTypeToAuthDescription.get(accountType);
Context authContext = context.createPackageContextAsUser(desc.packageName, 0,
mUserHandle);
label = authContext.getResources().getText(desc.labelId);
} catch (PackageManager.NameNotFoundException e) {
Log.w(TAG, "No label name for account type " + accountType);
} catch (Resources.NotFoundException e) {
Log.w(TAG, "No label icon for account type " + accountType);
}
}
return label;
}
public String getPackageForType(final String accountType) {
if (mTypeToAuthDescription.containsKey(accountType)) {
AuthenticatorDescription desc = mTypeToAuthDescription.get(accountType);
return desc.packageName;
}
return null;
}
public int getLabelIdForType(final String accountType) {
if (mTypeToAuthDescription.containsKey(accountType)) {
AuthenticatorDescription desc = mTypeToAuthDescription.get(accountType);
return desc.labelId;
}
return -1;
}
public void updateAuthDescriptions(Context context) {
AuthenticatorDescription[] authDescs = AccountManager.get(context)
.getAuthenticatorTypesAsUser(mUserHandle.getIdentifier());
for (int i = 0; i < authDescs.length; i++) {
mTypeToAuthDescription.put(authDescs[i].type, authDescs[i]);
}
}
public boolean containsAccountType(String accountType) {
return mTypeToAuthDescription.containsKey(accountType);
}
public AuthenticatorDescription getAccountTypeDescription(String accountType) {
return mTypeToAuthDescription.get(accountType);
}
public boolean hasAccountPreferences(final String accountType) {
if (containsAccountType(accountType)) {
AuthenticatorDescription desc = getAccountTypeDescription(accountType);
if (desc != null && desc.accountPreferencesId != 0) {
return true;
}
}
return false;
}
void onAccountsUpdated(Account[] accounts) {
updateAuthDescriptions(mContext);
if (accounts == null) {
accounts = AccountManager.get(mContext).getAccountsAsUser(mUserHandle.getIdentifier());
}
mEnabledAccountTypes.clear();
mAccTypeIconCache.clear();
for (int i = 0; i < accounts.length; i++) {
final Account account = accounts[i];
if (!mEnabledAccountTypes.contains(account.type)) {
mEnabledAccountTypes.add(account.type);
}
}
buildAccountTypeToAuthoritiesMap();
if (mListeningToAccountUpdates) {
mListener.onAccountsUpdate(mUserHandle);
}
}
@Override
public void onReceive(final Context context, final Intent intent) {
final Account[] accounts = AccountManager.get(mContext)
.getAccountsAsUser(mUserHandle.getIdentifier());
onAccountsUpdated(accounts);
}
public void listenToAccountUpdates() {
if (!mListeningToAccountUpdates) {
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(AccountManager.LOGIN_ACCOUNTS_CHANGED_ACTION);
intentFilter.addAction(Intent.ACTION_DEVICE_STORAGE_OK);
mContext.registerReceiverAsUser(this, mUserHandle, intentFilter, null, null);
mListeningToAccountUpdates = true;
}
}
public void stopListeningToAccountUpdates() {
if (mListeningToAccountUpdates) {
mContext.unregisterReceiver(this);
mListeningToAccountUpdates = false;
}
}
public ArrayList<String> getAuthoritiesForAccountType(String type) {
return mAccountTypeToAuthorities.get(type);
}
private void buildAccountTypeToAuthoritiesMap() {
mAccountTypeToAuthorities.clear();
SyncAdapterType[] syncAdapters = ContentResolver.getSyncAdapterTypesAsUser(
mUserHandle.getIdentifier());
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 (Log.isLoggable(TAG, Log.VERBOSE)) {
Log.v(TAG, "Added authority " + sa.authority + " to accountType "
+ sa.accountType);
}
authorities.add(sa.authority);
}
}
}