L'API Task è il modo standard per gestire le operazioni asincrone in Google Play Services. Fornisce un modo potente e flessibile per gestire le chiamate asincrone, sostituendo il pattern PendingResult precedente. Con Task, puoi concatenare più chiamate, gestire flussi complessi e scrivere gestori di successo ed errore chiari.
Gestire i risultati delle attività
Molte API in Google Play Services e Firebase restituiscono un oggetto Task per rappresentare le operazioni asincrone. Ad esempio, FirebaseAuth.signInAnonymously() restituisce un Task<AuthResult> che rappresenta il risultato dell'operazione di accesso. Task<AuthResult> indica che quando l'attività viene completata correttamente, restituirà un oggetto AuthResult.
Puoi gestire il risultato di un Task collegando listener che rispondono al completamento riuscito, all'errore o a entrambi:
Task<AuthResult> task = FirebaseAuth.getInstance().signInAnonymously();
Per gestire il completamento di un'attività, allega un OnSuccessListener:
task.addOnSuccessListener(new OnSuccessListener<AuthResult>() { @Override public void onSuccess(AuthResult authResult) { // Task completed successfully // ... } });
Per gestire un'attività non riuscita, allega un OnFailureListener:
task.addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { // Task failed with an exception // ... } });
Per gestire sia l'esito positivo che negativo nello stesso listener, collega un OnCompleteListener:
task.addOnCompleteListener(new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { // Task completed successfully AuthResult result = task.getResult(); } else { // Task failed with an exception Exception exception = task.getException(); } } });
Gestire i thread
Per impostazione predefinita, i listener collegati a un Task vengono eseguiti sul thread principale (UI) dell'applicazione. Ciò significa che devi evitare di eseguire operazioni di lunga durata nei listener. Se devi eseguire un'operazione di lunga durata, puoi specificare un Executor utilizzato per pianificare i listener su un thread in background.
// Create a new ThreadPoolExecutor with 2 threads for each processor on the // device and a 60 second keep-alive time. int numCores = Runtime.getRuntime().availableProcessors(); ThreadPoolExecutor executor = new ThreadPoolExecutor(numCores * 2, numCores *2, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>()); task.addOnCompleteListener(executor, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { // ... } });
Utilizzare i listener con ambito di attività
Quando devi gestire i risultati delle attività all'interno di un Activity, è importante gestire il ciclo di vita dei listener per evitare che vengano chiamati quando il Activity non è più visibile. Per farlo, puoi utilizzare i listener con ambito attività. Questi listener vengono rimossi automaticamente quando viene chiamato il metodo onStop del tuo Activity, in modo che non vengano eseguiti dopo l'interruzione di Activity.
Activity activity = MainActivity.this; task.addOnCompleteListener(activity, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { // ... } });
Attività a catena
Se utilizzi un insieme di API che restituiscono oggetti Task in una funzione complessa, puoi concatenarli utilizzando le continuazioni. In questo modo eviti callback nidificati in profondità e consolidi la gestione degli errori per più attività concatenate.
Ad esempio, considera uno scenario in cui hai un metodo doSomething che restituisce un Task<String>, ma richiede un AuthResult come parametro. Puoi ottenere questo AuthResult in modo asincrono da un altro Task:
public Task<String> doSomething(AuthResult authResult) { // ... }Utilizzando il metodo Task.continueWithTask, puoi concatenare queste due attività:
Task<AuthResult> signInTask = FirebaseAuth.getInstance().signInAnonymously(); signInTask.continueWithTask(new Continuation<AuthResult, Task<String>>() { @Override public Task<String> then(@NonNull Task<AuthResult> task) throws Exception { // Take the result from the first task and start the second one AuthResult result = task.getResult(); return doSomething(result); } }).addOnSuccessListener(new OnSuccessListener<String>() { @Override public void onSuccess(String s) { // Chain of tasks completed successfully, got result from last task. // ... } }).addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { // One of the tasks in the chain failed with an exception. // ... } });
Bloccare un'attività
Se il programma è già in esecuzione in un thread in background, puoi bloccare il thread corrente e attendere il completamento dell'attività, anziché utilizzare un callback:
try { // Block on a task and get the result synchronously. This is generally done // when executing a task inside a separately managed background thread. Doing this // on the main (UI) thread can cause your application to become unresponsive. AuthResult authResult = Tasks.await(task); } catch (ExecutionException e) { // The Task failed, this is the same exception you'd get in a non-blocking // failure handler. // ... } catch (InterruptedException e) { // An interrupt occurred while waiting for the task to complete. // ... }Puoi anche specificare un timeout quando blocchi un'attività per evitare che l'applicazione si blocchi indefinitamente se l'attività richiede troppo tempo per essere completata:
try { // Block on the task for a maximum of 500 milliseconds, otherwise time out. AuthResult authResult = Tasks.await(task, 500, TimeUnit.MILLISECONDS); } catch (ExecutionException e) { // ... } catch (InterruptedException e) { // ... } catch (TimeoutException e) { // Task timed out before it could complete. // ... }Interoperabilità
Task è progettato per funzionare bene con altri pattern di programmazione asincrona comuni di Android. Può essere convertito in e da altre primitive come ListenableFuture e le coroutine Kotlin, che sono consigliate da AndroidX, consentendoti di utilizzare l'approccio più adatto alle tue esigenze.
Ecco un esempio con l'utilizzo di un Task:
// ... simpleTask.addOnCompleteListener(this) { completedTask -> textView.text = completedTask.result }
Coroutine Kotlin
Per utilizzare le coroutine Kotlin con Task, aggiungi la seguente dipendenza al tuo progetto e poi utilizza lo snippet di codice per eseguire la conversione da Task.
Gradle (build.gradle a livello di modulo, di solito app/build.gradle)
// Source: https://github.com/Kotlin/kotlinx.coroutines/tree/master/integration/kotlinx-coroutines-play-services implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-play-services:1.7.3'
Snippet
import kotlinx.coroutines.tasks.await // ... textView.text = simpleTask.await() }
Guava ListenableFuture
Per utilizzare Guava ListenableFuture con Task, aggiungi la seguente dipendenza al tuo progetto e poi utilizza lo snippet di codice per la conversione da un Task.
Gradle (build.gradle a livello di modulo, di solito app/build.gradle)
implementation "androidx.concurrent:concurrent-futures:1.2.0"
Snippet
import com.google.common.util.concurrent.ListenableFuture // ... /** Convert Task to ListenableFuture. */ fun <T> taskToListenableFuture(task: Task<T>): ListenableFuture<T> { return CallbackToFutureAdapter.getFuture { completer -> task.addOnCompleteListener { completedTask -> if (completedTask.isCanceled) { completer.setCancelled() } else if (completedTask.isSuccessful) { completer.set(completedTask.result) } else { val e = completedTask.exception if (e != null) { completer.setException(e) } else { throw IllegalStateException() } } } } } // ... this.listenableFuture = taskToListenableFuture(simpleTask) this.listenableFuture?.addListener( Runnable { textView.text = listenableFuture?.get() }, ContextCompat.getMainExecutor(this) )
RxJava2 Observable
Aggiungi al tuo progetto la seguente dipendenza, oltre alla libreria asincrona relativa di tua scelta, quindi utilizza lo snippet di codice per la conversione da un Task.
Gradle (build.gradle a livello di modulo, di solito app/build.gradle)
// Source: https://github.com/ashdavies/rx-tasks implementation 'io.ashdavies.rx.rxtasks:rx-tasks:2.2.0'
Snippet
import io.ashdavies.rx.rxtasks.toSingle import java.util.concurrent.TimeUnit // ... simpleTask.toSingle(this).subscribe { result -> textView.text = result }