สร้างอะแดปเตอร์การซิงค์

หมายเหตุ: เราขอแนะนำให้ใช้ WorkManager เป็นโซลูชันที่แนะนำสำหรับกรณีการใช้งานการประมวลผลเบื้องหลังส่วนใหญ่ โปรดอ้างอิง คำแนะนำเกี่ยวกับการประมวลผลในเบื้องหลังเพื่อดูว่าโซลูชันใดเหมาะกับคุณมากที่สุด

คอมโพเนนต์อะแดปเตอร์การซิงค์ในแอปสรุปโค้ดสำหรับงานที่โอน ข้อมูลระหว่างอุปกรณ์และเซิร์ฟเวอร์ อิงตามการตั้งเวลาและทริกเกอร์ที่คุณระบุ แอปของคุณ เฟรมเวิร์กอะแดปเตอร์การซิงค์จะเรียกใช้โค้ดในคอมโพเนนต์อะแดปเตอร์การซิงค์ หากต้องการเพิ่ม คอมโพเนนต์อะแดปเตอร์การซิงค์ไปยังแอปของคุณ คุณต้องเพิ่มชิ้นส่วนต่อไปนี้

คลาสอะแดปเตอร์ซิงค์

คลาสที่รวมโค้ดการโอนข้อมูลไว้ในอินเทอร์เฟซที่เข้ากันได้กับอะแดปเตอร์การซิงค์

ผูกพัน Service

คอมโพเนนต์ที่อนุญาตให้เฟรมเวิร์กอะแดปเตอร์การซิงค์เรียกใช้โค้ดในอะแดปเตอร์การซิงค์

ซิงค์ไฟล์ข้อมูลเมตา XML ของอะแดปเตอร์

ไฟล์ที่มีข้อมูลเกี่ยวกับอะแดปเตอร์การซิงค์ของคุณ เฟรมเวิร์กจะอ่านไฟล์นี้เพื่อ ดูวิธีโหลดและกำหนดเวลาการโอนข้อมูล

การประกาศในไฟล์ Manifest ของแอป

XML ที่ประกาศบริการที่เชื่อมโยงไว้และชี้ไปซิงค์ข้อมูลเมตาเฉพาะอะแดปเตอร์

บทเรียนนี้แสดงวิธีกำหนดองค์ประกอบเหล่านี้

สร้างคลาสอะแดปเตอร์การซิงค์

ในส่วนนี้ คุณจะได้เรียนรู้วิธีสร้างคลาสอะแดปเตอร์การซิงค์ที่ครอบคลุม รหัสการโอนข้อมูล การสร้างคลาสรวมถึงการขยายคลาสฐานของอะแดปเตอร์การซิงค์ การกำหนด สำหรับชั้นเรียน และนำวิธีการที่คุณกำหนดการโอนข้อมูลไปใช้ งาน

ขยายคลาสอะแดปเตอร์การซิงค์พื้นฐาน

หากต้องการสร้างคอมโพเนนต์อะแดปเตอร์การซิงค์ ให้เริ่มด้วยการขยาย AbstractThreadedSyncAdapter และเขียนเครื่องมือสร้าง ใช้เมนู เครื่องมือสร้างให้เรียกใช้งานการตั้งค่าทุกครั้งที่มีการสร้างคอมโพเนนต์อะแดปเตอร์การซิงค์ เช่นเดียวกับที่คุณใช้ Activity.onCreate() เพื่อสร้าง กิจกรรม ตัวอย่างเช่น ถ้าแอปของคุณใช้ผู้ให้บริการเนื้อหาในการจัดเก็บข้อมูล ให้ใช้เครื่องมือสร้าง เพื่อรับอินสแตนซ์ ContentResolver ตั้งแต่รูปแบบที่ 2 ของ มีการเพิ่มเครื่องมือสร้างในแพลตฟอร์ม Android เวอร์ชัน 3.0 เพื่อรองรับparallelSyncs คุณต้องสร้างรูปแบบตัวสร้าง 2 รูปแบบเพื่อรักษาความเข้ากันได้

หมายเหตุ: เฟรมเวิร์กอะแดปเตอร์การซิงค์ออกแบบมาให้ทำงานร่วมกับอะแดปเตอร์การซิงค์ คอมโพเนนต์ที่เป็นอินสแตนซ์เดี่ยว การสร้างอินสแตนซ์ของคอมโพเนนต์อะแดปเตอร์การซิงค์ปิดอยู่ รายละเอียดเพิ่มเติมในส่วน เชื่อมโยงอะแดปเตอร์การซิงค์กับเฟรมเวิร์ก

