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:
Kotlin
/* * 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() } }
Java
/* * 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é:
Kotlin
/** * 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 }
Java
/** * 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"dansres/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:icondans 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"dansres/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.