Task API

Task API adalah cara standar untuk menangani operasi asinkron di layanan Google Play. API ini menyediakan cara yang efektif dan fleksibel untuk mengelola panggilan asinkron, menggantikan pola PendingResult yang lebih lama. Dengan Task, Anda dapat menggabungkan beberapa panggilan, menangani alur yang kompleks, dan menulis pengendali keberhasilan dan kegagalan yang jelas.

Menangani hasil tugas

Banyak API di layanan Google Play dan Firebase menampilkan objek Task untuk mewakili operasi asinkron. Misalnya, FirebaseAuth.signInAnonymously() menampilkan Task<AuthResult> yang mewakili hasil operasi login. Task<AuthResult> menunjukkan bahwa saat tugas berhasil diselesaikan, tugas tersebut akan menampilkan objek AuthResult.

Anda dapat menangani hasil Task dengan melampirkan pemroses yang merespons penyelesaian yang berhasil, kegagalan, atau keduanya:

Task<AuthResult> task = FirebaseAuth.getInstance().signInAnonymously();

Untuk menangani penyelesaian tugas yang berhasil, lampirkan OnSuccessListener:

task.addOnSuccessListener(new OnSuccessListener<AuthResult>() {
    @Override
    public void onSuccess(AuthResult authResult) {
        // Task completed successfully
        // ...
    }
});

Untuk menangani tugas yang gagal, lampirkan OnFailureListener:

task.addOnFailureListener(new OnFailureListener() {
    @Override
    public void onFailure(@NonNull Exception e) {
        // Task failed with an exception
        // ...
    }
});

Untuk menangani keberhasilan dan kegagalan dalam pemroses yang sama, lampirkan 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();
        }
    }
});

Mengelola thread

Secara default, pemroses yang dilampirkan ke Task dijalankan di thread utama (UI) aplikasi. Artinya, Anda harus menghindari operasi yang berjalan lama di pemroses. Jika perlu melakukan operasi yang berjalan lama, Anda dapat menentukan Executor yang digunakan untuk menjadwalkan pemroses di thread latar belakang.

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

Menggunakan pemroses cakupan aktivitas

Saat Anda perlu menangani hasil tugas dalam Activity, penting untuk mengelola siklus proses pemroses agar tidak dipanggil saat Activity tidak lagi terlihat. Untuk melakukannya, Anda dapat menggunakan pemroses cakupan aktivitas. Pemroses ini akan otomatis dihapus saat metode onStop dari Activity Anda dipanggil, sehingga tidak akan dieksekusi setelah Activity dihentikan.

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

Tugas berantai

Jika menggunakan kumpulan API yang menampilkan objek Task dalam fungsi yang kompleks, Anda dapat menggabungkannya menggunakan kelanjutan. Hal ini membantu Anda menghindari callback yang sangat bertingkat dan mengonsolidasikan penanganan error untuk beberapa tugas yang digabungkan.

Misalnya, pertimbangkan skenario saat Anda memiliki metode doSomething yang menampilkan Task<String>, tetapi memerlukan AuthResult sebagai parameter. Anda dapat memperoleh AuthResult ini secara asinkron dari Task lain:

public Task<String> doSomething(AuthResult authResult) {
    // ...
}

Dengan menggunakan metode Task.continueWithTask, Anda dapat menggabungkan kedua tugas ini:

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

Memblokir tugas

Jika program Anda sudah dieksekusi di thread latar belakang, Anda dapat memblokir thread saat ini dan menunggu tugas selesai, bukan menggunakan 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.
    // ...
}

Anda juga dapat menentukan waktu tunggu saat memblokir tugas untuk mencegah aplikasi Anda macet tanpa batas waktu jika tugas memerlukan waktu terlalu lama untuk diselesaikan:

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

Interoperabilitas

Task dirancang untuk berfungsi dengan baik dengan pola pemrograman asinkron Android umum lainnya. Tugas ini dapat dikonversi ke dan dari primitif lain seperti ListenableFuture dan coroutine Kotlin, yang direkomendasikan oleh AndroidX, sehingga Anda dapat menggunakan pendekatan yang paling sesuai dengan kebutuhan.

Berikut adalah contoh yang menggunakan Task:

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

Coroutine Kotlin

Untuk menggunakan coroutine Kotlin dengan Task, tambahkan dependensi berikut ke project Anda, lalu gunakan cuplikan kode untuk mengonversi dari Task.

Gradle (level modul build.gradle, biasanya 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'
Cuplikan
import kotlinx.coroutines.tasks.await
// ...
  textView.text = simpleTask.await()
}

ListenableFuture Guava

Untuk menggunakan ListenableFuture Guava dengan Task, tambahkan dependensi berikut ke project Anda, lalu gunakan cuplikan kode untuk mengonversi dari Task.

Gradle (level modul build.gradle, biasanya app/build.gradle)
implementation "androidx.concurrent:concurrent-futures:1.2.0"
Cuplikan
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

Tambahkan dependensi berikut, selain library asinkron relatif pilihan, ke project Anda, lalu gunakan cuplikan kode untuk mengonversi dari Task.

Gradle (level modul build.gradle, biasanya app/build.gradle)
// Source: https://github.com/ashdavies/rx-tasks
implementation 'io.ashdavies.rx.rxtasks:rx-tasks:2.2.0'
Cuplikan
import io.ashdavies.rx.rxtasks.toSingle
import java.util.concurrent.TimeUnit
// ...
simpleTask.toSingle(this).subscribe { result -> textView.text = result }

Langkah berikutnya