ตัวอย่างต่อไปนี้แสดงวิธีใช้งาน AbstractThreadedSyncAdapterและผู้สร้าง:

/**
 * Handle the transfer of data between a server and an
 * app, using the Android sync adapter framework.
 */
class SyncAdapter @JvmOverloads constructor(
        context: Context,
        autoInitialize: Boolean,
        /**
         * Using a default argument along with @JvmOverloads
         * generates constructor for both method signatures to maintain compatibility
         * with Android 3.0 and later platform versions
         */
        allowParallelSyncs: Boolean = false,
        /*
         * If your app uses a content resolver, get an instance of it
         * from the incoming Context
         */
        val mContentResolver: ContentResolver = context.contentResolver
) : AbstractThreadedSyncAdapter(context, autoInitialize, allowParallelSyncs) {
    ...
}

/**
 * Handle the transfer of data between a server and an
 * app, using the Android sync adapter framework.
 */
public class SyncAdapter extends AbstractThreadedSyncAdapter {
    ...
    // Global variables
    // Define a variable to contain a content resolver instance
    ContentResolver contentResolver;
    /**
     * Set up the sync adapter
     */
    public SyncAdapter(Context context, boolean autoInitialize) {
        super(context, autoInitialize);
        /*
         * If your app uses a content resolver, get an instance of it
         * from the incoming Context
         */
        contentResolver = context.getContentResolver();
    }
    ...
    /**
     * Set up the sync adapter. This form of the
     * constructor maintains compatibility with Android 3.0
     * and later platform versions
     */
    public SyncAdapter(
            Context context,
            boolean autoInitialize,
            boolean allowParallelSyncs) {
        super(context, autoInitialize, allowParallelSyncs);
        /*
         * If your app uses a content resolver, get an instance of it
         * from the incoming Context
         */
        contentResolver = context.getContentResolver();
        ...
    }

เพิ่มโค้ดการโอนข้อมูล

คอมโพเนนต์อะแดปเตอร์การซิงค์ไม่โอนข้อมูลโดยอัตโนมัติ ผลลัพธ์ ห่อหุ้มโค้ดการโอนข้อมูลเพื่อให้เฟรมเวิร์กอะแดปเตอร์การซิงค์สามารถเรียกใช้ การโอนข้อมูลในเบื้องหลังโดยไม่มีส่วนเกี่ยวข้องจากแอป เมื่อเฟรมเวิร์กพร้อมแล้ว เพื่อซิงค์ข้อมูลแอปพลิเคชันของคุณ แอปพลิเคชันจะเรียกใช้วิธีการ onPerformSync()

เพื่ออำนวยความสะดวกในการโอนข้อมูลจากโค้ดของแอปหลักไปยังคอมโพเนนต์อะแดปเตอร์การซิงค์ การเรียกใช้เฟรมเวิร์กอะแดปเตอร์การซิงค์ onPerformSync() ที่มี อาร์กิวเมนต์ต่อไปนี้

บัญชี

ออบเจ็กต์ Account ที่เชื่อมโยงกับเหตุการณ์ที่ทริกเกอร์ อะแดปเตอร์การซิงค์ หากเซิร์ฟเวอร์ของคุณไม่ได้ใช้บัญชี คุณไม่จำเป็นต้องใช้ ในออบเจ็กต์นี้

เพิ่มเติม

Bundle ที่มีแฟล็กซึ่งส่งจากเหตุการณ์ที่ทำให้เกิดการซิงค์ อะแดปเตอร์

ความน่าเชื่อถือ

อำนาจของผู้ให้บริการเนื้อหาในระบบ แอปของคุณต้องมีสิทธิ์เข้าถึง ผู้ให้บริการรายนี้ โดยปกติแล้ว หน่วยงานนี้จะเกี่ยวข้องกับผู้ให้บริการเนื้อหาในแอปของคุณ

ไคลเอ็นต์ผู้ให้บริการเนื้อหา

ContentProviderClient สำหรับผู้ให้บริการเนื้อหาที่ชี้โดย อาร์กิวเมนต์ ContentProviderClient เป็นพื้นที่สาธารณะขนาดเล็ก กับผู้ให้เนื้อหา โดยมีฟังก์ชันพื้นฐานเหมือนกับ ContentResolver หากคุณใช้ผู้ให้บริการเนื้อหาในการจัดเก็บข้อมูล สำหรับแอปของคุณ คุณสามารถเชื่อมต่อกับผู้ให้บริการด้วยออบเจ็กต์นี้ได้ ไม่เช่นนั้น ก็ไม่ต้องสนใจ ได้

ผลการซิงค์

ออบเจ็กต์ SyncResult ที่คุณใช้ส่งข้อมูลไปยังการซิงค์ ของ Ad Exchange

ข้อมูลโค้ดต่อไปนี้แสดงโครงสร้างโดยรวมของ onPerformSync():

/*
 * Specify the code you want to run in the sync adapter. The entire
 * sync adapter runs in a background thread, so you don't have to set
 * up your own background processing.
 */
override fun onPerformSync(
        account: Account,
        extras: Bundle,
        authority: String,
        provider: ContentProviderClient,
        syncResult: SyncResult
) {
    /*
     * Put the data transfer code here.
     */
}

/*
 * Specify the code you want to run in the sync adapter. The entire
 * sync adapter runs in a background thread, so you don't have to set
 * up your own background processing.
 */
@Override
public void onPerformSync(
        Account account,
        Bundle extras,
        String authority,
        ContentProviderClient provider,
        SyncResult syncResult) {
    /*
     * Put the data transfer code here.
     */
}

ขณะที่การนำไปใช้งานจริง onPerformSync() มีไว้สำหรับ ความต้องการในการซิงค์ข้อมูลและโปรโตคอลการเชื่อมต่อเซิร์ฟเวอร์ของแอป งานทั่วไปที่การติดตั้งใช้งานของคุณควรทำ

การเชื่อมต่อกับเซิร์ฟเวอร์

แม้ว่าคุณสามารถสรุปได้ว่าเครือข่ายใช้งานได้เมื่อเริ่มการโอนข้อมูล เฟรมเวิร์กอะแดปเตอร์การซิงค์ไม่เชื่อมต่อกับเซิร์ฟเวอร์โดยอัตโนมัติ

การดาวน์โหลดและอัปโหลดข้อมูล

อะแดปเตอร์การซิงค์จะไม่ทำให้งานโอนข้อมูลเป็นไปโดยอัตโนมัติ ถ้าอยากดาวน์โหลด ข้อมูลจากเซิร์ฟเวอร์และจัดเก็บไว้ในผู้ให้บริการเนื้อหา คุณต้องระบุรหัสที่ จะขอข้อมูล ดาวน์โหลด แล้วแทรกไว้ในผู้ให้บริการ ในทำนองเดียวกัน หากคุณต้องการ ส่งข้อมูลไปยังเซิร์ฟเวอร์ คุณต้องอ่านไฟล์ ฐานข้อมูล หรือผู้ให้บริการ แล้วส่ง คำขออัปโหลดที่จำเป็น นอกจากนี้ คุณยังต้องจัดการกับข้อผิดพลาดเกี่ยวกับเครือข่ายที่เกิดขึ้นในขณะที่ กำลังโอนข้อมูล

การจัดการความขัดแย้งของข้อมูลหรือการกำหนดระดับความเป็นปัจจุบันของข้อมูล

อะแดปเตอร์การซิงค์จะไม่จัดการความขัดแย้งระหว่างข้อมูลในเซิร์ฟเวอร์และข้อมูลโดยอัตโนมัติ ในอุปกรณ์ นอกจากนี้ ระบบจะไม่ตรวจจับโดยอัตโนมัติว่าข้อมูลบนเซิร์ฟเวอร์ใหม่กว่า ข้อมูลบนอุปกรณ์ หรือในทางกลับกัน แต่คุณต้องจัดเตรียมอัลกอริทึมของคุณเองสําหรับ เมื่อต้องจัดการกับสถานการณ์นี้

ล้างข้อมูล

ปิดการเชื่อมต่อกับเซิร์ฟเวอร์เสมอ และล้างไฟล์ชั่วคราวและแคชในตอนท้าย การโอนข้อมูล

หมายเหตุ: เฟรมเวิร์กอะแดปเตอร์การซิงค์จะทำงาน onPerformSync() บน เทรดในเบื้องหลัง คุณจึงไม่ต้องตั้งค่าการประมวลผลในเบื้องหลังของคุณเอง

นอกจากงานเกี่ยวกับการซิงค์แล้ว คุณควรลองรวม เกี่ยวกับเครือข่ายและเพิ่มลงใน onPerformSync() การให้ความสำคัญกับงานด้านเครือข่ายทั้งหมดด้วยวิธีนี้ จะช่วยประหยัดพลังงานแบตเตอรี่ ที่จำเป็นต่อการเริ่มและหยุดอินเทอร์เฟซเครือข่าย หากต้องการดูข้อมูลเพิ่มเติมเกี่ยวกับการเพิ่มการเข้าถึงเครือข่าย โปรดดูคลาสการฝึกการโอนข้อมูลโดยไม่ต้องสิ้นเปลืองแบตเตอรี่ ซึ่งจะอธิบายถึงการเข้าถึงเครือข่ายหลายรูปแบบ ที่คุณสามารถรวมไว้ในโค้ดการโอนข้อมูล

เชื่อมโยงอะแดปเตอร์การซิงค์กับเฟรมเวิร์ก

ตอนนี้คุณมีโค้ดการโอนข้อมูลอยู่ในคอมโพเนนต์อะแดปเตอร์การซิงค์แล้ว แต่กลับมี เพื่อให้เฟรมเวิร์กเข้าถึงโค้ดของคุณได้ โดยคุณต้องสร้างขอบเขต Service ที่ส่งออบเจ็กต์ Android Binder พิเศษจากอะแดปเตอร์การซิงค์ ลงในเฟรมเวิร์ก ด้วยออบเจ็กต์ Binder นี้ เฟรมเวิร์กสามารถเรียกใช้ onPerformSync() วิธีและ ส่งข้อมูลไปให้

สร้างอินสแตนซ์คอมโพเนนต์อะแดปเตอร์การซิงค์เป็นหน่วยเดี่ยวใน onCreate() วิธีของบริการ ด้วยการสร้างอินสแตนซ์ คอมโพเนนต์ใน onCreate() คุณจะเลื่อน จนกว่าบริการจะเริ่มต้น ซึ่งจะเกิดขึ้นเมื่อเฟรมเวิร์กจะพยายามเรียกใช้ การโอนข้อมูล คุณต้องสร้างอินสแตนซ์คอมโพเนนต์ในลักษณะที่ปลอดภัยของชุดข้อความในกรณีที่มีการซิงค์ เฟรมเวิร์กอะแดปเตอร์จัดคิวการดำเนินการหลายรายการของอะแดปเตอร์การซิงค์เพื่อตอบสนองต่อทริกเกอร์หรือ การกำหนดเวลา

ตัวอย่างเช่น ข้อมูลโค้ดต่อไปนี้แสดงวิธีสร้างคลาสที่ใช้โอเปอเรเตอร์ bound Service สร้างอินสแตนซ์คอมโพเนนต์อะแดปเตอร์การซิงค์และรับ ออบเจ็กต์ของ Android Binder:

package com.example.android.syncadapter
/**
 * Define a Service that returns an [android.os.IBinder] for the
 * sync adapter class, allowing the sync adapter framework to call
 * onPerformSync().
 */
class SyncService : Service() {
    /*
     * Instantiate the sync adapter object.
     */
    override fun onCreate() {
        /*
         * Create the sync adapter as a singleton.
         * Set the sync adapter as syncable
         * Disallow parallel syncs
         */
        synchronized(sSyncAdapterLock) {
            sSyncAdapter = sSyncAdapter ?: SyncAdapter(applicationContext, true)
        }
    }

