กำหนดคำขอสำหรับงาน

คู่มือเริ่มต้นใช้งานได้อธิบายวิธีสร้าง WorkRequest และจัดคิวไว้แล้ว

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

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

ภาพรวม

งานจะกำหนดไว้ใน WorkManager โดยใช้ WorkRequest หากต้องการกำหนดเวลางานด้วย WorkManager คุณต้องสร้างออบเจ็กต์ WorkRequest ก่อน แล้วจึงจัดคิว

Kotlin

val myWorkRequest = ...
WorkManager.getInstance(myContext).enqueue(myWorkRequest)

Java

WorkRequest myWorkRequest = ...
WorkManager.getInstance(myContext).enqueue(myWorkRequest);

ออบเจ็กต์ WorkRequest มีข้อมูลทั้งหมดที่ WorkManager ต้องใช้ในการกำหนดเวลาและเรียกใช้งาน ซึ่งรวมถึงข้อจำกัดที่ต้องปฏิบัติตามเพื่อให้งานทำงาน ข้อมูลการกำหนดเวลา เช่น ความล่าช้าหรือช่วงเวลาที่เกิดซ้ำ การกำหนดค่าการลองใหม่ และอาจรวมถึงข้อมูลอินพุตหากงานของคุณอาศัยข้อมูลดังกล่าว

WorkRequest เป็นคลาสพื้นฐานแบบนามธรรม การใช้งานคลาสนี้ที่ได้มามี 2 วิธีที่คุณใช้สร้างคำขอได้ ได้แก่ OneTimeWorkRequest และ PeriodicWorkRequest ตามชื่อที่บอกไว้ OneTimeWorkRequest มีประโยชน์สำหรับการกำหนดเวลางานที่ไม่ซ้ำกัน ส่วน PeriodicWorkRequest เหมาะสำหรับการกำหนดเวลางานที่ทำซ้ำในช่วงเวลาหนึ่งๆ

กำหนดเวลางานแบบครั้งเดียว

สำหรับงานพื้นฐานซึ่งไม่จำเป็นต้องมีการกำหนดค่าเพิ่มเติม ให้ใช้เมธอดแบบคงที่ from ดังนี้

Kotlin

val myWorkRequest = OneTimeWorkRequest.from(MyWork::class.java)

Java

WorkRequest myWorkRequest = OneTimeWorkRequest.from(MyWork.class);

สำหรับงานที่ซับซ้อนมากขึ้น คุณสามารถใช้เครื่องมือสร้างต่อไปนี้

Kotlin

val uploadWorkRequest: WorkRequest =
   OneTimeWorkRequestBuilder<MyWork>()
       // Additional configuration
       .build()

Java

WorkRequest uploadWorkRequest =
   new OneTimeWorkRequest.Builder(MyWork.class)
       // Additional configuration
       .build();

กำหนดเวลางานด่วน

WorkManager 2.7.0 ได้เปิดตัวแนวคิดเรื่องงานด่วน ซึ่งช่วยให้ WorkManager ทำงานที่สำคัญได้ในขณะที่ช่วยให้ระบบควบคุมการเข้าถึงทรัพยากรได้ดีขึ้น

งานด่วนมีลักษณะที่โดดเด่นดังต่อไปนี้

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

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

โควต้า

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

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

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

ดำเนินงานด่วน

ตั้งแต่ WorkManager 2.7 เป็นต้นไป แอปของคุณจะเรียกใช้ setExpedited() เพื่อประกาศว่า WorkRequest ควรทำงานโดยเร็วที่สุดโดยใช้งานด่วนได้ ข้อมูลโค้ดต่อไปนี้แสดงตัวอย่างวิธีใช้ setExpedited()

Kotlin

val request = OneTimeWorkRequestBuilder<SyncWorker>()
    <b>.setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)</b>
    .build()

WorkManager.getInstance(context)
    .enqueue(request)

Java

OneTimeWorkRequest request = new OneTimeWorkRequestBuilder<T>()
    .setInputData(inputData)
    <b>.setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)</b>
    .build();

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

ความเข้ากันได้แบบย้อนหลังและบริการที่ทำงานอยู่เบื้องหน้า

เพื่อรักษาความเข้ากันได้แบบย้อนหลังสำหรับงานด่วน WorkManager อาจเรียกใช้บริการที่ทำงานอยู่เบื้องหน้าในแพลตฟอร์มเวอร์ชันที่เก่ากว่า Android 12 บริการที่ทำงานอยู่เบื้องหน้าสามารถแสดงการแจ้งเตือนแก่ผู้ใช้ได้

