Membuat authenticator stub

Framework adaptor sinkronisasi mengasumsikan bahwa adaptor sinkronisasi Anda mentransfer data antara penyimpanan perangkat yang terkait dengan akun dan penyimpanan server yang memerlukan akses login. Oleh karena itu, framework ini mengharapkan Anda untuk menyediakan komponen yang disebut pengautentikasi sebagai bagian dari adaptor sinkronisasi. Komponen ini dicolokkan ke akun Android dan framework autentikasi serta menyediakan antarmuka standar untuk menangani kredensial pengguna seperti informasi login.

Meskipun aplikasi Anda tidak menggunakan akun, komponen authenticator harus tetap Anda sediakan. Jika Anda tidak menggunakan login akun atau server, informasi yang ditangani oleh pengautentikasi akan diabaikan, sehingga Anda dapat menyediakan komponen pengautentikasi yang berisi penerapan metode stub. Anda juga harus menyediakan Service terikat yang memungkinkan framework adaptor sinkronisasi memanggil metode pengautentikasi.

Tutorial ini menunjukkan cara menentukan semua bagian dari pengautentikasi stub yang Anda perlukan untuk memenuhi persyaratan framework adaptor sinkronisasi. Jika Anda perlu menyediakan pengautentikasi sungguhan yang menangani akun pengguna, baca dokumentasi referensi untuk AbstractAccountAuthenticator.

Menambahkan komponen pengautentikasi stub

Untuk menambahkan komponen pengautentikasi stub ke aplikasi Anda, buat class yang memperluas AbstractAccountAuthenticator, lalu nonaktifkan metode yang diperlukan, baik dengan menampilkan null atau dengan menampilkan pengecualian.

Cuplikan berikut menunjukkan contoh class authenticator 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();
    }
}

Mengaitkan authenticator ke framework

Agar framework adaptor sinkronisasi dapat mengakses pengautentikasi, Anda harus membuat Layanan terikat untuk itu. Layanan ini menyediakan objek binder Android yang memungkinkan framework memanggil pengautentikasi Anda dan meneruskan data antara pengautentikasi dan framework.

Cuplikan berikut menunjukkan cara menentukan Service terikat:

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

Menambahkan file metadata authenticator

Untuk menghubungkan komponen pengautentikasi ke adaptor sinkronisasi dan framework akun, Anda harus menyediakan framework ini dengan metadata yang menjelaskan komponen tersebut. Metadata ini mendeklarasikan jenis akun yang telah Anda buat untuk adaptor sinkronisasi dan mendeklarasikan elemen antarmuka pengguna yang ditampilkan sistem jika Anda ingin membuat jenis akun Anda terlihat oleh pengguna. Deklarasikan metadata ini dalam file XML yang disimpan di direktori /res/xml/ dalam project aplikasi Anda. Anda dapat memberikan nama apa pun pada file tersebut, meskipun biasanya disebut authenticator.xml.

File XML ini berisi satu elemen <account-authenticator> yang memiliki atribut berikut:

android:accountType
Framework adaptor sinkronisasi mengharuskan setiap adaptor sinkronisasi memiliki jenis akun, dalam bentuk nama domain. Framework ini menggunakan jenis akun sebagai bagian dari identifikasi internal adaptor sinkronisasi. Untuk server yang memerlukan login, jenis akun beserta akun pengguna akan dikirim ke server sebagai bagian dari kredensial login.

Jika server tidak memerlukan login, Anda tetap harus menyediakan jenis akun. Untuk nilai, gunakan nama domain yang Anda kontrol. Meski framework menggunakannya untuk mengelola adaptor sinkronisasi, nilainya tidak akan dikirim ke server Anda.

android:icon
Pointer ke resource Drawable yang berisi ikon. Jika membuat adaptor sinkronisasi terlihat dengan menentukan atribut android:userVisible="true" pada res/xml/syncadapter.xml, Anda harus menyediakan resource ikon ini. Ikon ini muncul di bagian Akun pada aplikasi Setelan sistem.
android:smallIcon
Pointer ke resource Drawable yang berisi ikon dalam versi kecil. Resource ini dapat digunakan sebagai ganti android:icon di bagian Akun pada aplikasi Setelan sistem, bergantung pada ukuran layar.
android:label
String yang dapat dilokalkan yang mengidentifikasi jenis akun kepada pengguna. Jika Anda membuat adaptor sinkronisasi terlihat dengan menentukan atribut android:userVisible="true" pada res/xml/syncadapter.xml, Anda harus menyediakan string ini. Ikon ini muncul di bagian Akun pada aplikasi Setelan sistem, di samping ikon yang Anda tentukan untuk pengautentikasi.

Cuplikan berikut menunjukkan file XML untuk authenticator yang Anda buat sebelumnya:

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

Mendeklarasikan pengautentikasi dalam manifes

Pada langkah sebelumnya, Anda membuat Service terikat yang menautkan pengautentikasi ke framework adaptor sinkronisasi. Untuk mengidentifikasi layanan ini ke sistem, deklarasikan layanan dalam manifes aplikasi Anda dengan menambahkan elemen <service> berikut sebagai elemen turunan dari <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>

Elemen <intent-filter> menyiapkan filter yang dipicu oleh tindakan intent android.accounts.AccountAuthenticator, yang dikirim oleh sistem untuk menjalankan pengautentikasi. Saat filter dipicu, sistem akan memulai AuthenticatorService, Service terikat yang telah Anda berikan untuk menggabungkan pengautentikasi.

Elemen <meta-data> mendeklarasikan metadata untuk pengautentikasi. Atribut android:name menautkan meta-data ke framework autentikasi. Elemen android:resource menentukan nama file metadata pengautentikasi yang Anda buat sebelumnya.

Selain pengautentikasi, adaptor sinkronisasi juga memerlukan penyedia konten. Jika aplikasi Anda belum menggunakan penyedia konten, buka tutorial berikutnya untuk mempelajari cara membuat penyedia konten stub; atau, buka tutorial Membuat Adaptor Sinkronisasi.