    /**
     * Return an object that allows the system to invoke
     * the sync adapter.
     *
     */
    override fun onBind(intent: Intent): IBinder {
        /*
         * Get the object that allows external processes
         * to call onPerformSync(). The object is created
         * in the base class code when the SyncAdapter
         * constructors call super()
         *
         * We should never be in a position where this is called before
         * onCreate() so the exception should never be thrown
         */
        return sSyncAdapter?.syncAdapterBinder ?: throw IllegalStateException()
    }

    companion object {
        // Storage for an instance of the sync adapter
        private var sSyncAdapter: SyncAdapter? = null
        // Object to use as a thread-safe lock
        private val sSyncAdapterLock = Any()
    }
}

package com.example.android.syncadapter;
/**
 * Define a Service that returns an <code><a href="/reference/android/os/IBinder.html">IBinder</a></code> for the
 * sync adapter class, allowing the sync adapter framework to call
 * onPerformSync().
 */
public class SyncService extends Service {
    // Storage for an instance of the sync adapter
    private static SyncAdapter sSyncAdapter = null;
    // Object to use as a thread-safe lock
    private static final Object sSyncAdapterLock = new Object();
    /*
     * Instantiate the sync adapter object.
     */
    @Override
    public void onCreate() {
        /*
         * Create the sync adapter as a singleton.
         * Set the sync adapter as syncable
         * Disallow parallel syncs
         */
        synchronized (sSyncAdapterLock) {
            if (sSyncAdapter == null) {
                sSyncAdapter = new SyncAdapter(getApplicationContext(), true);
            }
        }
    }
    /**
     * Return an object that allows the system to invoke
     * the sync adapter.
     *
     */
    @Override
    public IBinder onBind(Intent intent) {
        /*
         * Get the object that allows external processes
         * to call onPerformSync(). The object is created
         * in the base class code when the SyncAdapter
         * constructors call super()
         */
        return sSyncAdapter.getSyncAdapterBinder();
    }
}

หมายเหตุ: หากต้องการดูตัวอย่างโดยละเอียดของบริการที่เชื่อมโยงกับอะแดปเตอร์การซิงค์ ดูตัวอย่างแอป

เพิ่มบัญชีที่กำหนดตามเฟรมเวิร์ก

เฟรมเวิร์กอะแดปเตอร์การซิงค์กำหนดให้อะแดปเตอร์การซิงค์แต่ละรายการต้องมีประเภทบัญชี คุณประกาศ ค่าประเภทบัญชีในส่วน เพิ่มไฟล์ข้อมูลเมตาของ Authenticator คราวนี้คุณจะต้องตั้งค่าประเภทบัญชีนี้ใน ระบบ Android หากต้องการตั้งค่าประเภทบัญชี ให้เพิ่มบัญชีตัวยึดตำแหน่งที่ใช้ประเภทบัญชี โดยโทรไปที่ addAccountExplicitly()

ตำแหน่งที่ดีที่สุดในการเรียกเมธอดคือใน onCreate() วิธีการสำหรับแอปของคุณ กิจกรรมการเปิด ข้อมูลโค้ดต่อไปนี้จะแสดงวิธีดำเนินการ

...
// Constants
// The authority for the sync adapter's content provider
const val AUTHORITY = "com.example.android.datasync.provider"
// An account type, in the form of a domain name
const val ACCOUNT_TYPE = "example.com"
// The account name
const val ACCOUNT = "placeholderaccount"
...
class MainActivity : FragmentActivity() {

