Tworzenie kodu uwierzytelniającego

Struktura adaptera synchronizacji zakłada, że adapter synchronizacji przenosi dane między pamięcią urządzenia powiązane z kontem i pamięcią serwera, która wymaga logowania. Z tego powodu platforma wymaga udostępnienia w ramach synchronizacji komponentu zwanego uwierzytelnianiem przejściówkę. Łączy się on z kontami Androida i platformą uwierzytelniania, udostępnia standardowy interfejs do obsługi danych logowania użytkownika, takich jak dane logowania.

Nawet jeśli aplikacja nie korzysta z kont, nadal musisz udostępnić komponent uwierzytelniający. Jeśli nie korzystasz z kont ani loginu do serwera, informacje są przetwarzane przez mechanizm uwierzytelniający jest ignorowany, więc możesz podać komponent uwierzytelniający zawierający metodę stub implementacji. Musisz też podać wartość Service, która umożliwia platformie adaptera synchronizacji wywoływanie metod modułu uwierzytelniającego.

Z tej lekcji dowiesz się, jak zdefiniować wszystkie części mechanizmu uwierzytelniającego, które są niezbędne spełniają wymagania platformy adaptera synchronizacji. Jeśli musisz podać dla aplikacji uwierzytelniających, która obsługuje konta użytkowników, zapoznaj się z dokumentacją AbstractAccountAuthenticator

Dodaj komponent uwierzytelniający pośrednika

Aby dodać do aplikacji komponent uwierzytelniający, utwórz klasę rozszerzoną AbstractAccountAuthenticator, a następnie wyłącz wymagane metody, przez zwrócenie null lub przez zgłoszenie wyjątku.

Ten fragment kodu zawiera przykładową klasę uwierzytelniającą „stub”:

/*
 * Implement AbstractAccountAuthenticator and stub out all
 * of its methods
 */
class Authenticator(context: Context) // Simple constructor
    : AbstractAccountAuthenticator(context) {

    // Editing properties is not supported
    override fun editProperties(r: AccountAuthenticatorResponse, s: String): Bundle {
        throw UnsupportedOperationException()
    }

    // Don't add additional accounts
    @Throws(NetworkErrorException::class)
    override fun addAccount(
            r: AccountAuthenticatorResponse,
            s: String,
            s2: String,
            strings: Array<String>,
            bundle: Bundle
    ): Bundle?  = null

    // Ignore attempts to confirm credentials
    @Throws(NetworkErrorException::class)
    override fun confirmCredentials(
            r: AccountAuthenticatorResponse,
            account: Account,
            bundle: Bundle
    ): Bundle?  = null

    // Getting an authentication token is not supported
    @Throws(NetworkErrorException::class)
    override fun getAuthToken(
            r: AccountAuthenticatorResponse,
            account: Account,
            s: String,
            bundle: Bundle
    ): Bundle {
        throw UnsupportedOperationException()
    }

    // Getting a label for the auth token is not supported
    override fun getAuthTokenLabel(s: String): String {
        throw UnsupportedOperationException()
    }

    // Updating user credentials is not supported
    @Throws(NetworkErrorException::class)
    override fun updateCredentials(
            r: AccountAuthenticatorResponse,
            account: Account,
            s: String,
            bundle: Bundle
    ): Bundle {
        throw UnsupportedOperationException()
    }

    // Checking features for the account is not supported
    @Throws(NetworkErrorException::class)
    override fun hasFeatures(
            r: AccountAuthenticatorResponse,
            account: Account,
            strings: Array<String>
    ): Bundle {
        throw UnsupportedOperationException()
    }
}

/*
 * Implement AbstractAccountAuthenticator and stub out all
 * of its methods
 */
public class Authenticator extends AbstractAccountAuthenticator {
    // Simple constructor
    public Authenticator(Context context) {
        super(context);
    }
    // Editing properties is not supported
    @Override
    public Bundle editProperties(
            AccountAuthenticatorResponse r, String s) {
        throw new UnsupportedOperationException();
    }
    // Don't add additional accounts
    @Override
    public Bundle addAccount(
            AccountAuthenticatorResponse r,
            String s,
            String s2,
            String[] strings,
            Bundle bundle) throws NetworkErrorException {
        return null;
    }
    // Ignore attempts to confirm credentials
    @Override
    public Bundle confirmCredentials(
            AccountAuthenticatorResponse r,
            Account account,
            Bundle bundle) throws NetworkErrorException {
        return null;
    }
    // Getting an authentication token is not supported
    @Override
    public Bundle getAuthToken(
            AccountAuthenticatorResponse r,
            Account account,
            String s,
            Bundle bundle) throws NetworkErrorException {
        throw new UnsupportedOperationException();
    }
    // Getting a label for the auth token is not supported
    @Override
    public String getAuthTokenLabel(String s) {
        throw new UnsupportedOperationException();
    }
    // Updating user credentials is not supported
    @Override
    public Bundle updateCredentials(
            AccountAuthenticatorResponse r,
            Account account,
            String s, Bundle bundle) throws NetworkErrorException {
        throw new UnsupportedOperationException();
    }
    // Checking features for the account is not supported
    @Override
    public Bundle hasFeatures(
        AccountAuthenticatorResponse r,
        Account account, String[] strings) throws NetworkErrorException {
        throw new UnsupportedOperationException();
    }
}