เมธอด getForegroundInfoAsync() และ getForegroundInfo() ใน Worker ช่วยให้ WorkManager แสดงการแจ้งเตือนเมื่อคุณเรียกใช้ setExpedited() ก่อน Android 12

ListenableWorker ใดๆ ต้องใช้เมธอด getForegroundInfo หากคุณต้องการขอให้งานทำงานเป็นงานด่วน

เมื่อกำหนดเป้าหมายเป็น Android 12 ขึ้นไป บริการที่ทำงานอยู่เบื้องหน้าจะยังคงพร้อมใช้งานผ่านเมธอด setForeground ที่เกี่ยวข้อง

ผู้ปฏิบัติงาน

ผู้ปฏิบัติงานจะไม่ทราบว่างานที่ทำอยู่เป็นงานเร่งด่วนหรือไม่ แต่ผู้ปฏิบัติงานสามารถแสดงการแจ้งเตือนใน Android บางเวอร์ชันเมื่อมีการเร่ง WorkRequest

WorkManager มีเมธอด getForegroundInfoAsync() เพื่อเปิดใช้ฟีเจอร์นี้ ซึ่งคุณต้องนำไปใช้เพื่อให้ WorkManager แสดงการแจ้งเตือนเพื่อเริ่ม ForegroundService ให้คุณได้เมื่อจำเป็น

CoroutineWorker

หากใช้ CoroutineWorker คุณต้องใช้ getForegroundInfo() จากนั้นคุณจะส่งต่อให้ setForeground() ภายใน doWork() การดำเนินการนี้จะสร้างการแจ้งเตือนใน Android เวอร์ชันก่อน 12

ลองดูตัวอย่างต่อไปนี้

  class ExpeditedWorker(appContext: Context, workerParams: WorkerParameters):
   CoroutineWorker(appContext, workerParams) {

   override suspend fun getForegroundInfo(): ForegroundInfo {
       return ForegroundInfo(
           NOTIFICATION_ID, createNotification()
       )
   }

   override suspend fun doWork(): Result {
       TODO()
   }

    private fun createNotification() : Notification {
       TODO()
    }

}

นโยบายโควต้า

คุณควบคุมสิ่งที่จะเกิดขึ้นกับงานด่วนได้เมื่อแอปถึงโควต้าการดำเนินการ หากต้องการดำเนินการต่อ คุณสามารถส่ง setExpedited() ดังนี้

  • OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST ซึ่งจะทำให้งานทำงานเป็นคำของานปกติ ข้อมูลโค้ดก่อนหน้านี้แสดงให้เห็นถึงกรณีนี้
  • OutOfQuotaPolicy.DROP_WORK_REQUEST ซึ่งจะทำให้คำขอยกเลิกหากมีโควต้าไม่เพียงพอ

งานด่วนที่เลื่อนออกไป

ระบบจะพยายามเรียกใช้งานด่วนที่ระบุโดยเร็วที่สุดหลังจากที่มีการเรียกใช้งาน อย่างไรก็ตาม เช่นเดียวกับงานประเภทอื่นๆ ระบบอาจเลื่อนการเริ่มงานด่วนใหม่ออกไป เช่น ในกรณีต่อไปนี้

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

กำหนดเวลางานเป็นระยะ

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

วิธีใช้ PeriodicWorkRequest เพื่อสร้างออบเจ็กต์ WorkRequest ซึ่งจะทำงานเป็นระยะๆ มีดังนี้

Kotlin

val saveRequest =
       PeriodicWorkRequestBuilder<SaveImageToFileWorker>(1, TimeUnit.HOURS)
    // Additional configuration
           .build()

Java

PeriodicWorkRequest saveRequest =
       new PeriodicWorkRequest.Builder(SaveImageToFileWorker.class, 1, TimeUnit.HOURS)
           // Constraints
           .build();

ในตัวอย่างนี้ งานจะกำหนดเวลาโดยมีช่วงเวลา 1 ชั่วโมง

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

ช่วงเวลาการทำงานที่ยืดหยุ่น

หากลักษณะงานของคุณทำให้มีความละเอียดอ่อนต่อเวลาในการเรียกใช้ คุณสามารถกำหนดค่า PeriodicWorkRequest ให้ทำงานภายในระยะเวลาที่ยืดหยุ่นภายในแต่ละช่วงเวลาได้ ดังที่แสดงในรูปที่ 1

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

