Mogę mieć więcej niż jedno konto przechowywane?

Czy to z powodu problemów z synchronizacją?

Tak, potrzebujesz konta, aby użyć mechanizmu synchronizacji, takiego jak SyncAdapter

Dlaczego warto używać AccountAuthenticator?

• Obsługa mechanizmu synchronizacji tła jak SyncAdapter;

• Standardowy sposób uwierzytelniania użytkownicy;

• Obsługa różnych tokenów;

• Udostępnianie kont z różnymi uprawnieniami

1). Create Authenticator;

2). Utwórz Activity dla logowania użytkownika;

3). Utwórz Service, aby komunikować się z kontem.

Warunki.

AccountManager - zarządza kontem na urządzeniu. Żądaj tokenów auth, których powinieneś używać AccountManager.

AbstractAccountAuthenticator - komponent do pracy z typami kont. Zawiera całą logikę pracy z kontem (autoryzacja, prawa dostępu itp.) Jeden AbstractAccountAuthenticator może być używany przez różne aplikacje (np. konto Google dla Gmaila, Kalendarz, dysk itp.)

AccountAuthenticatorActivity - base Activity, for authorize / create account. AccountManager wywołuje to konto, jeśli jest to konieczne do identyfikacji konta (Token nie istnieje lub expired)

Kroki.

1). Create Authenticator;

Musisz rozszerzyć AbstractAccountAuthenticator i nadpisać 7 metod:

• Bundle editProperties(AccountAuthenticatorResponse response, String accountType) link
• Bundle addAccount(AccountAuthenticatorResponse response, String accountType, String authTokenType, String[] requiredFeatures, Bundle options) link
• Bundle confirmCredentials(AccountAuthenticatorResponse response, Account account, Bundle options) link
• Bundle getAuthToken(AccountAuthenticatorResponse response, Account account, String authTokenType, Bundle options) link
• String getAuthTokenLabel(String authTokenType) link
• Bundle updateCredentials(AccountAuthenticatorResponse response, Account account, String authTokenType, Bundle options) link
• Bundle hasFeatures(AccountAuthenticatorResponse response, Account account, String[] features) link

Przykład:

public class LodossAuthenticator extends AbstractAccountAuthenticator {

    private static final String LOG_TAG = LodossAuthenticator.class.getSimpleName();

    private final Context mContext;

    public LodossAuthenticator(Context context) {
        super(context);
        mContext = context;
    }

    @Override
    public Bundle editProperties(AccountAuthenticatorResponse response, String accountType) {
        return null;
    }

    @Override
    public Bundle addAccount(AccountAuthenticatorResponse response, String accountType, String authTokenType, String[] requiredFeatures, Bundle options) throws NetworkErrorException {
        final Intent intent = new Intent(mContext, CustomServerAuthenticatorSigninActivity.class);
        intent.putExtra(Config.ARG_ACCOUNT_TYPE, accountType);
        intent.putExtra(Config.ARG_AUTH_TYPE, authTokenType);
        intent.putExtra(Config.ARG_IS_ADDING_NEW_ACCOUNT, true);
        intent.putExtra(AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE, response);

        final Bundle bundle = new Bundle();
    bundle.putParcelable(AccountManager.KEY_INTENT, intent);
    return bundle;
    }

    @Override
    public Bundle confirmCredentials(AccountAuthenticatorResponse response, Account account, Bundle options) throws NetworkErrorException {
        return null;
    }

