Die Task
API ist die Standardmethode für die Verarbeitung asynchroner Vorgänge in Google Play-Diensten. Es bietet eine leistungsstarke und flexible Möglichkeit zum Verwalten asynchroner Aufrufe und ersetzt das ältere PendingResult
-Muster. Mit Task
können Sie mehrere Aufrufe verketten, komplexe Abläufe verarbeiten und klare Handler für den Erfolg und den Fehlerfall schreiben.
Aufgabenergebnisse verarbeiten
Viele APIs in den Google Play-Diensten und Firebase geben ein Task
-Objekt zurück, um asynchrone Vorgänge darzustellen. Beispiel: FirebaseAuth.signInAnonymously()
gibt ein Task<AuthResult>
zurück, das das Ergebnis des Anmeldevorgangs darstellt. Das Task<AuthResult>
gibt an, dass nach erfolgreichem Abschluss der Aufgabe ein AuthResult
-Objekt zurückgegeben wird.
Du kannst das Ergebnis eines Task
verarbeiten, indem du Listener anfügst, die auf einen erfolgreichen Abschluss, einen Fehler oder beides reagieren:
Task<AuthResult> task = FirebaseAuth.getInstance().signInAnonymously();
Wenn eine Aufgabe abgeschlossen wurde, fügen Sie eine OnSuccessListener
an:
task.addOnSuccessListener(new OnSuccessListener<AuthResult>() { @Override public void onSuccess(AuthResult authResult) { // Task completed successfully // ... } });
Wenn Sie eine fehlgeschlagene Aufgabe bearbeiten möchten, fügen Sie eine OnFailureListener
hinzu:
task.addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { // Task failed with an exception // ... } });
Wenn Sie sowohl den Erfolg als auch den Fehler im selben Listener behandeln möchten, fügen Sie eine OnCompleteListener
hinzu:
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(); } } });
Threads verwalten
Standardmäßig werden Listener, die an eine Task
angehängt sind, im Haupt-UI-Thread der Anwendung ausgeführt. Daher sollten Sie in Listeners keine Vorgänge mit langer Ausführungszeit ausführen. Wenn Sie einen langwierigen Vorgang ausführen müssen, können Sie eine Executor
angeben, mit der Listener in einem Hintergrund-Thread geplant werden.
// 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) { // ... } });
Listener auf Aktivitätsebene verwenden
Wenn Sie Aufgabenergebnisse in einem Activity
verarbeiten müssen, ist es wichtig, den Lebenszyklus der Listener zu verwalten, damit sie nicht aufgerufen werden, wenn das Activity
nicht mehr sichtbar ist. Dazu können Sie Listener auf Aktivitätsebene verwenden. Diese Listener werden automatisch entfernt, wenn die onStop
-Methode deiner Activity
aufgerufen wird, damit sie nicht ausgeführt werden, nachdem die Activity
beendet wurde.
Activity activity = MainActivity.this; task.addOnCompleteListener(activity, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { // ... } });
Aufgaben verketten
Wenn Sie mehrere APIs verwenden, die Task
-Objekte in einer komplexen Funktion zurückgeben, können Sie sie mithilfe von Fortsetzungen verketten. So lassen sich tief verschachtelte Callbacks vermeiden und die Fehlerbehandlung für mehrere verkettete Aufgaben konsolidieren.
Angenommen, Sie haben eine Methode doSomething
, die eine Task<String>
zurückgibt, aber einen AuthResult
als Parameter erfordert.
Sie können diese AuthResult
asynchron von einer anderen Task
abrufen:
public Task<String> doSomething(AuthResult authResult) { // ... }
Mit der Methode Task.continueWithTask
können Sie diese beiden Aufgaben verketten:
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. // ... } });
Aufgabe blockieren
Wenn Ihr Programm bereits in einem Hintergrund-Thread ausgeführt wird, können Sie den aktuellen Thread sperren und auf den Abschluss der Aufgabe warten, anstatt einen Callback zu verwenden:
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. // ... }
Sie können auch ein Zeitlimit angeben, wenn Sie eine Aufgabe blockieren, um zu verhindern, dass Ihre Anwendung unbegrenzt lang inaktiv bleibt, wenn die Aufgabe zu lange dauert:
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ät
Task
ist so konzipiert, dass es gut mit anderen gängigen asynchronen Programmiermustern von Android funktioniert. Sie können in andere Primitive wie ListenableFuture
und Kotlin-Coroutinen konvertiert werden, die von AndroidX empfohlen werden. So können Sie den Ansatz verwenden, der Ihren Anforderungen am besten entspricht.
Hier ein Beispiel mit einem Task
:
// ... simpleTask.addOnCompleteListener(this) { completedTask -> textView.text = completedTask.result }
Kotlin-Koroutine
Wenn Sie Kotlin-Coroutinen mit Task
verwenden möchten, fügen Sie Ihrem Projekt die folgende Abhängigkeit hinzu und verwenden Sie dann das Code-Snippet, um von einer Task
zu konvertieren.
Gradle (build.gradle
auf Modulebene, in der Regel 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
Wenn Sie Guava ListenableFuture
mit Task
verwenden möchten, fügen Sie Ihrem Projekt die folgende Abhängigkeit hinzu und verwenden Sie dann das Code-Snippet, um von einem Task
zu konvertieren.
Gradle (build.gradle
auf Modulebene, in der Regel 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
Fügen Sie Ihrem Projekt zusätzlich zur gewünschten relativen asynchronen Bibliothek die folgende Abhängigkeit hinzu und verwenden Sie dann das Code-Snippet, um von einem Task
zu konvertieren.
Gradle (build.gradle
auf Modulebene, in der Regel 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 }