@Override public void onError(int errorCode, String errorMessage) { mNumErrors++; IAccountManagerResponse response = getResponseAndClose(); if (response != null) { Log.v(TAG, getClass().getSimpleName() + " calling onError() on response " + response); try { response.onError(errorCode, errorMessage); } catch (RemoteException e) { Log.v(TAG, "Session.onError: caught RemoteException while responding", e); } } else { Log.v(TAG, "Session.onError: already closed"); } }
Session(IAccountManagerResponse response, int userId, AuthenticatorInfo info, boolean expectActivityLaunch, boolean stripAuthTokenFromResult, String accountName, boolean authDetailsRequired, boolean updateLastAuthenticatedTime) { if (info == null) throw new IllegalArgumentException("accountType is null"); this.mStripAuthTokenFromResult = stripAuthTokenFromResult; this.mResponse = response; this.mUserId = userId; this.mAuthenticatorInfo = info; this.mExpectActivityLaunch = expectActivityLaunch; this.mCreationTime = SystemClock.elapsedRealtime(); this.mAccountName = accountName; this.mAuthDetailsRequired = authDetailsRequired; this.mUpdateLastAuthenticatedTime = updateLastAuthenticatedTime; synchronized (mSessions) { mSessions.put(toString(), this); } if (response != null) { try { response.asBinder().linkToDeath(this, 0 /* flags */); } catch (RemoteException e) { mResponse = null; binderDied(); } } }
public void confirmCredentials(int userId, IAccountManagerResponse response, final Account account, final Bundle options, final boolean expectActivityLaunch) { if (response == null) throw new IllegalArgumentException("response is null"); if (account == null) throw new IllegalArgumentException("account is null"); AuthenticatorInfo info = getAuthenticatorInfo(account.type); if (info == null) { try { response.onError(ERROR_CODE_BAD_ARGUMENTS, "account.type does not exist"); } catch (RemoteException e) { e.printStackTrace(); } return; } new Session(response, userId, info, expectActivityLaunch, true, account.name, true, true) { @Override public void run() throws RemoteException { mAuthenticator.confirmCredentials(this, account, options); } }.bind(); }
public void confirmCredentials(int userId, IAccountManagerResponse response, final Account account, final Bundle options, final boolean expectActivityLaunch) { if (response == null) throw new IllegalArgumentException("response is null"); if (account == null) throw new IllegalArgumentException("account is null"); AuthenticatorInfo info = getAuthenticatorInfo(account.type); if(info == null) { try { response.onError(ERROR_CODE_BAD_ARGUMENTS, "account.type does not exist"); } catch(RemoteException e) { e.printStackTrace(); } return; } new Session(response, userId, info, expectActivityLaunch, true, account.name, true, true) { @Override public void run() throws RemoteException { mAuthenticator.confirmCredentials(this, account, options); } }.bind(); }
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); } } }
@Override public Object call(Object who, Method method, Object... args) throws Throwable { IAccountManagerResponse response = (IAccountManagerResponse) args[0]; Account account = (Account) args[1]; String[] features = (String[]) args[2]; Mgr.hasFeatures(response, account, features); return 0; }
@Override public Object call(Object who, Method method, Object... args) throws Throwable { IAccountManagerResponse response = (IAccountManagerResponse) args[0]; String accountType = (String) args[1]; String[] features = (String[]) args[2]; Mgr.getAccountsByFeatures(response, accountType, features); return 0; }
@Override public Object call(Object who, Method method, Object... args) throws Throwable { IAccountManagerResponse response = (IAccountManagerResponse) args[0]; Account account = (Account) args[1]; boolean expectActivityLaunch = (boolean) args[2]; Mgr.removeAccount(response, account, expectActivityLaunch); return 0; }
@Override public Object call(Object who, Method method, Object... args) throws Throwable { IAccountManagerResponse response = (IAccountManagerResponse) args[0]; Account account = (Account) args[1]; int userFrom = (int) args[2]; int userTo = (int) args[3]; method.invoke(who, args); return 0; }
@Override public Object call(Object who, Method method, Object... args) throws Throwable { IAccountManagerResponse response = (IAccountManagerResponse) args[0]; Account account = (Account) args[1]; String authTokenType = (String) args[2]; boolean notifyOnAuthFailure = (boolean) args[3]; boolean expectActivityLaunch = (boolean) args[4]; Bundle options = (Bundle) args[5]; Mgr.getAuthToken(response, account, authTokenType, notifyOnAuthFailure, expectActivityLaunch, options); return 0; }
@Override public Object call(Object who, Method method, Object... args) throws Throwable { IAccountManagerResponse response = (IAccountManagerResponse) args[0]; String accountType = (String) args[1]; String authTokenType = (String) args[2]; String[] requiredFeatures = (String[]) args[3]; boolean expectActivityLaunch = (boolean) args[4]; Bundle options = (Bundle) args[5]; Mgr.addAccount(response, accountType, authTokenType, requiredFeatures, expectActivityLaunch, options); return 0; }
@Override public Object call(Object who, Method method, Object... args) throws Throwable { IAccountManagerResponse response = (IAccountManagerResponse) args[0]; Account account = (Account) args[1]; String authTokenType = (String) args[2]; boolean expectActivityLaunch = (boolean) args[3]; Bundle options = (Bundle) args[4]; Mgr.updateCredentials(response, account, authTokenType, expectActivityLaunch, options); return 0; }
@Override public Object call(Object who, Method method, Object... args) throws Throwable { IAccountManagerResponse response = (IAccountManagerResponse) args[0]; Account account = (Account) args[1]; Bundle options = (Bundle) args[2]; boolean expectActivityLaunch = (boolean) args[3]; Mgr.confirmCredentials(response, account, options, expectActivityLaunch); return 0; }
@Override public Object call(Object who, Method method, Object... args) throws Throwable { IAccountManagerResponse response = (IAccountManagerResponse) args[0]; String accountType = (String) args[1]; String authTokenType = (String) args[2]; Mgr.getAuthTokenLabel(response, accountType, authTokenType); return 0; }
@Override public Object call(Object who, Method method, Object... args) throws Throwable { IAccountManagerResponse response = (IAccountManagerResponse) args[0]; Account accountToRename = (Account) args[1]; String newName = (String) args[2]; Mgr.renameAccount(response, accountToRename, newName); return 0; }
public void removeAccount(IAccountManagerResponse response, Account account, boolean expectActivityLaunch) { try { getRemote().removeAccount(VUserHandle.myUserId(), response, account, expectActivityLaunch); } catch (RemoteException e) { e.printStackTrace(); } }
public void getAuthToken(IAccountManagerResponse response, Account account, String authTokenType, boolean notifyOnAuthFailure, boolean expectActivityLaunch, Bundle loginOptions) { try { getRemote().getAuthToken(VUserHandle.myUserId(), response, account, authTokenType, notifyOnAuthFailure, expectActivityLaunch, loginOptions); } catch (RemoteException e) { e.printStackTrace(); } }
public void hasFeatures(IAccountManagerResponse response, Account account, String[] features) { try { getRemote().hasFeatures(VUserHandle.myUserId(), response, account, features); } catch (RemoteException e) { e.printStackTrace(); } }
public void addAccount(IAccountManagerResponse response, String accountType, String authTokenType, String[] requiredFeatures, boolean expectActivityLaunch, Bundle optionsIn) { try { getRemote().addAccount(VUserHandle.myUserId(), response, accountType, authTokenType, requiredFeatures, expectActivityLaunch, optionsIn); } catch (RemoteException e) { e.printStackTrace(); } }
public void updateCredentials(IAccountManagerResponse response, Account account, String authTokenType, boolean expectActivityLaunch, Bundle loginOptions) { try { getRemote().updateCredentials(VUserHandle.myUserId(), response, account, authTokenType, expectActivityLaunch, loginOptions); } catch (RemoteException e) { e.printStackTrace(); } }
public void editProperties(IAccountManagerResponse response, String accountType, boolean expectActivityLaunch) { try { getRemote().editProperties(VUserHandle.myUserId(), response, accountType, expectActivityLaunch); } catch (RemoteException e) { e.printStackTrace(); } }
public void getAuthTokenLabel(IAccountManagerResponse response, String accountType, String authTokenType) { try { getRemote().getAuthTokenLabel(VUserHandle.myUserId(), response, accountType, authTokenType); } catch (RemoteException e) { e.printStackTrace(); } }
public void confirmCredentials(IAccountManagerResponse response, Account account, Bundle options, boolean expectActivityLaunch) { try { getRemote().confirmCredentials(VUserHandle.myUserId(), response, account, options, expectActivityLaunch); } catch (RemoteException e) { e.printStackTrace(); } }
public void getAccountsByFeatures(IAccountManagerResponse response, String type, String[] features) { try { getRemote().getAccountsByFeatures(VUserHandle.myUserId(), response, type, features); } catch (RemoteException e) { e.printStackTrace(); } }
@Override public void updateCredentials(int userId, final IAccountManagerResponse response, final Account account, final String authTokenType, final boolean expectActivityLaunch, final Bundle loginOptions) { if (response == null) throw new IllegalArgumentException("response is null"); if (account == null) throw new IllegalArgumentException("account is null"); if (authTokenType == null) throw new IllegalArgumentException("authTokenType is null"); AuthenticatorInfo info = this.getAuthenticatorInfo(account.type); if (info == null) { try { response.onError(ERROR_CODE_BAD_ARGUMENTS, "account.type does not exist"); } catch (RemoteException e) { e.printStackTrace(); } return; } new Session(response, userId, info, expectActivityLaunch, false, account.name) { @Override public void run() throws RemoteException { mAuthenticator.updateCredentials(this, account, authTokenType, loginOptions); } @Override protected String toDebugString(long now) { if (loginOptions != null) loginOptions.keySet(); return super.toDebugString(now) + ", updateCredentials" + ", " + account + ", authTokenType " + authTokenType + ", loginOptions " + loginOptions; } }.bind(); }
@Override public void editProperties(int userId, IAccountManagerResponse response, final String accountType, final boolean expectActivityLaunch) { if (response == null) throw new IllegalArgumentException("response is null"); if (accountType == null) throw new IllegalArgumentException("accountType is null"); AuthenticatorInfo info = this.getAuthenticatorInfo(accountType); if (info == null) { try { response.onError(ERROR_CODE_BAD_ARGUMENTS, "account.type does not exist"); } catch (RemoteException e) { e.printStackTrace(); } return; } new Session(response, userId, info, expectActivityLaunch, true, null) { @Override public void run() throws RemoteException { mAuthenticator.editProperties(this, mAuthenticatorInfo.desc.type); } @Override protected String toDebugString(long now) { return super.toDebugString(now) + ", editProperties" + ", accountType " + accountType; } }.bind(); }
@Override public void getAuthTokenLabel(int userId, IAccountManagerResponse response, final String accountType, final String authTokenType) { if (accountType == null) throw new IllegalArgumentException("accountType is null"); if (authTokenType == null) throw new IllegalArgumentException("authTokenType is null"); AuthenticatorInfo info = getAuthenticatorInfo(accountType); if (info == null) { try { response.onError(ERROR_CODE_BAD_ARGUMENTS, "account.type does not exist"); } catch (RemoteException e) { e.printStackTrace(); } return; } new Session(response, userId, info, false, false, null) { @Override public void run() throws RemoteException { mAuthenticator.getAuthTokenLabel(this, authTokenType); } @Override public void onResult(Bundle result) throws RemoteException { if (result != null) { String label = result.getString(AccountManager.KEY_AUTH_TOKEN_LABEL); Bundle bundle = new Bundle(); bundle.putString(AccountManager.KEY_AUTH_TOKEN_LABEL, label); super.onResult(bundle); } else { super.onResult(null); } } }.bind(); }
@Override public void addAccount(int userId, final IAccountManagerResponse response, final String accountType, final String authTokenType, final String[] requiredFeatures, final boolean expectActivityLaunch, final Bundle optionsIn) { if (response == null) throw new IllegalArgumentException("response is null"); if (accountType == null) throw new IllegalArgumentException("accountType is null"); AuthenticatorInfo info = getAuthenticatorInfo(accountType); if (info == null) { try { response.onError(ERROR_CODE_BAD_ARGUMENTS, "account.type does not exist"); } catch (RemoteException e) { e.printStackTrace(); } return; } new Session(response, userId, info, expectActivityLaunch, true, null, false, true) { @Override public void run() throws RemoteException { mAuthenticator.addAccount(this, mAuthenticatorInfo.desc.type, authTokenType, requiredFeatures, optionsIn); } @Override protected String toDebugString(long now) { return super.toDebugString(now) + ", addAccount" + ", accountType " + accountType + ", requiredFeatures " + (requiredFeatures != null ? TextUtils.join(",", requiredFeatures) : null); } }.bind(); }
private void onResult(IAccountManagerResponse response, Bundle result) { try { response.onResult(result); } catch (RemoteException e) { // if the caller is dead then there is no one to care about remote // exceptions e.printStackTrace(); } }
@Override public void addAccount(int userId, final IAccountManagerResponse response, final String accountType, final String authTokenType, final String[] requiredFeatures, final boolean expectActivityLaunch, final Bundle optionsIn) { if (response == null) throw new IllegalArgumentException("response is null"); if (accountType == null) throw new IllegalArgumentException("accountType is null"); AuthenticatorInfo info = getAuthenticatorInfo(accountType); if(info == null) { try { response.onError(ERROR_CODE_BAD_ARGUMENTS, "account.type does not exist"); } catch(RemoteException e) { e.printStackTrace(); } return; } new Session(response, userId, info, expectActivityLaunch, true, null, false, true){ @Override public void run() throws RemoteException { mAuthenticator.addAccount(this, mAuthenticatorInfo.desc.type, authTokenType, requiredFeatures, optionsIn); } @Override protected String toDebugString(long now) { return super.toDebugString(now) + ", addAccount" + ", accountType " + accountType + ", requiredFeatures " + (requiredFeatures != null ? TextUtils.join(",", requiredFeatures) : null); } }.bind(); }
IAccountManagerResponse getResponseAndClose() { if (mResponse == null) { // this session has already been closed return null; } IAccountManagerResponse response = mResponse; close(); // this clears mResponse so we need to save the response before this call return response; }
@Override public void onServiceDisconnected(ComponentName name) { mAuthenticator = null; IAccountManagerResponse response = getResponseAndClose(); if (response != null) { try { response.onError(AccountManager.ERROR_CODE_REMOTE_EXCEPTION, "disconnected"); } catch (RemoteException e) { Log.v(TAG, "Session.onServiceDisconnected: " + "caught RemoteException while responding", e); } } }