Obsługa długotrwałych instancji roboczych

WorkManager ma wbudowaną obsługę długotrwałych wątków. W takich przypadkach WorkManager może wysłać do systemu operacyjnego sygnał, że proces powinien być utrzymany w stanie aktywnym, o ile to możliwe, podczas wykonywania tej pracy. Takie zadania mogą trwać dłużej niż 10 minut. Przykładowe zastosowania tej nowej funkcji to m.in. przesyłanie i pobieranie zbiorcze (które nie mogą być dzielone na części), przetwarzanie lokalnie modelu ML lub zadanie, które jest ważne dla użytkownika aplikacji.

WorkManager zarządza usługą na pierwszym planie i uruchamia ją w Twoim imieniu, aby wykonać WorkRequest, a także wyświetla powiadomienie, które można skonfigurować.

ListenableWorker obsługuje teraz interfejs setForegroundAsync(), a CoroutineWorker obsługuje zawieszanie interfejsu setForeground() API. Te interfejsy API umożliwiają deweloperom określenie, że ta funkcja WorkRequest jest ważna (z perspektywy użytkownika) lub długotrwała.

Od wersji 2.3.0-alpha03 WorkManager umożliwia też tworzenie PendingIntent, którego można używać do anulowania działań bez konieczności rejestrowania nowego komponentu Androida za pomocą interfejsu API createCancelPendingIntent(). To podejście jest szczególnie przydatne w przypadku interfejsów API setForegroundAsync() lub setForeground(), które umożliwiają dodanie działania powiadomienia w celu anulowania Worker.

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

W zależności od tego, czy kodujesz w Kotlinie czy w Javie, zastosujesz nieco inną metodę.

Kotlin

Deweloperzy Kotlina powinni używać CoroutineWorker. Zamiast używać interfejsu setForegroundAsync(), możesz użyć jego wersji z zawieszeniem, czyli 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 interfejsu ListenableWorker lub Worker mogą wywołać interfejs API setForegroundAsync(), który zwraca ListenableFuture<Void>. Możesz też zadzwonić na numer setForegroundAsync(), aby zaktualizować trwającą Notification.

Oto prosty przykład długotrwałego procesu, który pobiera plik. Ten Worker śledzi postępy, aby aktualizować trwającą Notification, która 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 na pierwszym planie do długotrwałego procesu

Uwaga: w zależności od poziomu interfejsu API, na który kierowana jest aplikacja, oraz rodzaju wykonywanej pracy, może być wymagane zadeklarowanie typu usługi na pierwszym planie. Deklarowanie typu usługi na pierwszym planie to sprawdzona metoda niezależnie od tego, na jaką wersję Androida kierujesz aplikację. Więcej informacji znajdziesz w artykule Oświadczanie usług na pierwszym planie i proszenie o przyznanie uprawnień

.

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

Jeśli Twoja aplikacja jest kierowana na Androida w wersji 11 (poziom API 30) lub nowszej i zawiera długo działający proces, który wymaga dostępu do aparatu lub mikrofonu, zadeklaruj odpowiednio typ usługi na pierwszym planie camera lub microphone.

Aby dodać te typy usług na pierwszym planie, wykonaj czynności opisane w poniższych sekcjach.

Zadeklaruj typy usług na pierwszym planie w pliku manifestu aplikacji

Zadeklaruj typ usługi na pierwszym planie w pliku manifestu aplikacji. W tym przykładzie pracownik potrzebuje dostępu do lokalizacji i mikrofonu:

AndroidManifest.xml

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

Uwaga: narzędzia do scalania plików manifestu łączą deklarację elementu <service> z poprzedniego fragmentu kodu z deklaracją, którą WorkManager definiuje w swoim pliku manifestu.

SystemForegroundService

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

Gdy wywołujesz setForeground() lub setForegroundAsync(), pamiętaj, aby określić typ usługi na pierwszym planie.

Uwaga: począwszy od Androida 14 (poziom API 34), gdy wywołujesz setForeground() lub setForegroundAsync(), system sprawdza, czy nie ma określonych wymagań wstępnych na podstawie typu usługi. Więcej informacji znajdziesz w artykule Oświadczanie usług na pierwszym planie i proszenie o uprawnienia

.

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);
}