פרוטוקול Threading ב-CoroutineWorker
קל לארגן דפים בעזרת אוספים
אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.
למשתמשי Kotlin, WorkManager מספק תמיכה ברמה הגבוהה ביותר בפונקציות רפליקות (coroutines). כדי להתחיל, צריך לכלול את work-runtime-ktx
בקובץ ה-gradle. במקום להרחיב את Worker
, צריך להרחיב את CoroutineWorker
, שיש לה גרסה מושהית של doWork()
. לדוגמה, אם רוצים ליצור CoroutineWorker
פשוט כדי לבצע פעולות רשת מסוימות, צריך לבצע את הפעולות הבאות:
class CoroutineDownloadWorker(
context: Context,
params: WorkerParameters
) : CoroutineWorker(context, params) {
override suspend fun doWork(): Result {
val data = downloadSynchronously("https://www.google.com")
saveData(data)
return Result.success()
}
}
שימו לב ש-CoroutineWorker.doWork()
היא פונקציה מושהה. בניגוד ל-Worker
, הקוד הזה לא פועל ב-Executor
שצוין ב-Configuration
. במקום זאת, הערך שמוגדר כברירת מחדל הוא Dispatchers.Default
. אפשר להתאים אישית את האפשרות הזו על ידי הזנת CoroutineContext
משלכם. בדוגמה שלמעלה, מומלץ לבצע את הפעולות האלה ב-Dispatchers.IO
באופן הבא:
class CoroutineDownloadWorker(
context: Context,
params: WorkerParameters
) : CoroutineWorker(context, params) {
override suspend fun doWork(): Result {
withContext(Dispatchers.IO) {
val data = downloadSynchronously("https://www.google.com")
saveData(data)
return Result.success()
}
}
}
CoroutineWorker
מטפל בהפסקות באופן אוטומטי על ידי ביטול של פונקציית ה-coroutine והעברת אותות הביטול. אין צורך לעשות שום דבר מיוחד כדי לטפל בהשבתות עבודה.
הפעלת CoroutineWorker בתהליך אחר
אפשר גם לקשר עובד לתהליך ספציפי באמצעות RemoteCoroutineWorker
, הטמעה של ListenableWorker
.
הפונקציה RemoteCoroutineWorker
מקשרת לתהליך ספציפי באמצעות שני ארגומנטים נוספים שצריך לספק כחלק מנתוני הקלט בזמן היצירה של בקשת העבודה: ARGUMENT_CLASS_NAME
ו-ARGUMENT_PACKAGE_NAME
.
הדוגמה הבאה ממחישה יצירה של בקשת עבודה שמקושרת לתהליך ספציפי:
Kotlin
val PACKAGE_NAME = "com.example.background.multiprocess"
val serviceName = RemoteWorkerService::class.java.name
val componentName = ComponentName(PACKAGE_NAME, serviceName)
val data: Data = Data.Builder()
.putString(ARGUMENT_PACKAGE_NAME, componentName.packageName)
.putString(ARGUMENT_CLASS_NAME, componentName.className)
.build()
return OneTimeWorkRequest.Builder(ExampleRemoteCoroutineWorker::class.java)
.setInputData(data)
.build()
Java
String PACKAGE_NAME = "com.example.background.multiprocess";
String serviceName = RemoteWorkerService.class.getName();
ComponentName componentName = new ComponentName(PACKAGE_NAME, serviceName);
Data data = new Data.Builder()
.putString(ARGUMENT_PACKAGE_NAME, componentName.getPackageName())
.putString(ARGUMENT_CLASS_NAME, componentName.getClassName())
.build();
return new OneTimeWorkRequest.Builder(ExampleRemoteCoroutineWorker.class)
.setInputData(data)
.build();
לכל RemoteWorkerService
, צריך גם להוסיף הגדרת שירות בקובץ AndroidManifest.xml
:
<manifest ... >
<service
android:name="androidx.work.multiprocess.RemoteWorkerService"
android:exported="false"
android:process=":worker1" />
<service
android:name=".RemoteWorkerService2"
android:exported="false"
android:process=":worker2" />
...
</manifest>
דוגמאות התוכן והקוד שבדף הזה כפופות לרישיונות המפורטים בקטע רישיון לתוכן. Java ו-OpenJDK הם סימנים מסחריים או סימנים מסחריים רשומים של חברת Oracle ו/או של השותפים העצמאיים שלה.
עדכון אחרון: 2025-07-27 (שעון UTC).
[[["התוכן קל להבנה","easyToUnderstand","thumb-up"],["התוכן עזר לי לפתור בעיה","solvedMyProblem","thumb-up"],["סיבה אחרת","otherUp","thumb-up"]],[["חסרים לי מידע או פרטים","missingTheInformationINeed","thumb-down"],["התוכן מורכב מדי או עם יותר מדי שלבים","tooComplicatedTooManySteps","thumb-down"],["התוכן לא עדכני","outOfDate","thumb-down"],["בעיה בתרגום","translationIssue","thumb-down"],["בעיה בדוגמאות/בקוד","samplesCodeIssue","thumb-down"],["סיבה אחרת","otherDown","thumb-down"]],["עדכון אחרון: 2025-07-27 (שעון UTC)."],[],[],null,["# Threading in CoroutineWorker\n\nFor Kotlin users, WorkManager provides first-class support for [coroutines](https://kotlinlang.org/docs/reference/coroutines-overview.html). To get\nstarted, include [`work-runtime-ktx` in your gradle file](/jetpack/androidx/releases/work#declaring_dependencies). Instead of extending [`Worker`](/reference/androidx/work/Worker), you should extend [`CoroutineWorker`](/reference/kotlin/androidx/work/CoroutineWorker), which has a suspending\nversion of `doWork()`. For example, if you wanted to build a simple `CoroutineWorker`\nto perform some network operations, you would do the following: \n\n class CoroutineDownloadWorker(\n context: Context,\n params: WorkerParameters\n ) : CoroutineWorker(context, params) {\n\n override suspend fun doWork(): Result {\n val data = downloadSynchronously(\"https://www.google.com\")\n saveData(data)\n return Result.success()\n }\n }\n\nNote that [`CoroutineWorker.doWork()`](/reference/kotlin/androidx/work/CoroutineWorker#doWork()) is a *suspending*\nfunction. Unlike `Worker`, this code does *not* run on the `Executor` specified\nin your [`Configuration`](/reference/androidx/work/Configuration). Instead, it\ndefaults to `Dispatchers.Default`. You can customize this by providing your own `CoroutineContext`. In the above example, you would probably want to do this work on `Dispatchers.IO`, as follows: \n\n class CoroutineDownloadWorker(\n context: Context,\n params: WorkerParameters\n ) : CoroutineWorker(context, params) {\n\n override suspend fun doWork(): Result {\n withContext(Dispatchers.IO) {\n val data = downloadSynchronously(\"https://www.google.com\")\n saveData(data)\n return Result.success()\n }\n }\n }\n\n`CoroutineWorker` handles stoppages automatically by cancelling the coroutine\nand propagating the cancellation signals. You don't need to do anything special\nto handle [work stoppages](/topic/libraries/architecture/workmanager/how-to/managing-work#cancelling).\n\nRunning a CoroutineWorker in a different process\n------------------------------------------------\n\nYou can also bind a worker to a specific process by using\n[`RemoteCoroutineWorker`](/reference/kotlin/androidx/work/multiprocess/RemoteCoroutineWorker),\nan implementation of `ListenableWorker`.\n\n`RemoteCoroutineWorker` binds to a specific process with two extra arguments\nthat you provide as part of the input data when building the work request:\n`ARGUMENT_CLASS_NAME` and `ARGUMENT_PACKAGE_NAME`.\n\nThe following example demonstrates building a work request that is bound to a\nspecific process: \n\n### Kotlin\n\n```kotlin\nval PACKAGE_NAME = \"com.example.background.multiprocess\"\n\nval serviceName = RemoteWorkerService::class.java.name\nval componentName = ComponentName(PACKAGE_NAME, serviceName)\n\nval data: Data = Data.Builder()\n .putString(ARGUMENT_PACKAGE_NAME, componentName.packageName)\n .putString(ARGUMENT_CLASS_NAME, componentName.className)\n .build()\n\nreturn OneTimeWorkRequest.Builder(ExampleRemoteCoroutineWorker::class.java)\n .setInputData(data)\n .build()\n```\n\n### Java\n\n```java\nString PACKAGE_NAME = \"com.example.background.multiprocess\";\n\nString serviceName = RemoteWorkerService.class.getName();\nComponentName componentName = new ComponentName(PACKAGE_NAME, serviceName);\n\nData data = new Data.Builder()\n .putString(ARGUMENT_PACKAGE_NAME, componentName.getPackageName())\n .putString(ARGUMENT_CLASS_NAME, componentName.getClassName())\n .build();\n\nreturn new OneTimeWorkRequest.Builder(ExampleRemoteCoroutineWorker.class)\n .setInputData(data)\n .build();\n```\n\nFor each `RemoteWorkerService`, you also need to add a service definition in\nyour `AndroidManifest.xml` file: \n\n```xml\n\u003cmanifest ... \u003e\n \u003cservice\n android:name=\"androidx.work.multiprocess.RemoteWorkerService\"\n android:exported=\"false\"\n android:process=\":worker1\" /\u003e\n\n \u003cservice\n android:name=\".RemoteWorkerService2\"\n android:exported=\"false\"\n android:process=\":worker2\" /\u003e\n ...\n\u003c/manifest\u003e\n```"]]