    // Instance fields
    private lateinit var mAccount: Account
    ...
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
       ...
        // Create the placeholder account
        mAccount = createSyncAccount()
       ...
    }
    ...
    /**
     * Create a new placeholder account for the sync adapter
     */
    private fun createSyncAccount(): Account {
        val accountManager = getSystemService(Context.ACCOUNT_SERVICE) as AccountManager
        return Account(ACCOUNT, ACCOUNT_TYPE).also { newAccount ->
            /*
             * Add the account and account type, no password or user data
             * If successful, return the Account object, otherwise report an error.
             */
            if (accountManager.addAccountExplicitly(newAccount, null, null)) {
                /*
                 * If you don't set android:syncable="true" in
                 * in your <provider> element in the manifest,
                 * then call context.setIsSyncable(account, AUTHORITY, 1)
                 * here.
                 */
            } else {
                /*
                 * The account exists or some other error occurred. Log this, report it,
                 * or handle it internally.
                 */
            }
        }
    }
    ...
}

public class MainActivity extends FragmentActivity {
    ...
    ...
    // Constants
    // The authority for the sync adapter's content provider
    public static final String AUTHORITY = "com.example.android.datasync.provider";
    // An account type, in the form of a domain name
    public static final String ACCOUNT_TYPE = "example.com";
    // The account name
    public static final String ACCOUNT = "placeholderaccount";
    // Instance fields
    Account mAccount;
    ...
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ...
        // Create the placeholder account
        mAccount = CreateSyncAccount(this);
        ...
    }
    ...
    /**
     * Create a new placeholder account for the sync adapter
     *
     * @param context The application context
     */
    public static Account CreateSyncAccount(Context context) {
        // Create the account type and default account
        Account newAccount = new Account(
                ACCOUNT, ACCOUNT_TYPE);
        // Get an instance of the Android account manager
        AccountManager accountManager =
                (AccountManager) context.getSystemService(
                        ACCOUNT_SERVICE);
        /*
         * Add the account and account type, no password or user data
         * If successful, return the Account object, otherwise report an error.
         */
        if (accountManager.addAccountExplicitly(newAccount, null, null)) {
            /*
             * If you don't set android:syncable="true" in
             * in your <provider> element in the manifest,
             * then call context.setIsSyncable(account, AUTHORITY, 1)
             * here.
             */
        } else {
            /*
             * The account exists or some other error occurred. Log this, report it,
             * or handle it internally.
             */
        }
    }
    ...
}

