L'API Task
è il modo standard per gestire le operazioni asincrone in Google Play Services. Fornisce un modo efficace e flessibile per gestire le chiamate asincrone, sostituendo il precedente pattern PendingResult
. 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 al termine dell'attività verrà restituito un oggetto AuthResult
.
Puoi gestire il risultato di un Task
collegando ascoltatori che rispondono al completamento riuscito, al fallimento 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 il successo che l'errore nello stesso listener, allega 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, gli ascoltatori associati a un Task
vengono eseguiti sul thread principale (UI) dell'applicazione. Ciò significa che dovresti evitare di eseguire operazioni che richiedono molto tempo nei visualizzatori. Se devi eseguire un'operazione di lunga durata, puoi specificare un Executor
utilizzato per pianificare gli ascoltatori in 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 gli ascoltatori basati sulle attività
Quando devi gestire i risultati delle attività all'interno di un Activity
, è importante gestire il ciclo di vita degli ascoltatori per impedire che vengano chiamati quando il Activity
non è più visibile. A tale scopo, puoi utilizzare gli ascoltatori basati sulle attività. Questi ascoltatori vengono rimossi automaticamente quando viene chiamato il metodo onStop
del Activity
, in modo che non vengano eseguiti dopo l'interruzione del Activity
.
Activity activity = MainActivity.this; task.addOnCompleteListener(activity, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { // ... } });
Attività in catena
Se utilizzi un insieme di API che restituiscono oggetti Task
in una funzione complessa,
puoi collegarle in serie utilizzando le continue. In questo modo puoi evitare callback molto nidificati e consolidare la gestione degli errori per più attività incatenate.
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 tuo programma è già in esecuzione in un thread in background, puoi bloccare il thread attuale 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 impedire all'applicazione di bloccarsi 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 Android comuni. 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 di 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 progetto e poi utilizza lo snippet di codice per eseguire la conversione da un Task
.
Gradle (build.gradle
a livello di modulo, in genere 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 eseguire la conversione da un Task
.
Gradle (build.gradle
a livello di modulo, in genere 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 la seguente dipendenza al tuo progetto, oltre alla relativa libreria asincrona di scelta, e utilizza lo snippet di codice per eseguire la conversione da un Task
.
Gradle (build.gradle
a livello di modulo, in genere 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 }