ממשקי ה-API של Tasks

ממשק Task API הוא הדרך הרגילה לטפל בפעולות אסינכרוניות בשירותי Google Play. הוא מספק דרך יעילה וגמישה לנהל קריאות אסינכרוניות, ומחליף את התבנית הישנה יותר 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 מופעלים בשרשור הראשי (ממשק המשתמש) של האפליקציה. המשמעות היא שצריך להימנע מביצוע פעולות ארוכות טווח ב-listeners. אם אתם צריכים לבצע פעולה ארוכת טווח, אתם יכולים לציין 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) {
        // ...
    }
});

שימוש בפונקציות event listener בהיקף פעילות

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

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

משימות ברשת

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

לדוגמה, נניח שיש לכם 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.
        // ...
    }
});

חסימת משימה

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

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 וקורוטינות של Kotlin, ולהיפך. מומלץ להשתמש ב-AndroidX, כדי שתוכלו לבחור את הגישה שהכי מתאימה לצרכים שלכם.

לדוגמה, אם משתמשים ב-Task:

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

שגרת המשך (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'
build.gradle

קטע טקסט

import kotlinx.coroutines.tasks.await
// ...
  textView.text = simpleTask.await()
}
MainActivity.kt

גויאבה ListenableFuture

כדי להשתמש ב-Guava ListenableFuture עם Task, מוסיפים את התלות הבאה לפרויקט ואז משתמשים בקטע הקוד כדי להמיר מ-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

השלבים הבאים

• Task מידע נוסף
• Tasks מידע נוסף