Java AccountManager类代码示例

import android.accounts.AccountManager; //导入依赖的package包/类
public void sendResult() {
    IAccountManagerResponse response = getResponseAndClose();
    if (response != null) {
        try {
            Account[] accounts = new Account[mAccountsWithFeatures.size()];
            for (int i = 0; i < accounts.length; i++) {
                accounts[i] = mAccountsWithFeatures.get(i);
            }
            if (Log.isLoggable(TAG, Log.VERBOSE)) {
                Log.v(TAG, getClass().getSimpleName() + " calling onResult() on response "
                        + response);
            }
            Bundle result = new Bundle();
            result.putParcelableArray(AccountManager.KEY_ACCOUNTS, accounts);
            response.onResult(result);
        } catch (RemoteException e) {
            // if the caller is dead then there is no one to care about remote exceptions
            Log.v(TAG, "failure while notifying response", e);
        }
    }
}
 

import android.accounts.AccountManager; //导入依赖的package包/类
public void checkAccount() {
    if (mCurrentAccount >= mAccountsOfType.length) {
        sendResult();
        return;
    }

    final IAccountAuthenticator accountAuthenticator = mAuthenticator;
    if (accountAuthenticator == null) {
        // It is possible that the authenticator has died, which is indicated by
        // mAuthenticator being set to null. If this happens then just abort.
        // There is no need to send back a result or error in this case since
        // that already happened when mAuthenticator was cleared.
        Log.v(TAG, "checkAccount: aborting session since we are no longer"
                + " connected to the authenticator, " + toDebugString());
        return;
    }
    try {
        accountAuthenticator.hasFeatures(this, mAccountsOfType[mCurrentAccount], mFeatures);
    } catch (RemoteException e) {
        onError(AccountManager.ERROR_CODE_REMOTE_EXCEPTION, "remote exception");
    }
}
 

import android.accounts.AccountManager; //导入依赖的package包/类
@SuppressWarnings("deprecation")
@Override
public String getAuthToken() throws AuthFailureError {
    AccountManagerFuture<Bundle> future = mAccountManager.getAuthToken(mAccount,
            mAuthTokenType, mNotifyAuthFailure, null, null);
    Bundle result;
    try {
        result = future.getResult();
    } catch (Exception e) {
        throw new AuthFailureError("Error while retrieving auth token", e);
    }
    String authToken = null;
    if (future.isDone() && !future.isCancelled()) {
        if (result.containsKey(AccountManager.KEY_INTENT)) {
            Intent intent = result.getParcelable(AccountManager.KEY_INTENT);
            throw new AuthFailureError(intent);
        }
        authToken = result.getString(AccountManager.KEY_AUTHTOKEN);
    }
    if (authToken == null) {
        throw new AuthFailureError("Got null auth token for type: " + mAuthTokenType);
    }

    return authToken;
}
 

import android.accounts.AccountManager; //导入依赖的package包/类
void bind() {
	Log.v(TAG, "initiating bind to authenticator type " + mAuthenticatorInfo.desc.type);
	Intent intent = new Intent();
	intent.setAction(AccountManager.ACTION_AUTHENTICATOR_INTENT);
	intent.setClassName(mAuthenticatorInfo.serviceInfo.packageName, mAuthenticatorInfo.serviceInfo.name);
	intent.putExtra("_VA_|_user_id_", mUserId);

	if (!mContext.bindService(intent, this, Context.BIND_AUTO_CREATE)) {
		Log.d(TAG, "bind attempt failed for " + toDebugString());
		onError(AccountManager.ERROR_CODE_REMOTE_EXCEPTION, "bind failure");
	}
}
 

import android.accounts.AccountManager; //导入依赖的package包/类
private void createAuthNotification()
{
    NotificationCompat.Builder builder =
            new NotificationCompat.Builder(getContext(), AuthenticatorActivity.AUTH_NOTIFICATION_CHANNEL_ID)
                .setContentTitle(getContext().getString(R.string.sync_ntf_needs_reauthentication_title))
                .setContentText(getContext().getString(R.string.sync_ntf_needs_reauthentication_description))
                .setSmallIcon(R.mipmap.ic_launcher)
                .setAutoCancel(true);

    Intent intent = new Intent(getContext(), AuthenticatorActivity.class);
    intent.putExtra(AccountManager.KEY_ACCOUNT_TYPE, getContext().getString(R.string.account_type));
    intent.putExtra(AuthenticatorActivity.ARG_AUTH_TOKEN_TYPE, AuthenticatorActivity.ARG_AUTH_TOKEN_TYPE);
    intent.putExtra(AuthenticatorActivity.ARG_IS_ADDING_NEW_ACCOUNT, false);

    TaskStackBuilder stackBuilder = TaskStackBuilder.create(getContext());
    stackBuilder.addParentStack(AuthenticatorActivity.class);
    stackBuilder.addNextIntent(intent);
    PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT);
    builder.setContentIntent(resultPendingIntent);

    NotificationManager ntfMgr =
            (NotificationManager) getContext().getSystemService(Context.NOTIFICATION_SERVICE);
    ntfMgr.notify(AuthenticatorActivity.AUTH_NOTIFICATION_ID, builder.build());
}
 

