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 esito positivo e negativo chiari.

Gestisci 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à, collega un OnSuccessListener:

task.addOnSuccessListener(new OnSuccessListener<AuthResult>() {
    @Override
    public void onSuccess(AuthResult authResult) {
        // Task completed successfully
        // ...
    }
});

Per gestire un'attività non riuscita, collega 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 quello 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();
        }
    }
});

Gestisci i thread

Per impostazione predefinita, i listener collegati a un Task vengono eseguiti nel thread principale (UI) dell'applicazione. Ciò significa che devi evitare di eseguire operazioni a lunga esecuzione nei listener. Se devi eseguire un'operazione a lunga esecuzione, puoi specificare un Executor che viene 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) {
        // ...
    }
});

Utilizza listener con ambito attività

Quando devi gestire i risultati delle attività all'interno di un Activity, è importante gestire il ciclo di vita degli ascoltatori per evitare che vengano chiamati quando 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'arresto di 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 concatenarli utilizzando le continuazioni. In questo modo, eviti callback con nidificazione profonda 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.
        // ...
    }
});

Blocca 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 a tempo indeterminato 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 da e in 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
}

Coroutines 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 un 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, quindi utilizza lo snippet di codice per eseguire la conversione da 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 la seguente dipendenza, oltre alla relativa libreria asincrona di tua scelta, al tuo progetto, quindi utilizza lo snippet di codice per eseguire 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 }

Passaggi successivi