Ab Version 9.0.0 der Google Play-Dienste können Sie eine Task API und eine Reihe von Methoden verwenden, die Task oder dessen Unterklassen zurückgeben. Task ist eine API, die asynchrone Methodenaufrufe darstellt, ähnlich wie PendingResult in früheren Versionen von Google Play-Diensten.
Aufgabenergebnisse verarbeiten
Eine gängige Methode, mit der ein Task zurückgegeben wird, ist FirebaseAuth.signInAnonymously().
Es gibt eine Task<AuthResult> zurück. Dies bedeutet, dass die Aufgabe bei erfolgreicher Ausführung ein AuthResult-Objekt zurückgibt:
Task<AuthResult> task = FirebaseAuth.getInstance().signInAnonymously();
Hängen Sie ein OnSuccessListener an, damit Sie benachrichtigt werden, wenn die Aufgabe erfolgreich abgeschlossen wurde:
task.addOnSuccessListener(new OnSuccessListener<AuthResult>() {
@Override
public void onSuccess(AuthResult authResult) {
// Task completed successfully
// ...
}
});
Hängen Sie ein OnFailureListener an, damit Sie benachrichtigt werden, wenn die Aufgabe fehlschlägt:
task.addOnFailureListener(new OnFailureListener() {
@Override
public void onFailure(@NonNull Exception e) {
// Task failed with an exception
// ...
}
});
Hängen Sie ein OnCompleteListener an, um Erfolg und Fehler im selben Listener zu verarbeiten:
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();
}
}
});
Haarentfernung mit Faden
An einen Thread angehängte Listener werden standardmäßig im Hauptthread der Anwendung (UI) ausgeführt. Wenn Sie einen Listener anhängen, können Sie auch ein Executor angeben, das zum Planen von Listenern verwendet wird.
// 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) {
// ...
}
});
Aktivitätsbezogene Listener
Wenn Sie Aufgabenergebnisse in einem Activity beobachten, möchten Sie der Aufgabe möglicherweise Aktivitäts-Listener hinzufügen. Diese Listener werden während der Methode onStop Ihrer Aktivität entfernt, sodass Ihre Listener nicht aufgerufen werden, wenn die Aktivität nicht mehr sichtbar ist.
Activity activity = MainActivity.this;
task.addOnCompleteListener(activity, new OnCompleteListener<AuthResult>() {
@Override
public void onComplete(@NonNull Task<AuthResult> task) {
// ...
}
});
Verketten
Wenn Sie mehrere APIs verwenden, die Task zurückgeben, können Sie sie mithilfe einer Fortsetzung verketten. Dadurch werden tief verschachtelte Callbacks vermieden und die Fehlerbehandlung für Aufgabenketten konsolidiert.
Die Methode doSomething gibt beispielsweise ein Task<String> zurück, erfordert jedoch einen AuthResult, den wir asynchron von einer Aufgabe erhalten:
public Task<String> doSomething(AuthResult authResult) {
// ...
}
Mit der Methode Task.continueWithTask können wir 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.
// ...
}
});
Optionen zum Blockieren von Inhalten
Wenn Ihr Programm bereits in einem Hintergrundthread ausgeführt wird, können Sie eine Aufgabe blockieren, um das Ergebnis synchron abzurufen und Callbacks zu vermeiden:
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 beim Blockieren einer Aufgabe ein Zeitlimit festlegen, damit Ihre Anwendung nicht hängen bleibt:
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 lässt sich konzeptionell auf verschiedene gängige Android-Ansätze zur Verwaltung von asynchronem Code abstimmen. Ein Task kann problemlos in andere Primitive, einschließlich der von Android X empfohlenen ListenableFuture- und Kotlin-Koroutinen, konvertiert werden.
Hier ein Beispiel mit Task:
// ...
simpleTask.addOnCompleteListener(this) {
completedTask -> textView.text = completedTask.result
}
Kotlin Coroutine
Nutzung
Fügen Sie Ihrem Projekt die folgende Abhängigkeit hinzu und verwenden Sie den folgenden Code, um aus einem Task zu konvertieren.
Gradle (Modulebene build.gradle, normalerweise 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.4.1'
Snippet
import kotlinx.coroutines.tasks.await // ... textView.text = simpleTask.await() }
Guava – ListenableFuture
Fügen Sie Ihrem Projekt die folgende Abhängigkeit hinzu und verwenden Sie den folgenden Code, um aus einem Task zu konvertieren.
Gradle (Modulebene build.gradle, normalerweise app/build.gradle)
implementation "androidx.concurrent:concurrent-futures:1.1.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 – beobachtbar
Fügen Sie zusätzlich zur relativen asynchronen Bibliothek Ihrer Wahl die folgende Abhängigkeit hinzu und verwenden Sie den folgenden Code, um aus einem Task zu konvertieren.
Gradle (Modulebene build.gradle, normalerweise 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 }