รูปที่ 1 แผนภาพแสดงช่วงเวลาที่เกิดซ้ำพร้อมระยะเวลาที่ยืดหยุ่นซึ่งงานสามารถทำงานได้

หากต้องการกำหนดงานเป็นระยะๆ ด้วยระยะเวลาที่ยืดหยุ่น ให้ส่ง flexInterval พร้อมกับ repeatInterval เมื่อสร้าง PeriodicWorkRequest ระยะเวลาที่ยืดหยุ่นจะเริ่มที่ repeatInterval - flexInterval และดำเนินต่อไปจนถึงสิ้นสุดช่วงเวลา

ต่อไปนี้คือตัวอย่างของงานที่ทำเป็นระยะซึ่งสามารถทำงานได้ในช่วง 15 นาทีสุดท้ายของทุกๆ 1 ชั่วโมง

Kotlin

val myUploadWork = PeriodicWorkRequestBuilder<SaveImageToFileWorker>(
       1, TimeUnit.HOURS, // repeatInterval (the period cycle)
       15, TimeUnit.MINUTES) // flexInterval
    .build()

Java

WorkRequest saveRequest =
       new PeriodicWorkRequest.Builder(SaveImageToFileWorker.class,
               1, TimeUnit.HOURS,
               15, TimeUnit.MINUTES)
           .build();

