意图有时不会被解雇

Question

I have the following code:

public class CheckoutPresenter extends CheckinOutPresenter {

    @Inject
    public CheckoutPresenter(ThreadExecutor threadExecutor, PostExecutionThread postExecutionThread, OnlineBookingRepository onlineBookingRepository, OfflineBookingRepository offlineBookingRepository, ImageRepository imageRepository) {
        super(threadExecutor, postExecutionThread, onlineBookingRepository, offlineBookingRepository, imageRepository);
    }

    @Override
    protected void bindIntents() {
        Observable<CheckinOutViewState> checkinViewStateObservable =
                intent(CheckinOutView::fetchLocalCheckin)
                        .switchMap(uuid -> offlineBookingRepository.fetchCheckoutById(uuid, false)) <-- Here sometimes get called, sometimes not
                        .subscribeOn(Schedulers.from(threadExecutor))
                        .map(CheckinOutViewState.SuccessLocalFetch::new)
                        .cast(CheckinOutViewState.class)
                        .onErrorReturn(CheckinOutViewState.ErrorStateOut::new)
                        .observeOn(postExecutionThread.getScheduler());

        Observable<CheckinOutViewState> sendCheckin =
                intent(CheckinOutView::sendCheckin)
                        .switchMap(checkinIntent -> imageRepository.saveImage(checkinIntent.getFilename(), checkinIntent.getSignature())
                                .subscribeOn(Schedulers.from(threadExecutor))
                                .filter(cnhImageResponse -> cnhImageResponse.getLinks() != null)
                                .switchMap(response ->  {
                                    CheckinOutCommand command = checkinIntent.getCheckinOutCommand();
                                    command.setSignatureUrlImage(response.getLinks().getUrl());
                                    return onlineBookingRepository.doCheckout(command).subscribeOn(Schedulers.from(threadExecutor));
                                })
                                .subscribeOn(Schedulers.from(threadExecutor))
                                .map(CheckinOutViewState.SentSuccessfuly::new)
                                .cast(CheckinOutViewState.class)
                                .startWith(new CheckinOutViewState.LoadingStateOut())
                                .doOnError(error -> offlineBookingRepository.doCheckout(checkinIntent.getCheckinOutCommand()))
                                .doOnComplete(() -> offlineBookingRepository.deleteCheckoutById(checkinIntent.getCheckinOutCommand().getBookingId(), false))
                                .onErrorReturn(CheckinOutViewState.ErrorStateOut::new))
                        .observeOn(postExecutionThread.getScheduler());

        subscribeViewState(Observable.merge(checkinViewStateObservable, sendCheckin), CheckinOutView::render);
    }

}

which inherits from:

public abstract class CheckinOutPresenter extends MviBasePresenter<CheckinOutView, CheckinOutViewState> {

    protected final ThreadExecutor threadExecutor;
    protected final PostExecutionThread postExecutionThread;
    protected final OnlineBookingRepository onlineBookingRepository;
    protected final OfflineBookingRepository offlineBookingRepository;
    protected final ImageRepository imageRepository;

    CheckinOutPresenter(ThreadExecutor threadExecutor, PostExecutionThread postExecutionThread, OnlineBookingRepository onlineBookingRepository, OfflineBookingRepository offlineBookingRepository, ImageRepository imageRepository) {
        this.threadExecutor = threadExecutor;
        this.postExecutionThread = postExecutionThread;
        this.onlineBookingRepository = onlineBookingRepository;
        this.offlineBookingRepository = offlineBookingRepository;
        this.imageRepository = imageRepository;
    }

}

@Override
    public Observable<String> fetchLocalCheckin() {
        return Observable.just(booking.getBookingId());
    }

But the problem is, sometimes the fetchLocalCheckin is fired, sometimes not. What am I doing wrong here ? Did I miss something ?

Answer 1

@Override
public Observable<String> fetchLocalCheckin() {
     return Observable.just(booking.getBookingId());
}

Observable.just(...) . This one triggers exactly one time onNext() followed immediately by a onComplete() . Since Mosby's MviBasePresenter follows the Reactive contract which basically says that once a onComplete() event is received the whole stream "finishes", that means the CheckinOutView::fetchLocalCheckin only triggers exactly one time and cannot be invoked a second time (because onComplete() already has been triggered).

So if you want to trigger multiple times this intent, don't use Observable.just() but rather PublishSubject or PublishRelay .

ie with your case, this one will only ever trigger the first time your View layer (Fragment, Activity, ViewGroup) has been created, but no second time, ie after screen orientation changes, because the first time it has been created Observale.just() triggers onComplete() which prevents MviBasePresenter from accepting future events.