Le API Task

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
}
MainActivity.kt

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'
build.gradle

Snippet

import kotlinx.coroutines.tasks.await
// ...
  textView.text = simpleTask.await()
}
MainActivity.kt

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"
build.gradle

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)
)
MainActivity.kt

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'
build.gradle

Snippet

import io.ashdavies.rx.rxtasks.toSingle
import java.util.concurrent.TimeUnit
// ...
simpleTask.toSingle(this).subscribe { result -> textView.text = result }
MainActivity.kt

Passaggi successivi

• Task riferimento
• Tasks riferimento