| /* |
| * Copyright (C) 2009 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 android.accounts; |
| |
| import android.os.RemoteException; |
| import android.os.Bundle; |
| import android.app.PendingIntent; |
| import android.app.Activity; |
| import android.content.Intent; |
| import android.content.Context; |
| |
| import java.util.concurrent.locks.Lock; |
| import java.util.concurrent.locks.ReentrantLock; |
| import java.util.concurrent.locks.Condition; |
| |
| /** |
| * A class that helps with interactions with the {@link IAccountManager} interface. It provides |
| * methods to allow for account, password, and authtoken management for all accounts on the |
| * device. Some of these calls are implemented with the help of the corresponding |
| * {@link IAccountAuthenticator} services. One accesses the {@link AccountManager} by calling: |
| * AccountManager accountManager = |
| * (AccountManager)context.getSystemService(Context.ACCOUNT_SERVICE) |
| * |
| * <p> |
| * TODO: this interface is still in flux |
| */ |
| public class AccountManager { |
| private static final String TAG = "AccountManager"; |
| |
| private final Context mContext; |
| private final IAccountManager mService; |
| |
| public AccountManager(Context context, IAccountManager service) { |
| mContext = context; |
| mService = service; |
| } |
| |
| public String getPassword(Account account) { |
| try { |
| return mService.getPassword(account); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| throw new RuntimeException(e); |
| } |
| } |
| |
| public String getUserData(Account account, String key) { |
| try { |
| return mService.getUserData(account, key); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| throw new RuntimeException(e); |
| } |
| } |
| |
| public Account[] blockingGetAccounts() { |
| try { |
| return mService.getAccounts(); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| throw new RuntimeException(e); |
| } |
| } |
| |
| public void getAccounts(final PendingIntent intent, final int code) { |
| getAccountsByType(null /* all account types */, intent, code); |
| } |
| |
| public void getAccountsByType(final String accountType, |
| final PendingIntent intent, final int code) { |
| Thread t = new Thread() { |
| public void run() { |
| try { |
| Account[] accounts; |
| if (accountType != null) { |
| accounts = blockingGetAccountsByType(accountType); |
| } else { |
| accounts = blockingGetAccounts(); |
| } |
| Intent payload = new Intent(); |
| payload.putExtra("accounts", accounts); |
| intent.send(mContext, code, payload); |
| } catch (PendingIntent.CanceledException e) { |
| // the pending intent is no longer accepting results, we don't |
| // need to do anything to handle this |
| } |
| } |
| }; |
| t.start(); |
| } |
| |
| public Account[] blockingGetAccountsByType(String accountType) { |
| try { |
| return mService.getAccountsByType(accountType); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| throw new RuntimeException(e); |
| } |
| } |
| |
| public boolean addAccount(Account account, String password, Bundle extras) { |
| try { |
| return mService.addAccount(account, password, extras); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| throw new RuntimeException(e); |
| } |
| } |
| |
| public void removeAccount(Account account) { |
| try { |
| mService.removeAccount(account); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| } |
| } |
| |
| public void invalidateAuthToken(String accountType, String authToken) { |
| try { |
| mService.invalidateAuthToken(accountType, authToken); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| } |
| } |
| |
| public String peekAuthToken(Account account, String authTokenType) { |
| try { |
| return mService.peekAuthToken(account, authTokenType); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| throw new RuntimeException(e); |
| } |
| } |
| |
| public void setPassword(Account account, String password) { |
| try { |
| mService.setPassword(account, password); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| } |
| } |
| |
| public void clearPassword(Account account) { |
| try { |
| mService.clearPassword(account); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| } |
| } |
| |
| public void setUserData(Account account, String key, String value) { |
| try { |
| mService.setUserData(account, key, value); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| } |
| } |
| |
| public void getAuthToken(AccountManagerResponse response, |
| Account account, String authTokenType, boolean notifyAuthFailure) { |
| try { |
| mService.getAuthToken(response.getIAccountManagerResponse(), account, authTokenType, |
| notifyAuthFailure); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| } |
| } |
| |
| public void setAuthToken(Account account, String authTokenType, String authToken) { |
| try { |
| mService.setAuthToken(account, authTokenType, authToken); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| } |
| } |
| |
| public void addAccountInteractively(AccountManagerResponse response, String accountType) { |
| try { |
| mService.addAccountInteractively(response.getIAccountManagerResponse(), accountType); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| } |
| } |
| |
| public class AuthenticateAccountThread extends Thread { |
| public Lock mLock = new ReentrantLock(); |
| public Condition mCondition = mLock.newCondition(); |
| volatile boolean mSuccess = false; |
| volatile boolean mFailure = false; |
| volatile boolean mResult = false; |
| private final Account mAccount; |
| private final String mPassword; |
| public AuthenticateAccountThread(Account account, String password) { |
| mAccount = account; |
| mPassword = password; |
| } |
| public void run() { |
| try { |
| IAccountManagerResponse response = new IAccountManagerResponse.Stub() { |
| public void onStringResult(String value) throws RemoteException { |
| } |
| |
| public void onIntResult(int value) throws RemoteException { |
| } |
| |
| public void onBooleanResult(boolean value) throws RemoteException { |
| mLock.lock(); |
| try { |
| if (!mFailure && !mSuccess) { |
| mSuccess = true; |
| mResult = value; |
| mCondition.signalAll(); |
| } |
| } finally { |
| mLock.unlock(); |
| } |
| } |
| |
| public void onError(int errorCode, String errorMessage) { |
| mLock.lock(); |
| try { |
| if (!mFailure && !mSuccess) { |
| mFailure = true; |
| mCondition.signalAll(); |
| } |
| } finally { |
| mLock.unlock(); |
| } |
| } |
| }; |
| |
| mService.authenticateAccount(response, mAccount, mPassword); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| } |
| } |
| } |
| |
| public boolean authenticateAccount(Account account, String password) { |
| AuthenticateAccountThread thread = new AuthenticateAccountThread(account, password); |
| thread.mLock.lock(); |
| thread.start(); |
| try { |
| while (!thread.mSuccess && !thread.mFailure) { |
| try { |
| thread.mCondition.await(); |
| } catch (InterruptedException e) { |
| // keep waiting |
| } |
| } |
| return thread.mResult; |
| } finally { |
| thread.mLock.unlock(); |
| } |
| } |
| |
| public void updatePassword(AccountManagerResponse response, Account account) { |
| try { |
| mService.updatePassword(response.getIAccountManagerResponse(), account); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| } |
| } |
| |
| public void editProperties(AccountManagerResponse response, String accountType) { |
| try { |
| mService.editProperties(response.getIAccountManagerResponse(), accountType); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| } |
| } |
| |
| public void getPasswordStrength(AccountManagerResponse response, |
| String accountType, String password) { |
| try { |
| mService.getPasswordStrength(response.getIAccountManagerResponse(), |
| accountType, password); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| } |
| } |
| |
| public void checkUsernameExistence(AccountManagerResponse response, |
| String accountType, String username) { |
| try { |
| mService.checkUsernameExistence(response.getIAccountManagerResponse(), |
| accountType, username); |
| } catch (RemoteException e) { |
| // if this happens the entire runtime will restart |
| } |
| } |
| } |