WorkManager dispone di supporto integrato per i worker a lunga esecuzione. In questi casi, WorkManager può fornire un segnale al sistema operativo per confermare che il processo deve essere mantenuto attivo. se possibile durante l'esecuzione di questo lavoro. Questi worker possono eseguire più di 10 minuti. Tra gli esempi di casi d'uso di questa nuova funzionalità ci sono i caricamenti collettivi o (che non possono essere suddivisi in blocchi), l'analisi locale di un modello ML o che sono importanti per l'utente dell'app.
WorkManager gestisce ed esegue un servizio in primo piano per tuo conto
per eseguire WorkRequest
, mostrando al contempo un ambiente
notifica.
ListenableWorker
ora supporta l'API setForegroundAsync()
e
CoroutineWorker
supporta un'API setForeground()
sospesa. Questi
Le API consentono agli sviluppatori di specificare che questo WorkRequest
è importante (da un
punto di vista dell'utente) o a lunga durata.
A partire da 2.3.0-alpha03
, WorkManager ti consente anche di creare un'immagine
PendingIntent
, che può essere utilizzato per annullare i lavoratori senza dover
registrare un nuovo componente Android utilizzando createCancelPendingIntent()
tramite Google Cloud CLI
o tramite l'API Compute Engine. Questo approccio è particolarmente utile quando utilizzato con
API setForegroundAsync()
o setForeground()
, che possono essere utilizzate per aggiungere un
per annullare Worker
.
Creazione e gestione dei worker a lunga esecuzione
Sarà utilizzato un approccio leggermente diverso a seconda che la programmazione sia attiva o meno Kotlin o Java.
Kotlin
Gli sviluppatori Kotlin devono utilizzare CoroutineWorker
. Invece di utilizzare
setForegroundAsync()
, puoi usare la versione sospesa di questo metodo,
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
Gli sviluppatori che utilizzano un ListenableWorker
o un Worker
possono chiamare il metodo
API setForegroundAsync()
, che restituisce ListenableFuture<Void>
. Tu
puoi anche chiamare setForegroundAsync()
per aggiornare un Notification
in corso.
Ecco un semplice esempio di worker a lunga esecuzione che scarica un file. Questo
Il worker tiene traccia dei progressi per aggiornare un Notification
in corso che mostra
l'avanzamento del download.
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
}
}
Aggiungi un tipo di servizio in primo piano a un worker a lunga esecuzione
Se la tua app ha come target Android 14 (livello API 34) o versioni successive, devi specificare una
tipo di servizio in primo piano per tutti i worker a lunga esecuzione.
Se la tua app ha come target Android 10 (livello API 29) o versioni successive e contiene un
worker a lunga esecuzione che richiede l'accesso alla posizione, indica che il worker
utilizza un tipo di servizio in primo piano location
.
Se la tua app ha come target Android 11 (livello API 30) o versioni successive
e contiene un worker di lunga durata che richiede l'accesso alla fotocamera o al microfono,
dichiarare il primo piano camera
o microphone
tipi di servizi, rispettivamente.
Per aggiungere questi tipi di servizi in primo piano, completa i passaggi descritti nella sezione le sezioni seguenti.
Dichiara i tipi di servizi in primo piano nel file manifest dell'app
Dichiara il tipo di servizio in primo piano del worker nel file manifest dell'app. Nella Nell'esempio seguente, il lavoratore richiede l'accesso alla posizione e al microfono:
AndroidManifest.xml
<service android:name="androidx.work.impl.foreground.SystemForegroundService" android:foregroundServiceType="location|microphone" tools:node="merge" />
Specifica i tipi di servizi in primo piano durante il runtime
Quando chiami setForeground()
o setForegroundAsync()
, assicurati di specificare un
tipo di servizio in primo piano.
MiaPosizioneEMicrofono
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); }