Examples with AuthenticatorDescription android.accounts.AuthenticatorDescription used on opensource projects

Example 11 with AuthenticatorDescription

use of android.accounts.AuthenticatorDescription in project android_frameworks_base by AOSPA.

the class AccountManagerService method getAuthToken.

@Override
public void getAuthToken(IAccountManagerResponse response, final Account account, final String authTokenType, final boolean notifyOnAuthFailure, final boolean expectActivityLaunch, final Bundle loginOptions) {
    Bundle.setDefusable(loginOptions, true);
    if (Log.isLoggable(TAG, Log.VERBOSE)) {
        Log.v(TAG, "getAuthToken: " + account + ", response " + response + ", authTokenType " + authTokenType + ", notifyOnAuthFailure " + notifyOnAuthFailure + ", expectActivityLaunch " + expectActivityLaunch + ", caller's uid " + Binder.getCallingUid() + ", pid " + Binder.getCallingPid());
    }
    if (response == null)
        throw new IllegalArgumentException("response is null");
    try {
        if (account == null) {
            Slog.w(TAG, "getAuthToken called with null account");
            response.onError(AccountManager.ERROR_CODE_BAD_ARGUMENTS, "account is null");
            return;
        }
        if (authTokenType == null) {
            Slog.w(TAG, "getAuthToken called with null authTokenType");
            response.onError(AccountManager.ERROR_CODE_BAD_ARGUMENTS, "authTokenType is null");
            return;
        }
    } catch (RemoteException e) {
        Slog.w(TAG, "Failed to report error back to the client." + e);
        return;
    }
    int userId = UserHandle.getCallingUserId();
    long ident = Binder.clearCallingIdentity();
    final UserAccounts accounts;
    final RegisteredServicesCache.ServiceInfo<AuthenticatorDescription> authenticatorInfo;
    try {
        accounts = getUserAccounts(userId);
        authenticatorInfo = mAuthenticatorCache.getServiceInfo(AuthenticatorDescription.newKey(account.type), accounts.userId);
    } finally {
        Binder.restoreCallingIdentity(ident);
    }
    final boolean customTokens = authenticatorInfo != null && authenticatorInfo.type.customTokens;
    // skip the check if customTokens
    final int callerUid = Binder.getCallingUid();
    final boolean permissionGranted = customTokens || permissionIsGranted(account, authTokenType, callerUid, userId);
    // Get the calling package. We will use it for the purpose of caching.
    final String callerPkg = loginOptions.getString(AccountManager.KEY_ANDROID_PACKAGE_NAME);
    List<String> callerOwnedPackageNames;
    ident = Binder.clearCallingIdentity();
    try {
        callerOwnedPackageNames = Arrays.asList(mPackageManager.getPackagesForUid(callerUid));
    } finally {
        Binder.restoreCallingIdentity(ident);
    }
    if (callerPkg == null || !callerOwnedPackageNames.contains(callerPkg)) {
        String msg = String.format("Uid %s is attempting to illegally masquerade as package %s!", callerUid, callerPkg);
        throw new SecurityException(msg);
    }
    // let authenticator know the identity of the caller
    loginOptions.putInt(AccountManager.KEY_CALLER_UID, callerUid);
    loginOptions.putInt(AccountManager.KEY_CALLER_PID, Binder.getCallingPid());
    if (notifyOnAuthFailure) {
        loginOptions.putBoolean(AccountManager.KEY_NOTIFY_ON_FAILURE, true);
    }
    long identityToken = clearCallingIdentity();
    try {
        // Distill the caller's package signatures into a single digest.
        final byte[] callerPkgSigDigest = calculatePackageSignatureDigest(callerPkg);
        // route of starting a Session
        if (!customTokens && permissionGranted) {
            String authToken = readAuthTokenInternal(accounts, account, authTokenType);
            if (authToken != null) {
                Bundle result = new Bundle();
                result.putString(AccountManager.KEY_AUTHTOKEN, authToken);
                result.putString(AccountManager.KEY_ACCOUNT_NAME, account.name);
                result.putString(AccountManager.KEY_ACCOUNT_TYPE, account.type);
                onResult(response, result);
                return;
            }
        }
        if (customTokens) {
            /*
                 * Look up tokens in the new cache only if the loginOptions don't have parameters
                 * outside of those expected to be injected by the AccountManager, e.g.
                 * ANDORID_PACKAGE_NAME.
                 */
            String token = readCachedTokenInternal(accounts, account, authTokenType, callerPkg, callerPkgSigDigest);
            if (token != null) {
                if (Log.isLoggable(TAG, Log.VERBOSE)) {
                    Log.v(TAG, "getAuthToken: cache hit ofr custom token authenticator.");
                }
                Bundle result = new Bundle();
                result.putString(AccountManager.KEY_AUTHTOKEN, token);
                result.putString(AccountManager.KEY_ACCOUNT_NAME, account.name);
                result.putString(AccountManager.KEY_ACCOUNT_TYPE, account.type);
                onResult(response, result);
                return;
            }
        }
        new Session(accounts, response, account.type, expectActivityLaunch, false, /* stripAuthTokenFromResult */
        account.name, false) {

            /* authDetailsRequired */
            @Override
            protected String toDebugString(long now) {
                if (loginOptions != null)
                    loginOptions.keySet();
                return super.toDebugString(now) + ", getAuthToken" + ", " + account + ", authTokenType " + authTokenType + ", loginOptions " + loginOptions + ", notifyOnAuthFailure " + notifyOnAuthFailure;
            }

            @Override
            public void run() throws RemoteException {
                // "grant permission" intent instead of the "getAuthToken" intent.
                if (!permissionGranted) {
                    mAuthenticator.getAuthTokenLabel(this, authTokenType);
                } else {
                    mAuthenticator.getAuthToken(this, account, authTokenType, loginOptions);
                }
            }

            @Override
            public void onResult(Bundle result) {
                Bundle.setDefusable(result, true);
                if (result != null) {
                    if (result.containsKey(AccountManager.KEY_AUTH_TOKEN_LABEL)) {
                        Intent intent = newGrantCredentialsPermissionIntent(account, null, callerUid, new AccountAuthenticatorResponse(this), authTokenType, true);
                        Bundle bundle = new Bundle();
                        bundle.putParcelable(AccountManager.KEY_INTENT, intent);
                        onResult(bundle);
                        return;
                    }
                    String authToken = result.getString(AccountManager.KEY_AUTHTOKEN);
                    if (authToken != null) {
                        String name = result.getString(AccountManager.KEY_ACCOUNT_NAME);
                        String type = result.getString(AccountManager.KEY_ACCOUNT_TYPE);
                        if (TextUtils.isEmpty(type) || TextUtils.isEmpty(name)) {
                            onError(AccountManager.ERROR_CODE_INVALID_RESPONSE, "the type and name should not be empty");
                            return;
                        }
                        Account resultAccount = new Account(name, type);
                        if (!customTokens) {
                            saveAuthTokenToDatabase(mAccounts, resultAccount, authTokenType, authToken);
                        }
                        long expiryMillis = result.getLong(AbstractAccountAuthenticator.KEY_CUSTOM_TOKEN_EXPIRY, 0L);
                        if (customTokens && expiryMillis > System.currentTimeMillis()) {
                            saveCachedToken(mAccounts, account, callerPkg, callerPkgSigDigest, authTokenType, authToken, expiryMillis);
                        }
                    }
                    Intent intent = result.getParcelable(AccountManager.KEY_INTENT);
                    if (intent != null && notifyOnAuthFailure && !customTokens) {
                        /*
                             * Make sure that the supplied intent is owned by the authenticator
                             * giving it to the system. Otherwise a malicious authenticator could
                             * have users launching arbitrary activities by tricking users to
                             * interact with malicious notifications.
                             */
                        checkKeyIntent(Binder.getCallingUid(), intent);
                        doNotification(mAccounts, account, result.getString(AccountManager.KEY_AUTH_FAILED_MESSAGE), intent, "android", accounts.userId);
                    }
                }
                super.onResult(result);
            }
        }.bind();
    } finally {
        restoreCallingIdentity(identityToken);
    }
}