เพิ่มไฟล์ข้อมูลเมตาของอะแดปเตอร์การซิงค์

หากต้องการเสียบคอมโพเนนต์อะแดปเตอร์การซิงค์เข้ากับเฟรมเวิร์ก คุณจะต้องระบุเฟรมเวิร์ก พร้อมข้อมูลเมตาที่อธิบายคอมโพเนนต์และแจ้ง Flag เพิ่มเติม ข้อมูลเมตาจะระบุ ประเภทบัญชีที่คุณสร้างขึ้นสำหรับอะแดปเตอร์การซิงค์ แสดงความน่าเชื่อถือของผู้ให้บริการเนื้อหา ที่เชื่อมโยงกับแอปของคุณ ควบคุมส่วนของอินเทอร์เฟซผู้ใช้ของระบบที่เกี่ยวข้องกับอะแดปเตอร์การซิงค์ และประกาศ Flag อื่นๆ ที่เกี่ยวข้องกับการซิงค์ ประกาศข้อมูลเมตานี้ในไฟล์ XML พิเศษที่จัดเก็บไว้ใน ไดเรกทอรี /res/xml/ ในโปรเจ็กต์แอปของคุณ คุณจะตั้งชื่อไฟล์อย่างไรก็ได้ แต่โดยทั่วไปจะเรียกว่า syncadapter.xml

