Android developer portal with tools, libraries, and apps

The easy asynchronous library for Kotlin. With extensions for Android, RxJava, JavaFX and much more.

This library helps with sequential tasks that will be run one after another and only when each task is finished. These tasks can either be UI or background.

Utility library of concurrent execution strategies for JVM and Android.

• Inspired by async for JavaScript and Node.js.
• Execute collection iterators and control flow strategies concurrently in the background.
• Callbacks are notified when strategies are complete, cancelled, or error out.
• Android extensions execute final callbacks on the UI thread.

Reactive Bolts-Android(powered by parse and facebook) allows to convert Task<T> to Observable<T>.

Chain of Command with background foreground options. Chains can be pre-constructed, and reused any number of times. Individual commands can be written as lambdas, or as classes.

Annotation-triggered method call by specified thread.

• Eliminate runOnUiThread calls by using @OnUi on method.
• Make background logic more clear by using @OnBackground on method.

Improved AsyncQueryHandler that supports Bulk Insert operation

Makes it easy to put your asynchronous operations behind Android's Loader.

Simple threading library using annotations for Android. This library makes it very easier to do any task on any thread. You can simply annotate a method to execute on any particular task and you are ready to go.

Android library to easily queue background and UI tasks.

So what does it exactly do?

If you are working on Android you probably have ended up using AsyncTasks to do background tasks and then have a response on the UI Thread. Well, author confesses: "I HATE ASYNCTASKS".

Are you sad to create every time the ThreadPool and MainThread to be exposed with Dagger to the application? If yes, you can use this library to reduce your work.

A small Android library to handle Async Task methods. Use Interface Segregation Principle to divide the actions into individual callbacks.

An Android task queue library. Support priority, timeout, multiple queue and auto-retry.

Immediately executable LooperScheduler. Supports RxJava 2.x and 1.x.

This library allows to use better multi-threading approach with observer-pattern.

LiteGo is a Java-based asynchronous concurrency library.

AWEX (Android Work EXecutor) is a thread pool to execute tasks that uses Promises to deliver results. Promises that can be cancelled, can be combined or even can process collections in parallel automatically.

A tiny Android library to create async background tasks. Highly inspired by NanoTasks, but with a funnier API.

AndroidOperationQueue is tiny serial operation queue for Android Development.

AndroidChannel is helper library for inter thread communication between main thread and worker thread. AndroidChannel uses HandlerThread for inter thread communication.

Satellite is a simple (for those who are familiar with RxJava) Android library, which allows to properly connect background tasks with visual parts of an application.

FromTo is a helper library that makes it simple to handle asynchronous actions with views for Android and Java/Kotlin.

Asynchronous Workers and Worker Managers for Android.

Futuroid is an Android library that allows running asynchronous tasks and attaching callbacks thanks to a convenient syntax. It offers an alternative to the Android AsyncTask class.

Features:

• Future-based API (similar to Guava's ListenableFutures, Scala/Akka Futures, Javascript promises...)
• Allows registering callbacks to be run on the Android UI/main thread
• Provides a default ExecutorService (fixed thread pool with 5 threads) that can be replaced by a custom one
• Each task can be run on the default ExecutorService or on a custom one
• Allows task chaining (monad-style)

AsyncManager hopes to keep management of background threads as simple as possible, by keeping the creation and termination of background tasks to just one API call respectively. Callback, which will be processed on the UI thread, can be overridden to process the result returned from the background operation.

Small Android library for use the Interactor (use case) and Executor for running code on a ThreadPool Thread or UI Thread. Normally this library is used for implement the Clean Architecture.

android-asyncservice manages threading and caching transparently in your Android app.

It's an alternative to AsyncTasks, Loaders, or more advanced libs like RxJava, Robospice, Groundy, … but AsyncService focuses on keeping your code short and simple!

Android lifecycle safety task with sugar code style.

android-deferred-object is a chainable utility object that can register multiple callbacks into callback queues, invoke callback queues, and relay the success or failure state of any synchronous or asynchronous function.

Coordinator is a Java library that is used to coordinate various asynchronous actions. Usually we found cases that you need to check if other thread is completed to execute an action, coordinator solves this problem without using flags.