Example 12 with AuthenticatorDescription

use of android.accounts.AuthenticatorDescription in project android_frameworks_base by ResurrectionRemix.

the class AuthenticatorHelper method getDrawableForType.

/**
     * Gets an icon associated with a particular account type. If none found, return null.
     * @param accountType the type of account
     * @return a drawable for the icon or a default icon returned by
     * {@link PackageManager#getDefaultActivityIcon} if one cannot be found.
     */
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) {
        // Ignore
        }
    }
    if (icon == null) {
        icon = context.getPackageManager().getDefaultActivityIcon();
    }
    return icon;
}

Example 13 with AuthenticatorDescription

use of android.accounts.AuthenticatorDescription in project android_frameworks_base by ResurrectionRemix.

the class AuthenticatorHelper method getLabelForType.

/**
     * Gets the label associated with a particular account type. If none found, return null.
     * @param accountType the type of account
     * @return a CharSequence for the label or null if one cannot be found.
     */
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;
}

Example 14 with AuthenticatorDescription

use of android.accounts.AuthenticatorDescription in project Resurrection_packages_apps_Settings by ResurrectionRemix.

the class AccountPreferenceBase method addPreferencesForType.

/**
     * Gets the preferences.xml file associated with a particular account type.
     * @param accountType the type of account
     * @return a PreferenceScreen inflated from accountPreferenceId.
     */
