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

คู่มือการเริ่มต้นใช้งานได้อธิบายวิธีสร้าง 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 รองรับนโยบาย Backoff 2 แบบ ได้แก่ LINEAR และ EXPONENTIAL

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

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

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

WorkRequest myWorkRequest =
       new OneTimeWorkRequest.Builder(MyWork.class)
               .setBackoffCriteria(
                       BackoffPolicy.LINEAR,
                       OneTimeWorkRequest.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 class สามารถเข้าถึง อาร์กิวเมนต์อินพุตได้โดยการเรียกใช้ 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 เพื่อแสดงผลค่าที่ส่งคืนได้ ข้อมูลอินพุตและเอาต์พุตจะอธิบายรายละเอียดเพิ่มเติมในส่วนพารามิเตอร์อินพุตและค่าที่ส่งคืน

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

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