ไฟล์ XML นี้มีองค์ประกอบ XML เดียว <sync-adapter> ที่มีส่วน แอตทริบิวต์ต่อไปนี้

android:contentAuthority

สิทธิ์ URI สำหรับผู้ให้บริการเนื้อหาของคุณ หากคุณสร้างผู้ให้บริการเนื้อหา Stub สำหรับ แอปของคุณในบทเรียนก่อนหน้านี้เรื่องการสร้างผู้ให้บริการเนื้อหา Stub ให้ใช้ค่าที่คุณระบุสำหรับ แอตทริบิวต์ android:authorities ในองค์ประกอบ <provider> ที่คุณเพิ่มลงในไฟล์ Manifest ของแอป แอตทริบิวต์นี้คือ ซึ่งอธิบายโดยละเอียดยิ่งขึ้นในส่วน ประกาศผู้ให้บริการในไฟล์ Manifest
หากคุณโอนข้อมูลจากผู้ให้บริการเนื้อหาไปยังเซิร์ฟเวอร์โดยใช้อะแดปเตอร์การซิงค์ ควรเป็นค่าเดียวกับผู้ออกใบรับรอง URI เนื้อหาที่คุณใช้สำหรับข้อมูลนั้น ค่านี้ ยังเป็นหนึ่งในหน่วยงานที่คุณระบุไว้ใน android:authorities ขององค์ประกอบ <provider> ที่ประกาศผู้ให้บริการในไฟล์ Manifest ของแอป

android:accountType

ประเภทบัญชีที่จำเป็นสำหรับเฟรมเวิร์กอะแดปเตอร์การซิงค์ ค่าต้องเหมือนกัน เป็นค่าประเภทบัญชีที่คุณระบุเมื่อสร้างไฟล์ข้อมูลเมตาของ Authenticator เช่น ตามที่อธิบายไว้ในส่วนเพิ่มไฟล์ข้อมูลเมตาของ Authenticator ค่านี้ยังเป็นค่าที่คุณระบุสำหรับ ค่าคงที่ ACCOUNT_TYPE ในข้อมูลโค้ดในส่วน เพิ่มบัญชีที่เฟรมเวิร์กกำหนดไว้

แอตทริบิวต์การตั้งค่า

android:userVisible

