ChatPresenter.java

/**
 * Listens to user actions and sends data to remote data source.
 * <p>
 * Presenter implements EventListener. Whenever the server sends events
 * to the Repository, it passes those events to the Presenter via EventListener.
 */
public class ChatPresenter implements ChatContract.Presenter {

    @NonNull
    private final BaseSchedulerProvider mSchedulerProvider;

    @NonNull
    private final CompositeDisposable mCompositeDisposable;

    @NonNull
    private final Repository mRepository;

    @NonNull
    private final ChatContract.View mView;

    @NonNull
    private final EventListener mViewEventListener;

    /**
     * Use this constructor to create a new ChatPresenter.
     *
     * @param view              {@link ChatContract.View}
     * @param eventListener     {@link EventListener} listens to server events.
     * @param schedulerProvider {@link BaseSchedulerProvider}
     * @param repository        {@link Repository}
     */
    public ChatPresenter(@NonNull ChatContract.View view,
                         @NonNull EventListener eventListener,
                         @NonNull BaseSchedulerProvider schedulerProvider,
                         @NonNull Repository repository) {
        mView = view;
        mViewEventListener = eventListener;
        mSchedulerProvider = schedulerProvider;
        mRepository = repository;

        // Setting the view's eventListener in the repository so that
        // when server sends events to repository, it passes the
        // events to the view
        mRepository.setEventListener(this);

        mCompositeDisposable = new CompositeDisposable();

        mView.setPresenter(this);
        mView.initView();
    }

    @Override
    public void subscribe() {

    }

    @Override
    public void unsubscribe() {
        mCompositeDisposable.clear();
    }

    @Override
    public void sendMessage(ChatMessage chatMessage) {
        Disposable disposable =
                mRepository.sendMessage(chatMessage)
                        .subscribeOn(mSchedulerProvider.io())
                        .observeOn(mSchedulerProvider.ui())
                        .subscribe(new Consumer<ChatMessage>() {
                            @Override
                            public void accept(ChatMessage chatMessage) throws Exception {
                                mView.onMessageDelivered(chatMessage);
                            }
                        }, new Consumer<Throwable>() {
                            @Override
                            public void accept(Throwable throwable) throws Exception {
                                mView.showAlert(throwable.getMessage(), true);
                            }
                        });

        mCompositeDisposable.add(disposable);
    }

    @Override
    public void onConnect(Object... args) {
        mViewEventListener.onConnect(args);
    }

    @Override
    public void onDisconnect(Object... args) {
        mViewEventListener.onDisconnect(args);
    }

    @Override
    public void onNewMessage(Object... args) {
        mViewEventListener.onNewMessage(args);
    }
}