La struttura dell'adattatore di sincronizzazione presuppone che l'adattatore di sincronizzazione trasferisca i dati tra lo spazio di archiviazione del dispositivo associati a uno spazio di archiviazione di account e server che richiede l'accesso tramite login. Per questo motivo, si aspetta che tu fornisca un componente chiamato autenticatore come parte della sincronizzazione dell'adattatore. Questo componente si collega agli account e al framework di autenticazione Android e Fornisce un'interfaccia standard per la gestione delle credenziali utente, come i dati di accesso.
Anche se la tua app non usa account, devi comunque fornire un componente di autenticazione.
Se non utilizzi account o dati di accesso al server, le informazioni gestite dall'autenticatore sono
ignorato, quindi puoi fornire un componente di autenticazione che contiene il metodo stub
implementazioni. Devi anche fornire un valore Service associato che
consente al framework dell'adattatore di sincronizzazione di chiamare i metodi dell'autenticatore.
Questa lezione mostra come definire tutte le parti di un autenticatore stub che devono
soddisfare i requisiti del framework dell'adattatore di sincronizzazione. Se devi fornire un modello
di autenticazione che gestisce gli account utente, leggi la documentazione di riferimento per
AbstractAccountAuthenticator.
Aggiungi un componente di autenticazione stub
Per aggiungere un componente di autenticazione stub alla tua app, crea una classe che si estenda
AbstractAccountAuthenticator e poi illustrare i metodi richiesti,
restituendo null o generando un'eccezione.
Lo snippet seguente mostra un esempio di classe di autenticazione stub:
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(); } }
Associa l'autenticatore al framework
Affinché il framework dell'adattatore di sincronizzazione possa accedere al tuo autenticatore, devi creare un per questo. Questo servizio fornisce un oggetto binder Android che consente al framework per chiamare l'autenticatore e trasferire i dati tra quest'ultimo e il framework.
Il seguente snippet mostra come definire l'elemento Service associato:
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(); } }
Aggiungi il file dei metadati dell'autenticatore
Per collegare il componente di autenticazione all'adattatore di sincronizzazione e ai framework dell'account, devi:
fornire a questo framework metadati che descrivono il componente. Questi metadati dichiarano
che hai creato per l'adattatore di sincronizzazione e dichiara gli elementi dell'interfaccia utente
che il sistema visualizza se vuoi rendere visibile all'utente il tuo tipo di account. Dichiara
metadati in un file XML archiviato nella directory /res/xml/ del progetto dell'app.
Puoi assegnare qualsiasi nome al file, anche se in genere è chiamato authenticator.xml.
Questo file XML contiene un singolo elemento <account-authenticator> che
presenta i seguenti attributi:
-
android:accountType -
Il framework dell'adattatore di sincronizzazione richiede che ogni adattatore di sincronizzazione abbia un tipo di account, nel formato
di un nome di dominio. Il framework utilizza il tipo di account come parte della
per l'identificazione interna. Per i server che richiedono l'accesso, il tipo di account e
viene inviato al server come parte delle credenziali di accesso.
Se il server non richiede l'accesso, devi comunque fornire un tipo di account. Per , utilizza un nome di dominio controllato da te. mentre il framework lo utilizza per gestire l'adattatore di sincronizzazione, il valore non viene inviato al server.
-
android:icon -
Puntare a un elemento Drawable
risorsa contenente un'icona. Se rendi visibile l'adattatore di sincronizzazione specificando il parametro
attributo
android:userVisible="true"inres/xml/syncadapter.xml, devi fornire la risorsa icona. Viene visualizzato nella sezione Account di nell'app Impostazioni del sistema. -
android:smallIcon -
Puntare a un elemento Drawable
risorsa contenente una versione ridotta dell'icona. Questa risorsa può essere utilizzata al posto di
android:iconnella sezione Account dell'app Impostazioni del sistema, in base alle dimensioni dello schermo. -
android:label -
Stringa localizzabile che identifica il tipo di account per gli utenti. Se crei l'adattatore di sincronizzazione
visibile specificando l'attributo
android:userVisible="true"inres/xml/syncadapter.xml, devi fornire questa stringa. Appare nella sezione Account dell'app Impostazioni del sistema, accanto all'icona che definisci per di autenticazione.
Lo snippet seguente mostra il file XML per l'autenticatore creato in precedenza:
<?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"/>
Dichiara l'autenticatore nel file manifest
In un passaggio precedente, hai creato un elemento Service associato che collega l'autenticatore
al framework dell'adattatore di sincronizzazione. Per identificare questo servizio per il sistema, dichiaralo nella tua app
del file manifest aggiungendo il seguente
<service>
come elemento secondario di
<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>
configura un filtro che viene attivato dall'azione di intent
android.accounts.AccountAuthenticator, inviata dal sistema per eseguire
di autenticazione. Quando il filtro viene attivato, il sistema avvia AuthenticatorService,
il Service associato che hai fornito per eseguire il wrapping dell'autenticatore.
La
<meta-data>
dichiara i metadati per l'autenticatore. La
android:name
collega i metadati al framework di autenticazione. La
android:resource
specifica il nome del file dei metadati dell'autenticatore creato in precedenza.
Oltre all'autenticatore, anche un adattatore di sincronizzazione richiede un fornitore di contenuti. Se la tua app non Se usi già un fornitore di contenuti, passa alla lezione successiva per imparare a creare contenuti stub. fornitore; In caso contrario, consulta la lezione Creazione di un adattatore di sincronizzazione.