import android.accounts.AccountManager; //导入依赖的package包/类
public void checkAccount() {
	if (mCurrentAccount >= mAccountsOfType.length) {
		sendResult();
		return;
	}

	final IAccountAuthenticator accountAuthenticator = mAuthenticator;
	if (accountAuthenticator == null) {
		// It is possible that the authenticator has died, which is indicated by
		// mAuthenticator being set to null. If this happens then just abort.
		// There is no need to send back a result or error in this case since
		// that already happened when mAuthenticator was cleared.
		Log.v(TAG, "checkAccount: aborting session since we are no longer"
                      + " connected to the authenticator, " + toDebugString());
		return;
	}
	try {
		accountAuthenticator.hasFeatures(this, mAccountsOfType[mCurrentAccount], mFeatures);
	} catch (RemoteException e) {
		onError(AccountManager.ERROR_CODE_REMOTE_EXCEPTION, "remote exception");
	}
}
 

import android.accounts.AccountManager; //导入依赖的package包/类
public static String getUsername(Context c) {
    AccountManager manager = AccountManager.get(c);
    Account[] accounts = manager.getAccountsByType("com.google");
    List<String> possibleEmails = new LinkedList<String>();

    for (Account account : accounts) {
        // TODO: Check possibleEmail against an email regex or treat
        // account.name as an email address only for certain account.type values.
        possibleEmails.add(account.name);
    }

    if (!possibleEmails.isEmpty() && possibleEmails.get(0) != null) {
        String email = possibleEmails.get(0);
        String[] parts = email.split("@");

        if (parts.length > 1)
            return parts[0];
    }
    return null;
}
 

import android.accounts.AccountManager; //导入依赖的package包/类
private String getName() {
    AccountManager manager = (AccountManager) getSystemService(ACCOUNT_SERVICE);
    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.GET_ACCOUNTS)
            != PackageManager.PERMISSION_GRANTED) {
        return null;
    }

    Account[] list = manager.getAccounts();

    for (Account account : list) {
        if (account.type.equalsIgnoreCase("com.google")) {
            return account.name;
        }
    }
    return null;
}
 

import android.accounts.AccountManager; //导入依赖的package包/类
private ArrayList<String> getUserEmail(){

		ArrayList<String> email = new ArrayList<String>();

		Pattern emailPattern = Patterns.EMAIL_ADDRESS; // API level 8+
		Account[] accounts = AccountManager.get(VerifyOTP.this).getAccounts();
		for (Account account : accounts) {
			if (emailPattern.matcher(account.name).matches()) {
				String possibleEmail = account.name;
				if(possibleEmail != null)
					if(possibleEmail.length() !=0 ){
						email.add(possibleEmail);
					}
			}
		}		
		return email;

	}
 

import android.accounts.AccountManager; //导入依赖的package包/类
public void sendResult() {
	IAccountManagerResponse response = getResponseAndClose();
	if (response != null) {
		try {
			Account[] accounts = new Account[mAccountsWithFeatures.size()];
			for (int i = 0; i < accounts.length; i++) {
				accounts[i] = mAccountsWithFeatures.get(i);
			}
			if (Log.isLoggable(TAG, Log.VERBOSE)) {
				Log.v(TAG, getClass().getSimpleName() + " calling onResult() on response "
						+ response);
			}
			Bundle result = new Bundle();
			result.putParcelableArray(AccountManager.KEY_ACCOUNTS, accounts);
			response.onResult(result);
		} catch (RemoteException e) {
			// if the caller is dead then there is no one to care about remote exceptions
			Log.v(TAG, "failure while notifying response", e);
		}
	}
}
 

