Obsługa długotrwałych instancji roboczych

Biblioteka WorkManager ma wbudowaną obsługę długotrwałych procesów roboczych. W takich przypadkach biblioteka WorkManager może wysłać do systemu operacyjnego sygnał, że proces powinien być utrzymywany przy życiu, jeśli to możliwe, podczas wykonywania tej pracy. Te procesy robocze mogą działać dłużej niż 10 minut. Przykłady zastosowań tej nowej funkcji to m.in. przesyłanie zbiorcze lub pobieranie (którego nie można podzielić na części), lokalne przetwarzanie modelu ML lub zadanie ważne dla użytkownika aplikacji.

Biblioteka WorkManager zarządza usługą działającą na pierwszym planie i uruchamia ją w Twoim imieniu aby wykonać WorkRequest, a także wyświetla konfigurowalne powiadomienie.

ListenableWorker obsługuje teraz interfejs setForegroundAsync(), a CoroutineWorker – interfejs setForeground() zawieszający. Te interfejsy API pozwalają programistom określić, że dany WorkRequest jest ważny (z perspektywy użytkownika) lub długotrwały.

Od wersji 2.3.0-alpha03 biblioteka WorkManager umożliwia też utworzenie PendingIntent, którego można użyć do anulowania procesów roboczych bez konieczności rejestrowania nowego komponentu Androida za pomocą createCancelPendingIntent() interfejsu API. To podejście jest szczególnie przydatne w przypadku używania interfejsów setForegroundAsync() lub setForeground(), których można użyć do dodania działania powiadomienia, aby anulować Worker.

Tworzenie długotrwałych procesów roboczych i zarządzanie nimi

W zależności od tego, czy kodujesz w Kotlinie czy w Javie, będziesz używać nieco innego podejścia.

Kotlin

Deweloperzy Kotlin powinni używać CoroutineWorker. Zamiast używać setForegroundAsync(), możesz użyć zawieszającej wersji tej metody, setForeground().

class DownloadWorker(context: Context, parameters: WorkerParameters) :
   CoroutineWorker(context, parameters) {

   private val notificationManager =
       context.getSystemService(Context.NOTIFICATION_SERVICE) as
               NotificationManager

   override suspend fun doWork(): Result {
       val inputUrl = inputData.getString(KEY_INPUT_URL)
                      ?: return Result.failure()
       val outputFile = inputData.getString(KEY_OUTPUT_FILE_NAME)
                      ?: return Result.failure()
       // Mark the Worker as important
       val progress = "Starting Download"
       setForeground(createForegroundInfo(progress))
       download(inputUrl, outputFile)
       return Result.success()
   }

   private fun download(inputUrl: String, outputFile: String) {
       // Downloads a file and updates bytes read
       // Calls setForeground() periodically when it needs to update
       // the ongoing Notification
   }
   // Creates an instance of ForegroundInfo which can be used to update the
   // ongoing notification.
   private fun createForegroundInfo(progress: String): ForegroundInfo {
       val id = applicationContext.getString(R.string.notification_channel_id)
       val title = applicationContext.getString(R.string.notification_title)
       val cancel = applicationContext.getString(R.string.cancel_download)
       // This PendingIntent can be used to cancel the worker
       val intent = WorkManager.getInstance(applicationContext)
               .createCancelPendingIntent(getId())

       // Create a Notification channel if necessary
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
           createChannel()
       }

       val notification = NotificationCompat.Builder(applicationContext, id)
           .setContentTitle(title)
           .setTicker(title)
           .setContentText(progress)
           .setSmallIcon(R.drawable.ic_work_notification)
           .setOngoing(true)
           // Add the cancel action to the notification which can
           // be used to cancel the worker
           .addAction(android.R.drawable.ic_delete, cancel, intent)
           .build()

       return ForegroundInfo(notificationId, notification)
   }

   @RequiresApi(Build.VERSION_CODES.O)
   private fun createChannel() {
       // Create a Notification channel
   }

   companion object {
       const val KEY_INPUT_URL = "KEY_INPUT_URL"
       const val KEY_OUTPUT_FILE_NAME = "KEY_OUTPUT_FILE_NAME"
   }
}

Java

Deweloperzy korzystający z ListenableWorker lub z Worker mogą wywołać interfejs setForegroundAsync(), który zwraca ListenableFuture<Void>. Możesz też wywołać setForegroundAsync(), aby zaktualizować bieżące Notification.

Oto prosty przykład długotrwałego procesu roboczego, który pobiera plik. Ten proces roboczy śledzi postęp, aby aktualizować bieżące Notification, które pokazuje postęp pobierania.

