Criar um autenticador de stubs

O framework do adaptador de sincronização presume que o adaptador de sincronização transfere dados entre o armazenamento do dispositivo. associadas a uma conta e ao armazenamento no servidor que exige acesso por login. Por esse motivo, a espera que você forneça um componente chamado autenticador como parte da sincronização. por um adaptador. Esse componente se conecta às contas do Android e ao framework de autenticação e fornece uma interface padrão para gerenciar credenciais do usuário, como informações de login.

Mesmo que seu app não use contas, você precisa fornecer um componente de autenticação. Se você não usar login em contas ou no servidor, as informações processadas pelo autenticador serão ignorados, para que você possa fornecer um componente autenticador que contenha o método stub e implementações. Também é necessário fornecer um Service vinculado que permite que o framework do adaptador de sincronização chame os métodos do autenticador.

Esta lição mostra como definir todas as partes de um autenticador de stubs necessárias atendem aos requisitos do framework do adaptador de sincronização. Se você precisar fornecer um autenticador que lida com contas de usuário, leia a documentação de referência para AbstractAccountAuthenticator:

Adicionar um componente autenticador de stubs

Para adicionar um componente autenticador de stubs ao app, crie uma classe que estenda AbstractAccountAuthenticator e, em seguida, fragmentar os métodos necessários retornando null ou gerando uma exceção.

O snippet a seguir mostra um exemplo de uma classe de autenticador de stubs.

/*
 * 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();
    }
}

Vincular o autenticador ao framework

Para que o framework do adaptador de sincronização acesse seu autenticador, você precisa criar uma que oferece um serviço para isso. Esse serviço oferece um objeto binder do Android que permite que o framework para chamar seu autenticador e transmitir dados entre ele e o framework.

O snippet a seguir mostra como definir o Service vinculado:

/**
* 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();
    }
}

Adicionar o arquivo de metadados do autenticador

Para conectar o componente autenticador ao adaptador de sincronização e aos frameworks de conta, você precisa: fornecem metadados que descrevem o componente a essa estrutura. Esses metadados declaram tipo de conta que você criou para o adaptador de sincronização e declara elementos de interface do usuário exibido pelo sistema se você quiser deixar seu tipo de conta visível para o usuário. Declarar metadados em um arquivo XML armazenado no diretório /res/xml/ no projeto do app. Você pode dar qualquer nome ao arquivo, embora ele seja normalmente chamado de authenticator.xml.

Esse arquivo XML contém um único elemento <account-authenticator> que tem os seguintes atributos:

android:accountType

O framework do adaptador de sincronização exige que cada adaptador de sincronização tenha um tipo de conta, no formato de um nome de domínio. O framework usa o tipo de conta como parte do identificação interna. Para servidores que exigem login, o tipo de conta, juntamente com um conta de usuário é enviada para o servidor como parte das credenciais de login.

Mesmo que seu servidor não exija login, você ainda precisará fornecer um tipo de conta. Para o use um nome de domínio que você controla. O framework usa isso para gerenciar adaptador de sincronização, o valor não será enviado ao servidor.

android:icon

Ponteiro para um Drawable recurso que contém um ícone. Se você tornar o adaptador de sincronização visível especificando o atributo android:userVisible="true" em res/xml/syncadapter.xml, forneça esse recurso de ícone. Ele aparece na seção Contas do no app Configurações do sistema.

android:smallIcon

Ponteiro para um Drawable recurso que contém uma versão pequena do ícone. Este recurso pode ser usado em vez de android:icon na seção Contas do app Configurações do sistema dependendo do tamanho da tela.

android:label

String localizável que identifica o tipo de conta para os usuários. Se você criar o adaptador de sincronização visível especificando o atributo android:userVisible="true" no res/xml/syncadapter.xml, você vai precisar fornecer essa string. Ele aparece na seção Contas do app Configurações do sistema, ao lado do ícone definido para o autenticador.

O snippet a seguir mostra o arquivo XML para o autenticador criado anteriormente.

<?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"/>

Declarar o autenticador no manifesto

Em uma etapa anterior, você criou um Service vinculado que vincula o autenticador ao framework do adaptador de sincronização. Para identificar esse serviço para o sistema, declare-o no seu app o manifesto adicionando o seguinte <service> como um elemento filho <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>

A <intent-filter> define um filtro que é acionado pela ação da intent android.accounts.AccountAuthenticator, que é enviada pelo sistema para executar a autenticador. Quando o filtro é acionado, o sistema inicia AuthenticatorService, A Service vinculada que você forneceu para unir o autenticador.

A <meta-data> declara os metadados para o autenticador. A android:name vincula os metadados à estrutura de autenticação. A android:resource especifica o nome do arquivo de metadados do autenticador criado anteriormente.

Além de um autenticador, um adaptador de sincronização também exige um provedor de conteúdo. Caso seu app não já usa um provedor de conteúdo, vá para a próxima lição para aprender a criar um conteúdo stub fornecedor; Caso contrário, vá para a lição Como criar um adaptador de sincronização.