Powiąż mechanizm uwierzytelniający ze platformą

Aby platforma adaptera synchronizacji miała dostęp do uwierzytelniania, musisz utworzyć powiązanie Serwis. Ta usługa udostępnia obiekt powiązania Androida, który umożliwia korzystanie z platformy aby wywołać aplikację uwierzytelniającą i przekazać dane między tym modułem a platformą.

Ten fragment kodu pokazuje, jak określić granicę Service:

/**
* A bound Service that instantiates the authenticator
* when started.
*/
class AuthenticatorService : Service() {

    // Instance field that stores the authenticator object
    private lateinit var mAuthenticator: Authenticator

    override fun onCreate() {
        // Create a new authenticator object
        mAuthenticator = Authenticator(getApplicationContext())
    }

    /*
     * When the system binds to this Service to make the RPC call
     * return the authenticator's IBinder.
     */
    override fun onBind(intent: Intent?): IBinder = mAuthenticator.iBinder
}

/**
 * A bound Service that instantiates the authenticator
 * when started.
 */
public class AuthenticatorService extends Service {
    ...
    // Instance field that stores the authenticator object
    private Authenticator mAuthenticator;
    @Override
    public void onCreate() {
        // Create a new authenticator object
        mAuthenticator = new Authenticator(getApplicationContext());
    }
    /*
     * When the system binds to this Service to make the RPC call
     * return the authenticator's IBinder.
     */
    @Override
    public IBinder onBind(Intent intent) {
        return mAuthenticator.getIBinder();
    }
}

Dodaj plik metadanych uwierzytelniania

Aby podłączyć komponent uwierzytelniający do adaptera synchronizacji i platform konta, musisz: wraz z metadanymi opisującymi komponent. Te metadane deklarują typ konta utworzonego dla adaptera synchronizacji i deklaruje elementy interfejsu użytkownika którą system wyświetla, jeśli chcesz, aby dany rodzaj konta był widoczny dla użytkownika. Zadeklaruj to w pliku XML przechowywanym w katalogu /res/xml/ w projekcie aplikacji. Plik może mieć dowolną nazwę, ale zwykle nazywa się on authenticator.xml.

Ten plik XML zawiera jeden element <account-authenticator>, który ma następujące atrybuty:

android:accountType

Platforma adaptera synchronizacji wymaga, aby każdy adapter synchronizacji miał typ konta w postaci od nazwy domeny. Platforma wykorzystuje typ konta jako część do ich wewnętrznej identyfikacji. W przypadku serwerów wymagających logowania podaj typ konta wraz ze znakiem dane konta użytkownika są wysyłane na serwer w ramach danych logowania.

Jeśli Twój serwer nie wymaga logowania, musisz podać rodzaj konta. W przypadku atrybutu użyj nazwy domeny, nad którą masz kontrolę. Platforma używa jej do zarządzania adapter synchronizacji, wartość nie jest wysyłana do serwera.

android:icon

Wskaźnik elementu elementu rysowalnego zasób zawierający ikonę. Jeśli zapewnisz widoczność adaptera synchronizacji przez określenie parametru atrybut android:userVisible="true" w res/xml/syncadapter.xml, musisz podać tę ikonę. Jest on widoczny w sekcji Konta w aplikacji Ustawienia.

android:smallIcon

Wskaźnik elementu elementu rysowalnego z niewielką wersją ikony. Tego zasobu można użyć zamiast android:icon w sekcji Konta w systemowej aplikacji Ustawienia, w zależności od rozmiaru ekranu.

android:label

Możliwe do zlokalizowania ciąg znaków określający typ konta dla użytkowników. Jeśli skorzystasz z adaptera synchronizacji widoczne przez określenie atrybutu android:userVisible="true" w res/xml/syncadapter.xml, wpisz ten ciąg. Wyświetla się w Konta w systemowej aplikacji Ustawienia, obok ikony zdefiniowanej dla uwierzytelnianie.

Poniższy fragment kodu zawiera plik XML utworzonego wcześniej modułu uwierzytelniającego:

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

Zadeklaruj uwierzytelnianie w pliku manifestu

W poprzednim kroku utworzyłeś(-aś) powiązanie Service, które łączy uwierzytelnianie do platformy adaptera synchronizacji. Aby zidentyfikować tę usługę w systemie, zadeklaruj ją w aplikacji pliku manifestu, dodając <service> jako elementu potomnego argumentu <application>:

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

<intent-filter> konfiguruje filtr wywoływany przez działanie intencji android.accounts.AccountAuthenticator, które są wysyłane przez system w celu uruchomienia uwierzytelnianie. Po aktywowaniu filtra system rozpoczyna działanie AuthenticatorService, zakres Service podany w celu opakowania uwierzytelniającego.

<meta-data> deklaruje metadane modułu uwierzytelniającego. android:name łączy metadane ze platformą uwierzytelniania. android:resource określa nazwę utworzonego wcześniej pliku metadanych uwierzytelniania.

Oprócz uwierzytelniania adapter synchronizacji wymaga też dostawcy treści. Jeśli aplikacja nie korzysta już z dostawcy treści, przejdź do następnej lekcji, aby dowiedzieć się, jak utworzyć treść skróconą. usługodawcy; W przeciwnym razie przejdź do lekcji Tworzenie adaptera synchronizacji.