public class DownloadWorker extends Worker {
   private static final String KEY_INPUT_URL = "KEY_INPUT_URL";
   private static final String KEY_OUTPUT_FILE_NAME = "KEY_OUTPUT_FILE_NAME";

   private NotificationManager notificationManager;

   public DownloadWorker(
       @NonNull Context context,
       @NonNull WorkerParameters parameters) {
           super(context, parameters);
           notificationManager = (NotificationManager)
               context.getSystemService(NOTIFICATION_SERVICE);
   }

   @NonNull
   @Override
   public Result doWork() {
       Data inputData = getInputData();
       String inputUrl = inputData.getString(KEY_INPUT_URL);
       String outputFile = inputData.getString(KEY_OUTPUT_FILE_NAME);
       // Mark the Worker as important
       String progress = "Starting Download";
       setForegroundAsync(createForegroundInfo(progress));
       download(inputUrl, outputFile);
       return Result.success();
   }

   private void download(String inputUrl, String outputFile) {
       // Downloads a file and updates bytes read
       // Calls setForegroundAsync(createForegroundInfo(myProgress))
       // periodically when it needs to update the ongoing Notification.
   }

   @NonNull
   private ForegroundInfo createForegroundInfo(@NonNull String progress) {
       // Build a notification using bytesRead and contentLength

       Context context = getApplicationContext();
       String id = context.getString(R.string.notification_channel_id);
       String title = context.getString(R.string.notification_title);
       String cancel = context.getString(R.string.cancel_download);
       // This PendingIntent can be used to cancel the worker
       PendingIntent intent = WorkManager.getInstance(context)
               .createCancelPendingIntent(getId());

       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
           createChannel();
       }

       Notification notification = new NotificationCompat.Builder(context, id)
               .setContentTitle(title)
               .setTicker(title)
               .setSmallIcon(R.drawable.ic_work_notification)
               .setOngoing(true)
               // Add the cancel action to the notification which can
               // be used to cancel the worker
               .addAction(android.R.drawable.ic_delete, cancel, intent)
               .build();

       return new ForegroundInfo(notificationId, notification);
   }

   @RequiresApi(Build.VERSION_CODES.O)
   private void createChannel() {
       // Create a Notification channel
   }
}

Dodawanie typu usługi działającej na pierwszym planie do długotrwałego procesu roboczego

Jeśli Twoja aplikacja jest kierowana na Androida 14 (API na poziomie 34) lub nowszego, musisz określić a typ usługi działającej na pierwszym planie dla wszystkich długotrwałych procesów roboczych. Jeśli Twoja aplikacja jest kierowana na Androida 10 (API na poziomie 29) lub nowszego i zawiera długotrwały proces roboczy, który wymaga dostępu do lokalizacji, wskaż, że proces roboczy używa typu usługi działającej na pierwszym planie location.

Jeśli Twoja aplikacja jest kierowana na Androida 11 (poziom API 30) lub nowszego i zawiera długotrwały worker, który wymaga dostępu do aparatu lub mikrofonu, zadeklaruj odpowiednio typy usług działających na pierwszym planie camera lub microphone.

Aby dodać te typy usług działających na pierwszym planie, wykonaj czynności opisane w kolejnych sekcjach.

Deklarowanie typów usług działających na pierwszym planie w pliku manifestu aplikacji

Zadeklaruj typ usługi działającej na pierwszym planie w pliku manifestu aplikacji. W tym przykładzie proces roboczy wymaga dostępu do lokalizacji i mikrofonu:

AndroidManifest.xml

<service
   android:name="androidx.work.impl.foreground.SystemForegroundService"
   android:foregroundServiceType="location|microphone"
   tools:node="merge" />

Określanie typów usług działających na pierwszym planie w czasie działania

Gdy wywołujesz setForeground() lub setForegroundAsync(), upewnij się, że określasz typ usługi działającej na pierwszym planie.

MyLocationAndMicrophoneWorker

Kotlin

private fun createForegroundInfo(progress: String): ForegroundInfo {
   // ...
   return ForegroundInfo(NOTIFICATION_ID, notification,
           FOREGROUND_SERVICE_TYPE_LOCATION or
FOREGROUND_SERVICE_TYPE_MICROPHONE) }

Java

@NonNull
private ForegroundInfo createForegroundInfo(@NonNull String progress) {
   // Build a notification...
   Notification notification = ...;
   return new ForegroundInfo(NOTIFICATION_ID, notification,
           FOREGROUND_SERVICE_TYPE_LOCATION | FOREGROUND_SERVICE_TYPE_MICROPHONE);
}