Görev API'leri

Task API, Google Play Hizmetleri'nde eşzamansız işlemleri yönetmenin standart yoludur. Eski PendingResult kalıbının yerini alan bu özellik, eşzamansız çağrıları yönetmek için güçlü ve esnek bir yöntem sunar. Task ile birden fazla çağrıyı zincirleyebilir, karmaşık akışları yönetebilir ve net başarı ve hata işleyicileri yazabilirsiniz.

Görev sonuçlarını işleme

Google Play Hizmetleri ve Firebase'deki birçok API, eşzamansız işlemleri temsil etmek için Task nesnesi döndürür. Örneğin, FirebaseAuth.signInAnonymously() oturum açma işleminin sonucunu temsil eden bir Task<AuthResult> döndürür. Task<AuthResult>, görev başarıyla tamamlandığında AuthResult nesnesinin döndürüleceğini gösterir.

Başarılı tamamlama, başarısızlık veya her ikisine de yanıt veren dinleyiciler ekleyerek Task sonucunu işleyebilirsiniz:

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

Görevin başarılı bir şekilde tamamlanmasını sağlamak için OnSuccessListener ekleyin:

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

Başarısız olan bir görevi işlemek için OnFailureListener ekleyin:

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

Hem başarıyı hem de başarısızlığı aynı dinleyicide işlemek için OnCompleteListener ekleyin:

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();
        }
    }
});

İleti dizilerini yönetme

Varsayılan olarak, Task öğesine eklenen dinleyiciler uygulamanın ana (UI) iş parçacığında çalıştırılır. Bu nedenle, uzun süren işlemleri dinleyicilerde yapmaktan kaçınmalısınız. Uzun süren bir işlem yapmanız gerekiyorsa arka plan iş parçacığında dinleyicileri planlamak için kullanılan bir Executor belirtebilirsiniz.

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

Etkinlik kapsamlı işleyiciler kullanma

Görev sonuçlarını bir Activity içinde işlemeniz gerektiğinde, Activity görünür durumda değilken dinleyicilerin çağrılmasını önlemek için dinleyicilerin yaşam döngüsünü yönetmeniz önemlidir. Bunu yapmak için etkinlik kapsamlı dinleyicileri kullanabilirsiniz. Bu dinleyiciler, onStop yönteminiz Activity çağrıldığında otomatik olarak kaldırılır. Böylece, Activity durdurulduktan sonra yürütülmezler.

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

Zincir görevler

Karmaşık bir işlevde Task nesneleri döndüren bir API grubu kullanıyorsanız devamlılıkları kullanarak bunları birbirine bağlayabilirsiniz. Bu, iç içe yerleştirilmiş geri çağırmaları önlemenize yardımcı olur ve birden fazla zincirlenmiş görev için hata işlemeyi birleştirir.

Örneğin, Task<String> döndüren ancak parametre olarak AuthResult gerektiren bir doSomething yönteminiz olduğunu düşünün. Bu AuthResult öğesini başka bir Task öğesinden eşzamansız olarak alabilirsiniz:

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

Task.continueWithTask yöntemini kullanarak bu iki görevi zincirleyebilirsiniz:

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

Görevi engelleme

Programınız zaten arka plan iş parçacığında yürütülüyorsa geri çağırma kullanmak yerine mevcut iş parçacığını engelleyebilir ve görevin tamamlanmasını bekleyebilirsiniz:

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

Bir görevi engellerken, görevin tamamlanması çok uzun sürerse uygulamanızın süresiz olarak takılmasını önlemek için bir zaman aşımı da belirtebilirsiniz:

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

Birlikte çalışabilirlik

Task, diğer yaygın Android eşzamansız programlama kalıplarıyla iyi çalışacak şekilde tasarlanmıştır. ListenableFuture ve Kotlin eşzamanlı rutinleri gibi diğer temel öğelere dönüştürülebilir ve bu öğelerden dönüştürülebilir. Bu öğeler, AndroidX tarafından önerilir ve ihtiyaçlarınıza en uygun yaklaşımı kullanmanıza olanak tanır.

Task kullanan bir örneği aşağıda bulabilirsiniz:

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

Kotlin eş yordamı

Task ile Kotlin eş yordamlarını kullanmak için projenize aşağıdaki bağımlılığı ekleyin ve ardından Task öğesinden dönüştürmek için kod snippet'ini kullanın.

Gradle (modül düzeyinde build.gradle, genellikle 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

Snippet

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

Guava ListenableFuture

Guava ListenableFuture ile Task kullanmak için projenize aşağıdaki bağımlılığı ekleyin ve ardından Task öğesinden dönüştürmek için kod snippet'ini kullanın.

Gradle (modül düzeyinde build.gradle, genellikle app/build.gradle)

implementation "androidx.concurrent:concurrent-futures:1.2.0"
build.gradle

Snippet

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

Seçtiğiniz göreceli asenkron kitaplığa ek olarak aşağıdaki bağımlılığı projenize ekleyin ve ardından Task öğesinden dönüştürmek için kod snippet'ini kullanın.

Gradle (modül düzeyinde build.gradle, genellikle app/build.gradle)

// Source: https://github.com/ashdavies/rx-tasks
implementation 'io.ashdavies.rx.rxtasks:rx-tasks:2.2.0'
build.gradle

Snippet

import io.ashdavies.rx.rxtasks.toSingle
import java.util.concurrent.TimeUnit
// ...
simpleTask.toSingle(this).subscribe { result -> textView.text = result }
MainActivity.kt

Sonraki adımlar

• Task referans
• Tasks referans