ממשק ה-API של Tasks

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

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

השיטה המקובלת להחזרת 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();
        }
    }
});

הברגה

כברירת מחדל, מאזינים המחוברים לשרשור מופעלים בשרשור הראשי של האפליקציה. כשמצרפים מאזינים, אפשר גם לציין 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) {
        // ...
    }
});

שרשרת

אם משתמשים בכמה ממשקי API שמחזירים Task, אפשר לחבר אותם יחד באמצעות המשך. כך תוכלו להימנע מקריאות חוזרות (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.
        // ...
    }
});

חסימה

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

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 לניהול קוד אסינכרוני, וניתן להמיר בקלות Task ל-Pitmits אחרים, כולל ה-Coroutines של ListenableFuture ו-Kotlin, שמומלץ על ידי AndroidX.

הנה דוגמה באמצעות הפונקציה Task:

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

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

Usage

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

מדרג (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.4.1'
build.gradle

קטע קוד

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

גויאבה להאזנה

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

מדרג (build.gradle ברמת המודול, בדרך כלל app/build.gradle)

implementation "androidx.concurrent:concurrent-futures:1.1.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 גלוי

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

מדרג (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 מקור מידע