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

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

שרשור

אם משתמשים בכמה ממשקי 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.
        // ...
    }
});

חסימה

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

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

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

קורוטין בקוטלין

שימוש

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

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

מוסיפים את התלות הבאה, בנוסף לספרייה האסינכרונית היחסית של לפרויקט שלך, ולהשתמש בקוד שבהמשך כדי להמיר מ-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