ממשקי ה-API של Tasks

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

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

הרבה ממשקי API ב-Google Play Services וב-Firebase מחזירים אובייקט Task כדי לייצג פעולות אסינכרוניות. לדוגמה, FirebaseAuth.signInAnonymously() מחזיר Task<AuthResult> שמייצג את התוצאה של פעולת הכניסה. החלק Task<AuthResult> מציין שכשהמשימה תושלם בהצלחה, היא תחזיר אובייקט AuthResult.

כדי לטפל בתוצאה של Task, אפשר לצרף מאזינים שמגיבים להשלמה מוצלחת, לכישלון או לשניהם:

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();
        }
    }
});

ניהול שרשורים

כברירת מחדל, מאזינים שמצורפים ל-Task פועלים בשרשור הראשי (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, חשוב לנהל את מחזור החיים של המאזינים כדי למנוע את הקריאה להם כש-Activity כבר לא גלוי. כדי לעשות את זה, אפשר להשתמש במאזינים ברמת הפעילות. המאזינים האלה מוסרים באופן אוטומטי כשמתבצעת קריאה ל-method‏ onStop של Activity, כדי שהם לא יופעלו אחרי ש-Activity נעצר.

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

שרשור משימות

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

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

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

חסימת משימה

אם התוכנית כבר פועלת בשרשור ברקע, אפשר לחסום את השרשור הנוכחי ולהמתין להשלמת המשימה, במקום להשתמש בקריאה חוזרת (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.
    // ...
}

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

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:

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

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

כדי להשתמש ב-coroutines של Kotlin עם Task, מוסיפים את יחסי התלות הבאים לפרויקט ואז משתמשים בקטע הקוד כדי להמיר מ-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'
קטע טקסט
import kotlinx.coroutines.tasks.await
// ...
  textView.text = simpleTask.await()
}

גויאבה ListenableFuture

כדי להשתמש ב-Guava ListenableFuture עם Task, צריך להוסיף את התלות הבאה לפרויקט ואז להשתמש בקטע הקוד כדי להמיר מ-Task.

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

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

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

השלבים הבאים