UseCases reuse

Here is our FavouriteArticleUseCase:

public final class FavouriteArticleUseCase implements CompletableUseCase<Integer> {

    private final FeedRepository feedRepository;

    public FavouriteArticleUseCase(final FeedRepository feedRepository) {
        this.feedRepository = feedRepository;
    }

    @Override
    public void execute(final Integer articleId, final Callback callback) {
        try {
            feedRepository.favouriteArticle(articleId).await();
            callback.onSuccess();
        } catch (final Throwable throwable) {
            callback.onError(throwable);
        }
    }
}

And here is the usage when we need additional info:

    public void favouriteArticle(final ArticleViewModel article) {
        callbackFavouriteArticleUseCase.execute(article.id,
                                                new CompletableUseCase.Callback() {

                                                    @Override
                                                    public void onSuccess() {
                                                        onFavouriteArticleSuccess(article);
                                                    }

                                                    @Override
                                                    public void onError(final Throwable throwable) {
                                                        onFavouriteArticleError(article, throwable);
                                                    }
                                                });
    }

    private void onFavouriteArticleSuccess(final ArticleViewModel article) {
        // Success
    }

    private void onFavouriteArticleError(final ArticleViewModel article, final Throwable throwable) {
        // Error
    }
    
    
This could get messy quick because now we need to use anonymous callback, so a little helper like this can help us out:

public final class CallbackRelay<P> implements CompletableUseCase.Callback {

    private final P parameter;
    private final Action1<P> successAction;
    private final Action2<P, Throwable> errorAction;

    public CallbackRelay(final P parameter, final Action1<P> successAction, final Action2<P, Throwable> errorAction) {
        this.parameter = parameter;
        this.successAction = successAction;
        this.errorAction = errorAction;
    }

    @Override
    public void onSuccess() {
        successAction.call(parameter);
    }

    @Override
    public void onError(final Throwable throwable) {
        errorAction.call(parameter, throwable);
    }
}

And now our presenter looks a bit nicer:

    public void favouriteArticle(final ArticleViewModel article) {
        callbackFavouriteArticleUseCase.execute(article.id,
                                                new CallbackRelay<>(article,
                                                      this::onFavouriteArticleSuccess,
                                                      this::onFavouriteArticleError));
    }

    private void onFavouriteArticleSuccess(final ArticleViewModel article) {
        // Success
    }

    private void onFavouriteArticleError(final ArticleViewModel article, final Throwable throwable) {
        // Error
    }
    
    
RxJava simplifies this approach a bit:

    public void favouriteArticle(final ArticleViewModel article) {
        favouriteArticleUseCase.execute(article.id)
                               .subscribe(() -> onFavouriteArticleSuccess(article),
                                          throwable -> onFavouriteArticleError(article, throwable));
    }