Stub-Authenticator erstellen

Das Framework des Sync Adapters geht davon aus, dass Ihr Synchronisierungsadapter Daten zwischen Gerätespeichern überträgt. die mit einem Konto und einem Serverspeicher verknüpft sind, für den eine Anmeldung erforderlich ist. Aus diesem Grund erwartet Sie, dass Sie eine Komponente, die als Authenticator bezeichnet wird, im Rahmen der Synchronisierung bereitstellen. Adapter. Diese Komponente wird mit dem Android-Framework und der Authentifizierung verbunden. stellt eine Standardoberfläche für die Verarbeitung von Nutzeranmeldedaten wie Anmeldedaten zur Verfügung.

Auch wenn Ihre App keine Konten verwendet, müssen Sie eine Authentifizierungskomponente bereitstellen. Wenn Sie weder Konten noch Server-Login verwenden, werden die Informationen, die vom Authenticator verarbeitet werden, ignoriert werden, sodass Sie eine Authenticator-Komponente bereitstellen können, die die Stub-Methode enthält Implementierungen. Sie müssen auch eine gebundene Service angeben, die ermöglicht dem Synchronisierungsadapter-Framework, die Methoden des Authenticators aufzurufen.

In dieser Lektion erfahren Sie, wie Sie alle Bestandteile eines Stub-Authentizators definieren, die Anforderungen des Frameworks für den Synchronisierungsadapter erfüllen. Wenn Sie einen echten Authenticator, der Nutzerkonten verarbeitet, finden Sie in der Referenzdokumentation für AbstractAccountAuthenticator

Stub-Authentifikatorkomponente hinzufügen

Um Ihrer App eine Stub-Authentifikatorkomponente hinzuzufügen, erstellen Sie eine Klasse, die die AbstractAccountAuthenticator und führen Sie dann einen Stub-out für die erforderlichen Methoden durch. entweder durch Rückgabe von null oder durch Auslösen einer Ausnahme.

Das folgende Snippet zeigt ein Beispiel für eine Stub-Authentifikatorklasse:

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

Binden Sie den Authenticator an das Framework.

Damit das Synchronisierungsadapter-Framework auf Ihren Authenticator zugreifen kann, müssen Sie eine gebundene Service für sie. Dieser Dienst stellt ein Android-Binderobjekt bereit, das das Framework ermöglicht. um Ihren Authenticator aufzurufen und Daten zwischen dem Authenticator und dem Framework zu übergeben.

Das folgende Snippet zeigt, wie die gebundene Service definiert wird:

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

Authenticator-Metadatendatei hinzufügen

Um Ihre Authentifizierungskomponente mit dem Synchronisierungsadapter und den Konto-Frameworks zu verbinden, müssen Sie Framework mit Metadaten bereitstellen, die die Komponente beschreiben. Diese Metadaten deklariert die Kontotyp, den Sie für den Synchronisierungsadapter erstellt haben, und deklariert Elemente der Benutzeroberfläche das das System anzeigt, wenn Sie Ihren Kontotyp für den Nutzer sichtbar machen möchten. Deklarieren Metadaten in einer XML-Datei, die im Verzeichnis /res/xml/ Ihres Anwendungsprojekts gespeichert ist. Sie können der Datei einen beliebigen Namen geben, obwohl sie normalerweise als authenticator.xml bezeichnet wird.

Diese XML-Datei enthält ein einzelnes Element <account-authenticator>, das verfügt über die folgenden Attribute:

android:accountType

Für das Framework des Synchronisierungsadapters muss jeder Synchronisierungsadapter einen Kontotyp im Format eines Domainnamens. Das Framework verwendet den Kontotyp als Teil des Synchronisierungsadapters der internen Identifizierung. Bei Servern, für die eine Anmeldung erforderlich ist, muss der Kontotyp zusammen mit einem Nutzerkonto wird als Teil der Anmeldedaten an den Server gesendet.

Auch wenn für Ihren Server keine Anmeldung erforderlich ist, müssen Sie einen Kontotyp angeben. Für die verwenden, verwenden Sie einen von Ihnen verwalteten Domainnamen. Das Framework nutzt es zur Verwaltung Ihrer Sync-Adapter verwenden, wird der Wert nicht an Ihren Server gesendet.

android:icon

Zeiger auf ein Drawable Ressource mit einem Symbol. Wenn Sie den Synchronisierungsadapter sichtbar machen, indem Sie den Parameter Attribut android:userVisible="true" in res/xml/syncadapter.xml, müssen Sie diese Symbolressource angeben. Sie befindet sich im Bereich Konten der über die App „Einstellungen“ des Systems.

android:smallIcon

Zeiger auf ein Drawable Ressource mit einer kleinen Version des Symbols. Diese Ressource kann anstelle von android:icon im Bereich Konten der App "Einstellungen" des Systems je nach Bildschirmgröße.

android:label

Lokalisierbarer String, der Nutzern den Kontotyp identifiziert. Wenn Sie den Synchronisierungsadapter erstellen sichtbar ist, indem das Attribut android:userVisible="true" in res/xml/syncadapter.xml eingeben, müssen Sie diesen String angeben. Sie erscheint in der Konten in der App "Einstellungen" des Systems neben dem Symbol, das Sie für das Authenticator.

Das folgende Snippet zeigt die XML-Datei für den Authenticator, den Sie zuvor erstellt haben:

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

Authenticator im Manifest deklarieren

In einem vorherigen Schritt haben Sie eine gebundene Service-Funktion erstellt, die den Authenticator verknüpft. mit dem Synchronisierungsadapter-Framework. Du kannst diesen Dienst in deiner App deklarieren, damit er im System identifiziert werden kann Manifest, indem Sie Folgendes hinzufügen: <service> -Elements als untergeordnetes Element von <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>

Die <intent-filter> wird ein Filter eingerichtet, der von der Intent-Aktion ausgelöst wird. android.accounts.AccountAuthenticator, die vom System zur Ausführung des Authenticator. Wenn der Filter ausgelöst wird, startet das System AuthenticatorService, Die gebundene Service, die Sie angegeben haben, um den Authenticator zu umschließen.

Die <meta-data> -Element deklariert die Metadaten für den Authenticator. Die android:name verknüpft die Metadaten mit dem Authentifizierungs-Framework. Die android:resource -Element gibt den Namen der Authenticator-Metadatendatei an, die Sie zuvor erstellt haben.

Für einen Synchronisierungsadapter ist neben einem Authenticator auch ein Contentanbieter erforderlich. Wenn Ihre App nicht Wenn Sie bereits einen Contentanbieter verwenden, fahren Sie mit der nächsten Lektion fort, um zu erfahren, wie Sie Stub-Inhalte erstellen. Anbieter; Fahren Sie andernfalls mit dem Abschnitt Synchronisierungsadapter erstellen fort.