public PreferenceScreen addPreferencesForType(final String accountType, PreferenceScreen parent) {
    PreferenceScreen prefs = null;
    if (mAuthenticatorHelper.containsAccountType(accountType)) {
        AuthenticatorDescription desc = null;
        try {
            desc = mAuthenticatorHelper.getAccountTypeDescription(accountType);
            if (desc != null && desc.accountPreferencesId != 0 && Utils.showAccount(getActivity(), accountType)) {
                // Load the context of the target package, then apply the
                // base Settings theme (no references to local resources)
                // and create a context theme wrapper so that we get the
                // correct text colors. Control colors will still be wrong,
                // but there's not much we can do about it since we can't
                // reference local color resources.
                final Context targetCtx = getActivity().createPackageContextAsUser(desc.packageName, 0, mUserHandle);
                final Theme baseTheme = getResources().newTheme();
                baseTheme.applyStyle(com.android.settings.R.style.Theme_SettingsBase, true);
                final Context themedCtx = new LocalClassLoaderContextThemeWrapper(getClass(), targetCtx, 0);
                themedCtx.getTheme().setTo(baseTheme);
                prefs = getPreferenceManager().inflateFromResource(themedCtx, desc.accountPreferencesId, parent);
            }
        } catch (PackageManager.NameNotFoundException e) {
            Log.w(TAG, "Couldn't load preferences.xml file from " + desc.packageName);
        } catch (Resources.NotFoundException e) {
            Log.w(TAG, "Couldn't load preferences.xml file from " + desc.packageName);
        }
    }
    return prefs;
}

Example 15 with AuthenticatorDescription

use of android.accounts.AuthenticatorDescription in project Resurrection_packages_apps_Settings by ResurrectionRemix.

the class MasterClear method loadAccountList.

private void loadAccountList(final UserManager um) {
    View accountsLabel = mContentView.findViewById(R.id.accounts_label);
    LinearLayout contents = (LinearLayout) mContentView.findViewById(R.id.accounts);
    contents.removeAllViews();
    Context context = getActivity();
    final List<UserInfo> profiles = um.getProfiles(UserHandle.myUserId());
    final int profilesSize = profiles.size();
    AccountManager mgr = AccountManager.get(context);
    LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    int accountsCount = 0;
    for (int profileIndex = 0; profileIndex < profilesSize; profileIndex++) {
        final UserInfo userInfo = profiles.get(profileIndex);
        final int profileId = userInfo.id;
        final UserHandle userHandle = new UserHandle(profileId);
        Account[] accounts = mgr.getAccountsAsUser(profileId);
        final int N = accounts.length;
        if (N == 0) {
            continue;
        }
        accountsCount += N;
        AuthenticatorDescription[] descs = AccountManager.get(context).getAuthenticatorTypesAsUser(profileId);
        final int M = descs.length;
        View titleView = Utils.inflateCategoryHeader(inflater, contents);
        final TextView titleText = (TextView) titleView.findViewById(android.R.id.title);
        titleText.setText(userInfo.isManagedProfile() ? R.string.category_work : R.string.category_personal);
        contents.addView(titleView);
        for (int i = 0; i < N; i++) {
            Account account = accounts[i];
            if (!Utils.showAccount(context, account.type)) {
                // If needn't to show the account, skip this account.
                continue;
            }
            AuthenticatorDescription desc = null;
            for (int j = 0; j < M; j++) {
                if (account.type.equals(descs[j].type)) {
                    desc = descs[j];
                    break;
                }
            }
            if (desc == null) {
                Log.w(TAG, "No descriptor for account name=" + account.name + " type=" + account.type);
                continue;
            }
            Drawable icon = null;
            try {
                if (desc.iconId != 0) {
                    Context authContext = context.createPackageContextAsUser(desc.packageName, 0, userHandle);
                    icon = context.getPackageManager().getUserBadgedIcon(authContext.getDrawable(desc.iconId), userHandle);
                }
            } catch (PackageManager.NameNotFoundException e) {
                Log.w(TAG, "Bad package name for account type " + desc.type);
            } catch (Resources.NotFoundException e) {
                Log.w(TAG, "Invalid icon id for account type " + desc.type, e);
            }
            if (icon == null) {
                icon = context.getPackageManager().getDefaultActivityIcon();
            }
            TextView child = (TextView) inflater.inflate(R.layout.master_clear_account, contents, false);
            child.setText(account.name);
            child.setCompoundDrawablesWithIntrinsicBounds(icon, null, null, null);
            contents.addView(child);
        }
    }
    if (accountsCount > 0) {
        accountsLabel.setVisibility(View.VISIBLE);
        contents.setVisibility(View.VISIBLE);
    }
    // Checking for all other users and their profiles if any.
    View otherUsers = mContentView.findViewById(R.id.other_users_present);
    final boolean hasOtherUsers = (um.getUserCount() - profilesSize) > 0;
    otherUsers.setVisibility(hasOtherUsers ? View.VISIBLE : View.GONE);
}