ตั้งค่าการเปิดเผยประเภทบัญชีของอะแดปเตอร์การซิงค์ โดยค่าเริ่มต้น แอตทริบิวต์ ไอคอนและป้ายกำกับบัญชีที่เชื่อมโยงกับประเภทบัญชีจะปรากฏใน ส่วนบัญชีของแอปการตั้งค่าของระบบ ดังนั้นคุณควรทำการซิงค์ ไม่แสดงอะแดปเตอร์ เว้นแต่คุณจะมีประเภทบัญชีหรือโดเมนที่เชื่อมโยงได้ง่าย กับแอปของคุณ หากกําหนดให้ไม่แสดงประเภทบัญชี คุณก็ยังอนุญาตให้ผู้ใช้ ควบคุมอะแดปเตอร์การซิงค์ด้วยอินเทอร์เฟซผู้ใช้ในกิจกรรมของแอป

android:supportsUploading

ให้คุณอัปโหลดข้อมูลไปยังระบบคลาวด์ ตั้งค่าเป็น false หากแอปของคุณเท่านั้น ข้อมูลการดาวน์โหลด

android:allowParallelSyncs

อนุญาตให้คอมโพเนนต์อะแดปเตอร์การซิงค์หลายอินสแตนซ์ทำงานพร้อมกัน ใช้ตัวเลือกนี้หากแอปของคุณรองรับบัญชีผู้ใช้หลายบัญชี และคุณต้องการอนุญาตบัญชีหลายรายการ ผู้ใช้เพื่อโอนข้อมูลพร้อมกัน แฟล็กนี้จะไม่มีผลหากคุณไม่เคยเรียกใช้ การโอนข้อมูลหลายครั้ง

android:isAlwaysSyncable

ระบุให้กับเฟรมเวิร์กอะแดปเตอร์การซิงค์ที่การเรียกใช้อะแดปเตอร์การซิงค์ทุกเมื่อ เวลาที่คุณระบุ หากต้องการควบคุมเวลาที่ซิงค์แบบเป็นโปรแกรม อะแดปเตอร์สามารถทำงานได้ ตั้งค่าแฟล็กนี้เป็น false แล้วเรียกใช้ requestSync() เพื่อเรียกใช้ อะแดปเตอร์การซิงค์ หากต้องการดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้งานอะแดปเตอร์การซิงค์ โปรดดูบทเรียน การเรียกใช้อะแดปเตอร์การซิงค์

ตัวอย่างต่อไปนี้แสดง XML สำหรับอะแดปเตอร์การซิงค์ที่ใช้บัญชีตัวยึดตำแหน่งเดียว และ จะดำเนินการดาวน์โหลดเท่านั้น

<?xml version="1.0" encoding="utf-8"?>
<sync-adapter
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:contentAuthority="com.example.android.datasync.provider"
        android:accountType="com.android.example.datasync"
        android:userVisible="false"
        android:supportsUploading="false"
        android:allowParallelSyncs="false"
        android:isAlwaysSyncable="true"/>

ประกาศอะแดปเตอร์การซิงค์ในไฟล์ Manifest

เมื่อเพิ่มคอมโพเนนต์อะแดปเตอร์การซิงค์ลงในแอปแล้ว คุณต้องขอสิทธิ์ ที่เกี่ยวข้องกับการใช้คอมโพเนนต์ และคุณต้องประกาศการเชื่อมโยง Service ที่คุณได้เพิ่มไว้

เนื่องจากคอมโพเนนต์อะแดปเตอร์การซิงค์จะเรียกใช้โค้ดที่โอนข้อมูลระหว่างเครือข่ายและ คุณต้องขอสิทธิ์ในการเข้าถึงอินเทอร์เน็ต นอกจากนี้ แอปของคุณต้องมี เพื่อขอสิทธิ์ในการอ่านและเขียนการตั้งค่าอะแดปเตอร์การซิงค์ เพื่อให้คุณสามารถควบคุมการซิงค์ อะแดปเตอร์จากคอมโพเนนต์อื่นๆ ในแอปโดยอัตโนมัติ นอกจากนี้คุณต้องส่งคำขอ สิทธิ์พิเศษที่อนุญาตให้แอปของคุณใช้คอมโพเนนต์ Authenticator ที่คุณสร้างขึ้น ในบทเรียนการสร้าง Stub Authenticator

ในการขอสิทธิ์เหล่านี้ ให้เพิ่มค่าต่อไปนี้ลงในไฟล์ Manifest ของแอปเป็นองค์ประกอบย่อยของ <manifest>:

android.permission.INTERNET