import android.accounts.AccountManager; //导入依赖的package包/类
protected void init() {
    initCrypto();

    accountManager = AccountManager.get(getBaseContext());
    serverHandler = new AuthServerHandlerImpl();

    userName = (EditText) findViewById(R.id.user_name);
    password = (EditText) findViewById(R.id.password);
    signIn = (Button) findViewById(R.id.signin_button);
    progressLayout = findViewById(R.id.progress_layout);

    Intent intent = getIntent();
    authTokenType = getIntent().getStringExtra(GlobalConstant.AUTH_TYPE);
    if (authTokenType == null) {
        authTokenType = GlobalConstant.AUTHTOKEN_TYPE_FULL_ACCESS;
    }

    isNewAccount = intent.getBooleanExtra(GlobalConstant.IS_ADDING_NEW_ACCOUNT, true);
    if (!isNewAccount) {
        // existing account
        String accountName = getIntent().getStringExtra(GlobalConstant.ACCOUNT_NAME);
        userName.setText(accountName);
    }

    signIn.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            login();
        }
    });
}
 

import android.accounts.AccountManager; //导入依赖的package包/类
/**
 * Pass the data from server to authenticator class
 *
 * @param intent the intent contain data from user and server {@link AccountManager#KEY_ACCOUNT_NAME},
 *               {@link AccountManager#KEY_AUTHTOKEN}, {@link AccountManager#KEY_ACCOUNT_TYPE} and
 *               {@link GlobalConstant#PARAM_USER_PASS}
 * @throws NoSuchPaddingException
 * @throws InvalidAlgorithmParameterException
 * @throws NoSuchAlgorithmException
 * @throws IllegalBlockSizeException
 * @throws BadPaddingException
 * @throws InvalidKeyException
 * @throws UnsupportedEncodingException
 * @throws SignInException
 */
private void passDataToAuthenticator(Intent intent)
        throws NoSuchPaddingException, InvalidAlgorithmParameterException, NoSuchAlgorithmException,
        IllegalBlockSizeException, BadPaddingException, InvalidKeyException, UnsupportedEncodingException,
        SignInException {

    if (intent.hasExtra(SIGNIN_ERROR)) throw new SignInException();

    String accountName = intent.getStringExtra(AccountManager.KEY_ACCOUNT_NAME);
    String accountPassword = intent.getStringExtra(GlobalConstant.PARAM_USER_PASS);
    accountPassword = Crypto.armorEncrypt(accountPassword.getBytes("UTF-8"), this);

    final Account account = new Account(accountName, authTokenType);

    if (isNewAccount) {
        String iCalId = intent.getStringExtra(AccountManager.KEY_AUTHTOKEN);
        String authtoken = intent.getStringExtra(AccountManager.KEY_ACCOUNT_TYPE);

        // encrypt user id and pass it to intent
        iCalId = Crypto.armorEncrypt(iCalId.getBytes("UTF-8"), this);
        intent.putExtra(AccountManager.KEY_AUTHTOKEN, iCalId);

        final Bundle extraData = new Bundle();
        extraData.putString(PARAM_PRINCIPAL, iCalId);

        accountManager.addAccountExplicitly(account, accountPassword, extraData);
        accountManager.setAuthToken(account, authtoken, iCalId);
    } else {
        accountManager.setPassword(account, accountPassword);
    }

    // encrypt password and pass it to intent
    intent.putExtra(GlobalConstant.PARAM_USER_PASS, accountPassword);


    setAccountAuthenticatorResult(intent.getExtras());
    setResult(RESULT_OK, intent);
    finish();
}
 

import android.accounts.AccountManager; //导入依赖的package包/类
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.login_activity);
    mAccountManager = AccountManager.get(getBaseContext());

    findViewById(R.id.submit)
            .setOnClickListener(
                    new View.OnClickListener() {
                        @Override
                        public void onClick(View v) {
                            addAccount();
                        }
                    });
}
 

import android.accounts.AccountManager; //导入依赖的package包/类
@Override
public Bundle getResult() throws OperationCanceledException, IOException, AuthenticatorException {
	Bundle bundle = mFuture.getResult();
	String accountName = bundle.getString(AccountManager.KEY_ACCOUNT_NAME);
	String accountType = bundle.getString(AccountManager.KEY_ACCOUNT_TYPE);
	if (isAccountAllowed(accountName, accountType, mUid))
		return bundle;
	else
		throw new OperationCanceledException("XPrivacy");
}
 

import android.accounts.AccountManager; //导入依赖的package包/类
private void populateAccountTextView() {
    AccountManager am = AccountManager.get(this);
    Account[] accounts = am.getAccountsByType(ACCOUNT_TYPE);
    String accountString = "Accounts of type " + ACCOUNT_TYPE + " are : \n";
    if (accounts.length != 0) {
        for (Account account : accounts) {
            accountString += "Account:" +  account.name + "\n";
        }
    } else {
        accountString = "No Accounts of type " + ACCOUNT_TYPE +
                " found. Please add accounts before exporting.";
        mAccountTextView.setTextColor(Color.RED);
    }
    mAccountTextView.setText(accountString);
}