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

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

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

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

ภาพรวม

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

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

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

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

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

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

สําหรับงานพื้นฐานที่ไม่ต้องมีการกําหนดค่าเพิ่มเติม ให้ใช้วิธีการแบบคงที่ from

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

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

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

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

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

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

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

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

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

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

โควต้า

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

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

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

ดำเนินการกับงานด่วน

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

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

WorkManager.getInstance(context)
    .enqueue(request)

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 ที่เกี่ยวข้อง

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

ผู้ปฏิบัติงานไม่ทราบว่างานที่ตนทำนั้นเป็นงานเร่งด่วนหรือไม่ แต่ Worker จะแสดงการแจ้งเตือนใน 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 ซึ่งทำให้คำขอถูกยกเลิกหากมีโควต้าไม่เพียงพอ

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ตัวอย่างวิธีตั้งค่างานให้ทำงานอย่างน้อย 10 นาทีหลังจาก มีการจัดคิว

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

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

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

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

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

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

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

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

ตัวอย่างการปรับแต่งการหน่วงเวลาและการใช้นโยบายการหยุดชั่วคราวมีดังนี้

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

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

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

ติดแท็กงาน

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

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

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

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

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

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

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

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

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

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

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

// 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()

// 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 เพื่อแสดงค่าที่ส่งคืนได้

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

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