Créer un authentificateur de bouchon

Le framework de l'adaptateur de synchronisation suppose que votre adaptateur de synchronisation transfère les données entre l'espace de stockage de l'appareil associé à un espace de stockage de compte et de serveur qui nécessite un accès de connexion. Pour cette raison, le s'attend à ce que vous fournissiez un composant appelé authentificateur lors de la synchronisation adaptateur secteur. Ce composant s'intègre dans le framework d'authentification et les comptes Android. fournit une interface standard pour gérer les identifiants des utilisateurs, tels que les informations de connexion.

Même si votre application n'utilise pas de comptes, vous devez tout de même fournir un composant d'authentification. Si vous n'utilisez pas de compte ni de connexion au serveur, les informations gérées par l'authentificateur sont ignoré. Vous pouvez donc fournir un composant d'authentification contenant la méthode bouchon mises en œuvre. Vous devez également fournir un Service lié qui permet au framework d'adaptateur de synchronisation d'appeler les méthodes de l'authentificateur.

Cette leçon explique comment définir les éléments d'un authentificateur de bouchon nécessaires répondent aux exigences du framework d'adaptateur de synchronisation. Si vous devez fournir une véritable qui gère les comptes d'utilisateurs, consultez la documentation de référence AbstractAccountAuthenticator

Ajouter un composant d'authentification bouchon

Pour ajouter un composant d'authentification bouchon à votre application, créez une classe qui s'étend sur AbstractAccountAuthenticator, puis bouchons les méthodes requises, soit en renvoyant null, soit en générant une exception.

L'extrait de code suivant montre un exemple de classe d'authentificateur de bouchon:

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

Lier l'authentificateur au framework

Pour que le framework d'adaptateur de synchronisation puisse accéder à votre authentificateur, vous devez créer une liaison de service. Ce service fournit un objet de liaison Android qui permet au framework pour appeler votre authentificateur et transmettre des données entre celui-ci et le framework.

L'extrait de code suivant montre comment définir le Service lié:

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

Ajouter le fichier de métadonnées de l'authentificateur

Pour connecter votre composant Authenticator à l'adaptateur de synchronisation et aux frameworks de compte, vous devez : fournissez à ce framework des métadonnées qui décrivent le composant. Cette métadonnée déclare type de compte que vous avez créé pour votre adaptateur de synchronisation et déclare les éléments de l'interface utilisateur que le système affiche si vous souhaitez que votre type de compte soit visible pour l’utilisateur. Déclarer ceci dans un fichier XML stocké dans le répertoire /res/xml/ de votre projet d'application. Vous pouvez attribuer n'importe quel nom au fichier, bien qu'il porte généralement le nom authenticator.xml.

Ce fichier XML contient un seul élément <account-authenticator> qui présente les attributs suivants:

android:accountType

Le framework d'adaptateur de synchronisation exige que chaque adaptateur de synchronisation soit associé à un type de compte, au format suivant : d'un nom de domaine. Le framework utilise le type de compte dans le champ une identification interne. Pour les serveurs nécessitant une connexion, le type de compte, accompagné d'un compte utilisateur est envoyé au serveur avec les identifiants de connexion.

Si votre serveur ne nécessite pas de connexion, vous devez quand même indiquer un type de compte. Pour le utilisez un nom de domaine que vous contrôlez. Bien que le framework l'utilise pour gérer adaptateur de synchronisation, la valeur n'est pas envoyée à votre serveur.

android:icon

Pointeur vers un drawable contenant une icône. Si vous rendez l'adaptateur de synchronisation visible en spécifiant le l'attribut android:userVisible="true" dans res/xml/syncadapter.xml, vous devez fournir cette ressource d'icône. Il apparaît dans la section Comptes de l'application Paramètres du système.

android:smallIcon

Pointeur vers un drawable ressource contenant une petite version de l'icône. Cette ressource peut être utilisée à la place android:icon dans la section Comptes de l'application Paramètres du système ; en fonction de la taille de l'écran.

android:label

Chaîne localisable identifiant le type de compte aux utilisateurs. Si vous utilisez l'adaptateur visible en spécifiant l'attribut android:userVisible="true" dans res/xml/syncadapter.xml, vous devez alors fournir cette chaîne. Il apparaît dans section Comptes de l'application Paramètres du système, à côté de l'icône définie pour le authentificateur.

L'extrait de code suivant montre le fichier XML de l'authentificateur que vous avez créé précédemment:

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

Déclarer l'authentificateur dans le fichier manifeste

Lors d'une étape précédente, vous avez créé un Service lié qui associe l'authentificateur au framework d'adaptateur de synchronisation. Pour identifier ce service auprès du système, déclarez-le dans votre appli en ajoutant le code suivant : <service> en tant qu'élément enfant de <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>

La <intent-filter> configure un filtre déclenché par l'action d'intent. android.accounts.AccountAuthenticator, qui est envoyé par le système pour exécuter authentificateur. Lorsque le filtre est déclenché, le système démarre AuthenticatorService, le Service lié que vous avez fourni pour encapsuler l'authentificateur.

La <meta-data> déclare les métadonnées pour l'authentificateur. La android:name associe les métadonnées au framework d'authentification. La android:resource spécifie le nom du fichier de métadonnées d'authentificateur que vous avez créé précédemment.

En plus d'un authentificateur, l'adaptateur de synchronisation requiert également un fournisseur de contenu. Si votre application ne utilisez déjà un fournisseur de contenu, passez à la leçon suivante pour apprendre à créer un contenu stub fournisseur ; Sinon, reportez-vous à la leçon Créer un adaptateur de synchronisation.