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

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

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

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

ภาพรวม

Work กำหนดใน 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 มักจะส่งผลต่องานที่ต้องเร่งรีบน้อยลง
  • เวลาในการตอบสนอง: ระบบจะดำเนินการที่เร่งด่วนทันที หากภาระงานปัจจุบันของระบบช่วยให้ดำเนินการดังกล่าวได้ ซึ่งหมายความว่างานเหล่านี้จะมีความไวต่อเวลาในการตอบสนองและไม่สามารถกำหนดเวลาให้ดำเนินการในภายหลังได้

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

โควต้า

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

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

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

กำลังทำงานด่วน

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

Kotlin

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

WorkManager.getInstance(context)
    .enqueue(request)

Java

OneTimeWorkRequest request = new OneTimeWorkRequestBuilder<T>()
    .setInputData(inputData)
    .setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)
    .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 ซึ่งจะทำให้คำขอถูกยกเลิกหากมีโควต้าไม่เพียงพอ

แอปตัวอย่าง

หากต้องการดูตัวอย่างที่สมบูรณ์เกี่ยวกับวิธีที่ WorkManager 2.7.0 ใช้งานที่เร่งด่วน ให้ดูWorkManagerSample ใน GitHub

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

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

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

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

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

ต่อไปนี้คือวิธีใช้ 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 ชั่วโมง

ระยะเวลาของช่วงเวลาหมายถึงเวลาขั้นต่ำระหว่างการทําซ้ำ เวลาที่แน่นอนที่ระบบจะเรียกใช้ Executor ขึ้นอยู่กับข้อจำกัดที่คุณใช้ในออบเจ็กต์ 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 และช่วง Flex ต้องมากกว่าหรือเท่ากับ PeriodicWorkRequest.MIN_PERIODIC_FLEX_MILLIS

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

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

ข้อจำกัดของงาน

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

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

หากต้องการสร้างชุดข้อจำกัดและเชื่อมโยงกับงานบางอย่าง ให้สร้างอินสแตนซ์ Constraints โดยใช้ Contraints.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 ได้ด้วย ในกรณีนี้ เฉพาะการเรียกใช้งานตามรอบครั้งแรกเท่านั้นที่จะล่าช้า

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

หากต้องการให้ WorkManager พยายามทำงานอีกครั้ง คุณสามารถส่งกลับ Result.retry() จาก Executor จากนั้นจะกำหนดเวลางานใหม่ตามการหน่วงเวลาแบ็คออฟและนโยบาย Backoff

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

  • นโยบายการหยุดชั่วคราวจะกำหนดระยะเวลาที่เพิ่มขึ้นของเวลาหยุดชั่วคราวสำหรับการพยายามดำเนินการอีกครั้งในภายหลัง WorkManager รองรับนโยบาย Backoff 2 นโยบาย LINEARและ EXPONENTIAL

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

ตัวอย่างการกำหนดการหน่วงเวลา Backoff และนโยบายมีดังนี้

Kotlin

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

Java

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

ในตัวอย่างนี้ การหน่วงเวลา Backoff ขั้นต่ำจะตั้งเป็นค่าขั้นต่ำที่อนุญาต คือ 10 วินาที เนื่องจากนโยบายคือ LINEAR ช่วงเวลาในการลองใหม่จะเพิ่มขึ้นประมาณ 10 วินาทีทุกครั้งที่ลองใหม่ ตัวอย่างเช่น การเรียกใช้ครั้งแรกที่จบด้วย Result.retry() จะพยายามดำเนินการอีกครั้งหลังจากผ่านไป 10 วินาที ตามด้วย 20, 30, 40 และอื่นๆ หากงานยังคงแสดง Result.retry() ต่อไปหลังจากการพยายามครั้งต่อๆ ไป หากตั้งค่านโยบายการหยุดชั่วคราวเป็น 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 เพื่อแสดงผลค่าที่แสดงผล ข้อมูลอินพุตและเอาต์พุตจะอธิบายไว้อย่างละเอียดในส่วนพารามิเตอร์อินพุตและค่าที่แสดงผล

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

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