Le API Task

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 }

Passaggi successivi