ActionChain

ActionChain makes bouncing between the main thread and background threads much:

• Easier
• Cleaner
• Safer
• More easily tested

and allows for much more code-reuse. It may help you in other ways, in which case: please share!

Usage

Add to your project dependencies:

compile 'com.lemnik:action-chain:0.1.1'

ActionCommand with lambda's can be used exactly like this:

import static com.lemnik.actionchain.ActionCommand.onBackground;
import static com.lemnik.actionchain.ActionCommand.onForeground;

// ...

onBackground((name) -> "Hello <b>" + name + "</b>")
.then(onBackground((msg) -> Html.fromHtml(msg)))
.then(onForeground((msg) -> {
    Toast.makeText(this, msg, Toast.LENGTH_LONG).show();
}))
.exec("Jason");

You can also capture an Action chain to be executed later:

private final ActionCommand.Chain<User, User> saveUser =
    new SaveLocalUserCommand()
    .then(new UploadUserCommand())
    .then(onForeground((user) -> {
        setUser(user);
    });

Thread-hopping Chain-of-Command

Action chains follow something like the chain-of-commands pattern (also known as chain-of-responsibility). In this case however:

• Aach command (ActionCommand) has a function that runs on a "background" thread (typically stolen from AsyncTask under the hood).
• The background function takes an input open (optionally) and produces an output object
• The output object is handed to a foreground consumer that runs on the main thread
• The output object is passed as the input for the next ActionCommand in the chain

Exceptions cause the entire chain to go into an error state, which by-default is a "pass forward" behaviour Errors are always handled on the main thread, so it's something you can simply attach to the end of your chain:

onBackground((name) -> "Hello <b>" + name + "</b>")
.then(onBackground((msg) -> Html.fromHtml(msg)))
.then(onForeground((msg) -> {
    Toast.makeText(this, msg, Toast.LENGTH_LONG).show();
}))
.then(onError(exception) -> {
    handleError(exception);
});

Usage Patterns

In case you don't have Java 8 (or lambdas of some other form) enabled for your Android project, Action chains can be implemented as ActionCommand classes instead (which is how they work under-the-hood anyway). These are also useful when you just want to encapsulate some logic in a way this easy to reuse, unit test, etc.

public class SaveUserCommand extends ActionCommand<User, User> {
    private final Database database;

    public SaveUserCommand(final Database database) {
        this.database = database;
    }

    public User save(final User user) {
        final long databaseId = database.save(user);
        return user.builder()
                   .setId(databaseId)
                   .build();
    }
}

These can then be used as:

public void onClick(View saveAndClose) {
    new SaveUserCommand(database)
        .then(SendUserToServer.INSTANCE)
        .then(new FinishActivity(this))
        .exec(userEditor.build());
}