Tasks API

החל מגרסה 9.0.0 של Google Play Services, אפשר להשתמש ב-API של Task ובמספר שיטות שמחזירות את Task או את תתי-הסוגים שלו. Task הוא ממשק API שמייצג קריאות אסינכרוניות ל-method, בדומה ל-PendingResult בגרסאות קודמות של Google Play Services.

טיפול בתוצאות של משימות

שיטה נפוצה שמחזירה Task היא FirebaseAuth.signInAnonymously(). הפונקציה מחזירה Task<AuthResult>, כלומר המשימה תחזיר אובייקט AuthResult אם היא תסתיים בהצלחה:

Task<AuthResult> task = FirebaseAuth.getInstance().signInAnonymously();

כדי לקבל התראה כשהמשימה תסתיים בהצלחה, צריך לצרף OnSuccessListener:

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

כדי לקבל התראה כשהמשימה נכשלת, צריך לצרף OnFailureListener:

task.addOnFailureListener(new OnFailureListener() {
    @Override
    public void onFailure(@NonNull Exception e) {
        // Task failed with an exception
        // ...
    }
});

כדי לטפל בהצלחה ובכישלון באותו מאזין, צריך לצרף 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();
        }
    }
});

שרשור

כברירת מחדל, מאזינים שמצורפים לשרשור מופעלים בשרשור הראשי (UI) של האפליקציה. כשמחברים מאזין, אפשר גם לציין Executor שמשמש לתזמון המאזינים.

// 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) {
        // ...
    }
});

פונקציות מעקב ברמת הפעילות

אם אתם ממתינים לתוצאות של משימות ב-Activity, כדאי להוסיף למשימה מאזינים ברמת הפעילות. המאזינים האלה יוסרו במהלך השיטה onStop של הפעילות, כדי שהמאזינים לא יישלחו כשהפעילות כבר לא גלויה.

Activity activity = MainActivity.this;
task.addOnCompleteListener(activity, new OnCompleteListener<AuthResult>() {
    @Override
    public void onComplete(@NonNull Task<AuthResult> task) {
        // ...
    }
});

קישור (chaining)

אם אתם משתמשים במספר ממשקי API שמחזירים את הערך Task, תוכלו לשרשר אותם יחד באמצעות המשך (continuation). כך אפשר להימנע מקריאות חזרה (callbacks) בתצוגת עץ עמוקה, ולרכז את טיפול השגיאות ברשתות של משימות.

לדוגמה, השיטה doSomething מחזירה Task<String> אבל דורשת AuthResult, שנקבל באופן אסינכרוני ממשימה:

public Task<String> doSomething(AuthResult authResult) {
    // ...
}

באמצעות השיטה Task.continueWithTask, אפשר לשרשר את שתי המשימות האלה:

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.
        // ...
    }
});

חסימה

אם התוכנית כבר פועלת בשרשור רקע, אפשר לחסום משימה כדי לקבל את התוצאה באופן סינכרוני ולהימנע מקריאות חזרה (callbacks):

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.
    // ...
}

אפשר גם לציין זמן קצוב לתפוגה כשחוסמים משימה, כדי שהאפליקציה לא תתקע:

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.
    // ...
}

יכולת פעולה הדדית

Task תואם מבחינה מושגית לכמה גישות פופולריות לניהול קוד אסינכרוני ב-Android, ואפשר להמיר אותו בקלות לפרימיטיבים אחרים, כולל ListenableFuture ו-coroutines של Kotlin, שמומלצים על ידי AndroidX.Task

דוגמה לשימוש ב-Task:

// ...
simpleTask.addOnCompleteListener(this) {
  completedTask -> textView.text = completedTask.result
}
MainActivity.kt

שגרת המשך (coroutine) ב-Kotlin

שימוש

מוסיפים את התלות הבאה לפרויקט ומשתמשים בקוד שלמטה כדי להמיר מ-Task.

Gradle (build.gradle ברמת המודול, בדרך כלל 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
קטע טקסט
import kotlinx.coroutines.tasks.await
// ...
  textView.text = simpleTask.await()
}
MainActivity.kt

Guava ListenableFuture

מוסיפים את התלות הבאה לפרויקט ומשתמשים בקוד שלמטה כדי להמיר מ-Task.

Gradle (build.gradle ברמת המודול, בדרך כלל app/build.gradle)
implementation "androidx.concurrent:concurrent-futures:1.2.0"
build.gradle
קטע טקסט
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

מוסיפים את התלות הבאה לפרויקט, בנוסף לספרייה האסינכרונית היחסית שבחרתם, ומשתמשים בקוד הבא כדי להמיר מ-Task.

Gradle (build.gradle ברמת המודול, בדרך כלל app/build.gradle)
// Source: https://github.com/ashdavies/rx-tasks
implementation 'io.ashdavies.rx.rxtasks:rx-tasks:2.2.0'
build.gradle
קטע טקסט
import io.ashdavies.rx.rxtasks.toSingle
import java.util.concurrent.TimeUnit
// ...
simpleTask.toSingle(this).subscribe { result -> textView.text = result }
MainActivity.kt

השלבים הבאים