Tasks API

החל מגרסה 9.0.0 של Google Play Services, ניתן להשתמש ב-API של Task ובמספר שיטות שמחזירות את Task או את מחלקות המשנה שלו. Task הוא API שמייצג קריאות לשיטה אסינכרונית, בדומה ל-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
        // ...
    }
});

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

שרשור

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

שרשור

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

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

חסימה

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

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 ישירות לפרימיטיבים אחרים, כולל ה-Coroutines ListenableFuture ו-Kotlin, שמומלצים על ידי AndroidX.

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

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

קורוטן ב-Kotlin

Usage

צריך להוסיף לפרויקט את התלות הבאה ולהשתמש בקוד הבא כדי להמיר אותו מ-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.4.1'
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.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.

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 הפניות