อนุญาตให้โค้ดอะแดปเตอร์ซิงค์เข้าถึงอินเทอร์เน็ตเพื่อดาวน์โหลดหรืออัปโหลดข้อมูลได้ จากอุปกรณ์ไปยังเซิร์ฟเวอร์ คุณไม่จำเป็นต้องเพิ่มสิทธิ์นี้อีกครั้งหากคุณ ก่อนหน้านี้

android.permission.READ_SYNC_SETTINGS

อนุญาตให้แอปอ่านการตั้งค่าอะแดปเตอร์การซิงค์ปัจจุบัน ตัวอย่างเช่น คุณต้องใช้พารามิเตอร์นี้ สิทธิ์ในการเรียก getIsSyncable()

android.permission.WRITE_SYNC_SETTINGS

อนุญาตให้แอปควบคุมการตั้งค่าอะแดปเตอร์การซิงค์ คุณต้องมีสิทธิ์นี้เพื่อ ตั้งค่าอะแดปเตอร์การซิงค์ตามกำหนดเวลาโดยใช้ addPeriodicSync() ไม่ต้องใช้สิทธิ์นี้เพื่อเรียกใช้ requestSync() หากต้องการทราบข้อมูลเพิ่มเติมเกี่ยวกับ การเรียกใช้อะแดปเตอร์การซิงค์ โปรดดูที่การเรียกใช้อะแดปเตอร์การซิงค์

ข้อมูลโค้ดต่อไปนี้แสดงวิธีเพิ่มสิทธิ์

<manifest>
...
    <uses-permission
            android:name="android.permission.INTERNET"/>
    <uses-permission
            android:name="android.permission.READ_SYNC_SETTINGS"/>
    <uses-permission
            android:name="android.permission.WRITE_SYNC_SETTINGS"/>
    <uses-permission
            android:name="android.permission.AUTHENTICATE_ACCOUNTS"/>
...
</manifest>

สุดท้าย เพื่อประกาศขอบเขต Service ที่เฟรมเวิร์กใช้เพื่อ โต้ตอบกับอะแดปเตอร์การซิงค์ เพิ่ม XML ต่อไปนี้ลงในไฟล์ Manifest ของแอปเป็นองค์ประกอบย่อย จาก <application>:

        <service
                android:name="com.example.android.datasync.SyncService"
                android:exported="false"
                android:process=":sync">
            <intent-filter>
                <action android:name="android.content.SyncAdapter"/>
            </intent-filter>
            <meta-data android:name="android.content.SyncAdapter"
                    android:resource="@xml/syncadapter" />
        </service>

<intent-filter> องค์ประกอบจะตั้งค่าตัวกรองที่ทริกเกอร์โดยการดำเนินการผ่าน Intent android.content.SyncAdapter ส่งโดยระบบเพื่อเรียกใช้อะแดปเตอร์การซิงค์ กรณีที่ตัวกรอง จะถูกเรียกใช้ ระบบจะเริ่มบริการที่มีผลผูกพันที่คุณสร้างขึ้น ซึ่งในตัวอย่างนี้ SyncService แอตทริบิวต์ android:exported="false" อนุญาตเฉพาะแอปและระบบเท่านั้นที่จะเข้าถึง Service แอตทริบิวต์ android:process=":sync" บอกระบบให้เรียกใช้ Service ในกระบวนการที่ใช้ร่วมกันทั่วโลกที่ชื่อว่า sync หากคุณมีอะแดปเตอร์ซิงค์หลายรายการในแอป อะแดปเตอร์เหล่านั้นก็แชร์กระบวนการนี้ได้ ซึ่งช่วยลดค่าใช้จ่ายลง

<meta-data> ให้ชื่อของไฟล์ XML ข้อมูลเมตาของอะแดปเตอร์การซิงค์ที่คุณสร้างขึ้นก่อนหน้านี้ android:name ระบุว่าข้อมูลเมตานี้มีไว้สำหรับเฟรมเวิร์กอะแดปเตอร์การซิงค์ android:resource ระบุชื่อของไฟล์ข้อมูลเมตา

ตอนนี้คุณมีคอมโพเนนต์ทั้งหมดสำหรับอะแดปเตอร์การซิงค์แล้ว บทเรียนถัดไปจะแสดงวิธีการ แจ้งให้เฟรมเวิร์กอะแดปเตอร์การซิงค์เรียกใช้อะแดปเตอร์การซิงค์ทั้งเพื่อตอบสนองต่อเหตุการณ์หรือใน ตามกำหนดการอย่างสม่ำเสมอ