Membuat authenticator stub

Framework adaptor sinkronisasi menganggap 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 penyediaan komponen yang disebut sebagai authenticator sebagai bagian dari adaptor sinkronisasi Anda. Komponen ini tersambung ke dalam akun Android dan framework autentikasi dan 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 perlu menyediakan Service terikat yang mengizinkan framework adaptor sinkronisasi untuk memanggil metode pengautentikasi.

Tutorial ini menunjukkan cara menentukan semua bagian dari pengautentikasi stub yang Anda butuhkan untuk memenuhi persyaratan framework adaptor sinkronisasi. Jika Anda perlu menyediakan pengautentikasi asli 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 pisahkan metode yang diperlukan, dengan mengembalikan null atau dengan memunculkan pengecualian.

Cuplikan berikut menunjukkan contoh class pengautentikasi 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 authenticator, Anda harus membuat Layanan terikat untuk mengaksesnya. Layanan ini menyediakan objek binder Android yang memungkinkan framework untuk memanggil pengautentikasi Anda dan meneruskan data antara pengautentikasi dan framework.

Karena framework memulai Service ini saat pertama kali perlu mengakses pengautentikasi, Anda juga dapat menggunakan layanan tersebut untuk membuat instance pengautentikasi, dengan memanggil konstruktor pengautentikasi dalam metode Service.onCreate() dari layanan tersebut.

Cuplikan berikut menunjukkan cara menetapkan 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(this)
        }

        /*
         * 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(this);
        }
        /*
         * 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 menyambungkan komponen authenticator ke dalam adaptor sinkronisasi dan framework akun, Anda harus menyediakan framework tersebut 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 oleh sistem jika Anda ingin membuat jenis akun 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 menggunakan jenis akun sebagai bagian dari identifikasi internal adaptor sinkronisasi. Untuk server yang memerlukan login, jenis akun bersama dengan 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. Framework menggunakannya untuk mengelola adaptor sinkronisasi, sementara nilai tidak akan dikirim ke server Anda.

android:icon
Pointer ke resource Drawabel yang berisi ikon. Jika Anda membuat adaptor sinkronisasi terlihat dengan menentukan atribut android:userVisible="true" pada res/xml/syncadapter.xml, Anda harus menyediakan resource ikon ini. Resource ini muncul di bagian Akun di 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 di aplikasi Setelan sistem, tergantung 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. String ini akan muncul di bagian Akun di 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 mengidentifikasikan layanan ini ke sistem, deklarasikan di manifes aplikasi Anda dengan menambahkan elemen <service> berikut sebagai elemen turunan <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 sediakan untuk menggabungkan pengautentikasi.

Elemen <meta-data> akan 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 pelajaran selanjutnya untuk mempelajari cara membuat penyedia konten stub; atau, buka pelajaran Membuat Adaptor Sinkronisasi.