ช่วงเวลาที่เกิดซ้ำต้องมากกว่าหรือเท่ากับ PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS และช่วงเวลาที่ยืดหยุ่นต้องมากกว่าหรือเท่ากับ PeriodicWorkRequest.MIN_PERIODIC_FLEX_MILLIS`

ผลกระทบของข้อจำกัดต่องานที่ทำเป็นระยะ

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

ข้อจำกัดในการทำงาน

Constraints ตรวจสอบว่างานถูกเลื่อนออกไปจนกว่าจะตรงตามเงื่อนไขที่เหมาะสมที่สุด ข้อจำกัดต่อไปนี้ใช้ได้กับ WorkManager

NetworkType จำกัดประเภทเครือข่ายที่จำเป็นสำหรับการทำงาน เช่น Wi-Fi (UNMETERED)
BatteryNotLow เมื่อตั้งค่าเป็น "จริง" งานจะไม่ทำงานหากอุปกรณ์อยู่ในโหมดแบตเตอรี่เหลือน้อย
RequiresCharging เมื่อตั้งค่าเป็น "จริง" งานจะทำงานเมื่ออุปกรณ์กำลังชาร์จเท่านั้น
DeviceIdle เมื่อตั้งค่าเป็น "จริง" อุปกรณ์ของผู้ใช้จะต้องไม่มีการใช้งานก่อนที่งานจะทำงาน ซึ่งจะเป็นประโยชน์สำหรับการเรียกใช้การดำเนินการแบบกลุ่มที่อาจส่งผลเสียต่อประสิทธิภาพของแอปอื่นๆ ที่ทำงานอยู่ในอุปกรณ์ของผู้ใช้
StorageNotLow เมื่อตั้งค่าเป็น "จริง" งานของคุณจะไม่ทำงานหากพื้นที่เก็บข้อมูลของผู้ใช้ในอุปกรณ์เหลือน้อยเกินไป

หากต้องการสร้างชุดข้อจำกัดและเชื่อมโยงกับงานบางอย่าง ให้สร้างอินสแตนซ์ Constraints โดยใช้ Constraints.Builder() และกำหนดให้กับ WorkRequest.Builder()

ตัวอย่างเช่น โค้ดต่อไปนี้จะสร้างคำของานซึ่งจะทำงานเมื่ออุปกรณ์ของผู้ใช้ทั้งกำลังชาร์จและเชื่อมต่อ Wi-Fi เท่านั้น

Kotlin

val constraints = Constraints.Builder()
   .setRequiredNetworkType(NetworkType.UNMETERED)
   .setRequiresCharging(true)
   .build()

val myWorkRequest: WorkRequest =
   OneTimeWorkRequestBuilder<MyWork>()
       .setConstraints(constraints)
       .build()

Java

Constraints constraints = new Constraints.Builder()
       .setRequiredNetworkType(NetworkType.UNMETERED)
       .setRequiresCharging(true)
       .build();

WorkRequest myWorkRequest =
       new OneTimeWorkRequest.Builder(MyWork.class)
               .setConstraints(constraints)
               .build();

เมื่อระบุข้อจำกัดหลายรายการ งานจะทำงานก็ต่อเมื่อเป็นไปตามข้อจำกัดทั้งหมดเท่านั้น

ในกรณีที่ข้อจำกัดไม่เป็นไปตามเงื่อนไขขณะที่งานกำลังทำงานอยู่ WorkManager จะหยุดผู้ปฏิบัติงาน จากนั้นระบบจะลองทำงานอีกครั้งเมื่อเป็นไปตามข้อจำกัดทั้งหมด

งานที่ล่าช้า

ในกรณีที่งานไม่มีข้อจำกัดหรือเป็นไปตามข้อจำกัดทั้งหมดเมื่อจัดคิวงาน ระบบอาจเลือกเรียกใช้งานทันที หากไม่ต้องการให้งานทำงานทันที คุณสามารถระบุให้งานเริ่มหลังจากความล่าช้าเริ่มต้นขั้นต่ำได้

ต่อไปนี้เป็นตัวอย่างวิธีตั้งค่างานให้ทำงานอย่างน้อย 10 นาทีหลังจากที่อยู่ในคิว

Kotlin

val myWorkRequest = OneTimeWorkRequestBuilder<MyWork>()
   .setInitialDelay(10, TimeUnit.MINUTES)
   .build()

Java

WorkRequest myWorkRequest =
      new OneTimeWorkRequest.Builder(MyWork.class)
               .setInitialDelay(10, TimeUnit.MINUTES)
               .build();

แม้ว่าตัวอย่างจะแสดงวิธีตั้งค่าความล่าช้าเริ่มต้นสำหรับ OneTimeWorkRequest แต่คุณก็ตั้งค่าความล่าช้าเริ่มต้นสำหรับ PeriodicWorkRequest ได้เช่นกัน ในกรณีนี้ ระบบจะเลื่อนเฉพาะการเรียกใช้ครั้งแรกของงานที่ทำเป็นระยะเท่านั้น

นโยบายการลองใหม่และ Backoff

หากต้องการให้ WorkManager ลองทำงานอีกครั้ง คุณสามารถแสดงผล Result.retry() จากผู้ปฏิบัติงานได้ จากนั้นระบบจะกำหนดเวลางานใหม่ตามความล่าช้าในการ Backoff และนโยบาย Backoff

  • ความล่าช้าในการ Backoff ระบุระยะเวลาขั้นต่ำที่ต้องรอก่อนที่จะลองทำงานอีกครั้งหลังจากพยายามครั้งแรก ค่านี้ต้องไม่น้อยกว่า 10 วินาที (หรือ MIN_BACKOFF_MILLIS)

  • นโยบาย Backoff กำหนดวิธีเพิ่มความล่าช้าของ Backoff เมื่อเวลาผ่านไปสำหรับการพยายามลองใหม่ครั้งต่อๆ ไป WorkManager รองรับนโยบาย Backoff 2 แบบ ได้แก่ LINEAR และ EXPONENTIAL

คำของานทุกรายการจะมีนโยบาย Backoff และความล่าช้าของ Backoff นโยบายเริ่มต้นคือ EXPONENTIAL โดยมีระยะหน่วง 30 วินาที แต่คุณสามารถลบล้างนโยบายนี้ได้ในการกำหนดค่าคำของาน

ต่อไปนี้คือตัวอย่างการปรับแต่งความล่าช้าและนโยบาย Backoff

Kotlin

val myWorkRequest = OneTimeWorkRequestBuilder<MyWork>()
   .setBackoffCriteria(
       BackoffPolicy.LINEAR,
       WorkRequest.MIN_BACKOFF_MILLIS,
       TimeUnit.MILLISECONDS)
   .build()

Java

WorkRequest myWorkRequest =
       new OneTimeWorkRequest.Builder(MyWork.class)
               .setBackoffCriteria(
                       BackoffPolicy.LINEAR,
                       WorkRequest.MIN_BACKOFF_MILLIS,
                       TimeUnit.MILLISECONDS)
               .build();

ในตัวอย่างนี้ ความล่าช้าในการ Backoff ขั้นต่ำจะตั้งค่าเป็นค่าต่ำสุดที่อนุญาต ซึ่งก็คือ 10 วินาที เนื่องจากนโยบายคือ LINEAR ช่วงเวลาในการลองใหม่จะเพิ่มขึ้นประมาณ 10 วินาทีในการพยายามครั้งใหม่แต่ละครั้ง ตัวอย่างเช่น การเรียกใช้ครั้งแรกที่เสร็จสิ้นด้วย Result.retry() จะมีการพยายามอีกครั้งหลังจากผ่านไป 10 วินาที ตามด้วย 20, 30, 40 วินาที และต่อไปเรื่อยๆ หากงานยังคงแสดงผล Result.retry() หลังจากพยายามครั้งต่อๆ ไป หากตั้งค่านโยบาย Backoff เป็น EXPONENTIAL ลำดับระยะเวลาการลองใหม่จะใกล้เคียงกับ 20, 40 และ 80

งานแท็ก

คำของานแต่ละรายการมีตัวระบุที่ไม่ซ้ำกัน ซึ่งสามารถใช้เพื่อระบุงานนั้นในภายหลังเพื่อยกเลิกงานหรือสังเกตความคืบหน้า

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

ตัวอย่างเช่น WorkManager.cancelAllWorkByTag(String) จะยกเลิกคำของานทั้งหมดที่มีแท็กหนึ่งๆ และ WorkManager.getWorkInfosByTag(String) จะแสดงรายการออบเจ็กต์ WorkInfo ซึ่งใช้เพื่อระบุสถานะงานปัจจุบันได้

โค้ดต่อไปนี้แสดงวิธีเพิ่มแท็ก "cleanup" ลงในงาน

Kotlin

val myWorkRequest = OneTimeWorkRequestBuilder<MyWork>()
   .addTag("cleanup")
   .build()

Java

WorkRequest myWorkRequest =
       new OneTimeWorkRequest.Builder(MyWork.class)
       .addTag("cleanup")
       .build();

สุดท้าย คุณสามารถเพิ่มแท็กหลายรายการลงในคำของานเดียวได้ ภายในระบบ แท็กเหล่านี้จะจัดเก็บเป็นชุดสตริง หากต้องการรับชุดแท็กที่เชื่อมโยงกับ WorkRequest คุณสามารถใช้ WorkInfo.getTags()

จากคลาส Worker คุณสามารถดึงชุดแท็กได้โดยใช้ ListenableWorker.getTags()

กำหนดข้อมูลอินพุต

งานของคุณอาจต้องใช้ข้อมูลอินพุตเพื่อทำงาน ตัวอย่างเช่น งานที่จัดการการอัปโหลดรูปภาพอาจต้องใช้ URI ของรูปภาพที่จะอัปโหลดเป็นอินพุต

ค่าอินพุตจะจัดเก็บเป็นคู่คีย์-ค่าในออบเจ็กต์ Data และตั้งค่าในคำของานได้ WorkManager จะส่งอินพุต Data ไปยังงานของคุณเมื่อเรียกใช้งาน คลาส Worker สามารถเข้าถึงอาร์กิวเมนต์อินพุตได้โดยเรียกใช้ Worker.getInputData() โค้ดต่อไปนี้แสดงวิธีสร้างอินสแตนซ์ Worker ซึ่งต้องใช้ข้อมูลอินพุตและวิธีส่งข้อมูลในคำของาน

Kotlin

// Define the Worker requiring input
class UploadWork(appContext: Context, workerParams: WorkerParameters)
   : Worker(appContext, workerParams) {

   override fun doWork(): Result {
       val imageUriInput =
           inputData.getString("IMAGE_URI") ?: return Result.failure()

       uploadFile(imageUriInput)
       return Result.success()
   }
   ...
}

// Create a WorkRequest for your Worker and sending it input
val myUploadWork = OneTimeWorkRequestBuilder<UploadWork>()
   .setInputData(workDataOf(
       "IMAGE_URI" to "http://..."
   ))
   .build()

Java

// Define the Worker requiring input
public class UploadWork extends Worker {

   public UploadWork(Context appContext, WorkerParameters workerParams) {
       super(appContext, workerParams);
   }

   @NonNull
   @Override
   public Result doWork() {
       String imageUriInput = getInputData().getString("IMAGE_URI");
       if(imageUriInput == null) {
           return Result.failure();
       }

       uploadFile(imageUriInput);
       return Result.success();
   }
   ...
}

// Create a WorkRequest for your Worker and sending it input
WorkRequest myUploadWork =
      new OneTimeWorkRequest.Builder(UploadWork.class)
           .setInputData(
               new Data.Builder()
                   .putString("IMAGE_URI", "http://...")
                   .build()
           )
           .build();

ในทำนองเดียวกัน คุณสามารถใช้คลาส Data เพื่อแสดงผลค่าที่แสดงผลได้

ขั้นตอนถัดไป

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