    @Override
    public Bundle getAuthToken(AccountAuthenticatorResponse response, Account account, String authTokenType, Bundle options) throws NetworkErrorException {
        // If the caller requested an authToken type we don't support, then
        // return an error
        if (!authTokenType.equals(AccountGeneral.AUTHTOKEN_TYPE_READ_ONLY) && !authTokenType.equals(AccountGeneral.AUTHTOKEN_TYPE_FULL_ACCESS)) {
            final Bundle result = new Bundle();
            result.putString(AccountManager.KEY_ERROR_MESSAGE, "invalid authTokenType");
            return result;
        }

        // Extract the username and password from the Account Manager, and ask
        // the server for an appropriate AuthToken.
        final AccountManager am = AccountManager.get(mContext);
        String authToken = am.peekAuthToken(account, authTokenType);

        // Lets give another try to authenticate the user
        if (TextUtils.isEmpty(authToken)) {
            final String password = am.getPassword(account);
            if (password != null) {
                try {
                    authToken = sServerAuthenticate.userSignIn(account.name, password, authTokenType);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

        // If we get an authToken - we return it
        if (!TextUtils.isEmpty(authToken)) {
            final Bundle result = new Bundle();
            result.putString(AccountManager.KEY_ACCOUNT_NAME, account.name);
            result.putString(AccountManager.KEY_ACCOUNT_TYPE, account.type);
            result.putString(AccountManager.KEY_AUTHTOKEN, authToken);
            return result;
        }

        // If we get here, then we couldn't access the user's password - so we
        // need to re-prompt them for their credentials. We do that by creating
        // an intent to display our AuthenticatorActivity.
        final Intent intent = new Intent(mContext, AuthenticatorActivity.class);
        intent.putExtra(AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE, response);
        intent.putExtra(com.lodoss.authlib.Config.ARG_ACCOUNT_TYPE, account.type);
        intent.putExtra(com.lodoss.authlib.Config.ARG_AUTH_TYPE, authTokenType);
        intent.putExtra(Config.ARG_ACCOUNT_NAME, account.name);
        final Bundle bundle = new Bundle();
    bundle.putParcelable(AccountManager.KEY_INTENT, intent);
    return bundle;
    }

    @Override
    public String getAuthTokenLabel(String authTokenType) {
        if (AccountGeneral.AUTHTOKEN_TYPE_FULL_ACCESS.equals(authTokenType))
            return AccountGeneral.AUTHTOKEN_TYPE_FULL_ACCESS_LABEL;
        else if (AccountGeneral.AUTHTOKEN_TYPE_READ_ONLY.equals(authTokenType))
            return AccountGeneral.AUTHTOKEN_TYPE_READ_ONLY_LABEL;
        else
            return authTokenType + " (Label)";
    }

    @Override
    public Bundle updateCredentials(AccountAuthenticatorResponse response, Account account, String authTokenType, Bundle options) throws NetworkErrorException {
        return null;
    }

    @Override
    public Bundle hasFeatures(AccountAuthenticatorResponse response, Account account, String[] features) throws NetworkErrorException {
        final Bundle result = new Bundle();
        result.putBoolean(KEY_BOOLEAN_RESULT, false);
        return result;
    }
}

Wyjaśnienie:

Więc musisz zobaczyć tylko 2 metody: addAccount, getAuthToken.

W addAccount dodałem kilka param config, które będą używane przez mojego Activity do logowania użytkownika. Głównym punktem jest intent.putExtra(Config.ARG_ACCOUNT_TYPE, accountType); - należy tutaj określić typ konta. Inne manipulacje nie są konieczne.

W getAuthToken - Przeczytaj komentarze proszę . Skopiowałem tę metodę z UdinicAuthenticator.java

Również, będziesz potrzebować następujących uprawnień w AndroidManifest.xml:

<uses-permission android:name="android.permission.GET_ACCOUNTS" />
<uses-permission android:name="android.permission.MANAGE_ACCOUNTS" />
<uses-permission android:name="android.permission.AUTHENTICATE_ACCOUNTS" />
<uses-permission android:name="android.permission.USE_CREDENTIALS" />

Podsumowanie z metod addAccount i getAuthToken

Spróbuj uzyskać token, jeśli token istnieje zwróć wynik, w przeciwnym razie zobaczysz Activity dla autoryzacji

2). Utwórz Activity dla logowania użytkownika;

ZobaczAuthenticator

Krótkie wyjaśnienie: Utwórz formularz z UserId i hasłem. Używanie identyfikatora użytkownika i hasła dane pobierają Token auth z serwera, a następnie wykonują następujący krok:

mAccountManager.addAccountExplicitly(account, accountPassword, null);
mAccountManager.setAuthToken(account, authtokenType, authtoken);

3). Utwórz Service, aby komunikować się z kontem.

Zobacz UdinicAuthenticatorService

Nie zapomnij dodać tej linii w AndroidManifest.xml do Service:

    <intent-filter>
        <action android:name="android.accounts.AccountAuthenticator" />
    </intent-filter>
    <meta-data android:name="android.accounts.AccountAuthenticator"
               android:resource="@xml/authenticator" />

A także w res/xml Dodaj plik authenticator.xml:

<?xml version="1.0" encoding="utf-8"?>
<account-authenticator xmlns:android="http://schemas.android.com/apk/res/android"
                       android:accountType="com.mediamanagment.app"
                       android:icon="@drawable/ic_launcher"
                       android:smallIcon="@drawable/ic_launcher"
                       android:label="@string/authenticator_label"/>

Dla materiałów źródłowych dzięki

• Udi Cohen;

• Daniel Serdyukov (cały tekst przetłumaczony z jego artykułu (oprócz mojego małe dodatki) " synchronizacja w aplikacjach na Androida. Część 1 " tylko po rosyjsku. link: http://habrahabr.ru/company/e-Legion/blog/206210/)