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

คู่มือเริ่มต้นใช้งานได้อธิบายวิธีสร้าง 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 เพื่อรักษาความเข้ากันได้แบบย้อนหลังสำหรับงานที่เร่งด่วน Foreground services สามารถแสดงการแจ้งเตือนต่อผู้ใช้ได้

เมธอด 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 ซึ่งทำให้คำขอถูกยกเลิกหาก มีโควต้าไม่เพียงพอ

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

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

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

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

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

วิธีใช้ 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 ได้เช่นกัน ในกรณีดังกล่าว ระบบจะเลื่อนเฉพาะการเรียกใช้ครั้งแรกของงานเป็นระยะ เท่านั้น

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

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

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

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

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

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

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() หลังจากพยายามครั้งต่อๆ ไป หากตั้งค่านโยบาย Backoff เป็น 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 เพื่อแสดงค่าที่ส่งคืนได้

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

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