how we can handle, if it is multiple usecase called? about flutter_clean_architecture HOT 4 CLOSED

private final ThreadExecutor mExecutor;
private final PostExecutor mPostExecutor;
private final CompositeDisposable mDisposable;
private AndroObserver<T> mObserver;
private PublishRelay<Long> mTrigger;

public UseCase(ThreadExecutor executor, PostExecutor postExecution) {
    this.mExecutor = executor;
    this.mPostExecutor = postExecution;
    this.mDisposable = new CompositeDisposable();
    this.mTrigger = PublishRelay.create();
}

/**
 * Builds an {@link Observable} which will be used when executing the current {@link UseCase}.
 */
public abstract Observable<T> buildUseCaseObservable(Params params);

/**
 * Executes the current use case.
 *
 * @param observer {@link DisposableObserver} which will be listening to the observable build
 *                 by {@link #buildUseCaseObservable(Params)} ()} method.
 * @param params   Parameters (Optional) used to build/execute this use case.
 */
public void execute(AndroObserver<T> observer, Params params) {
    mObserver = observer;
    mDisposable.clear();
    addDisposable(this.buildUseCaseObservable(params)
            .subscribeOn(Schedulers.from(mExecutor))
            .observeOn(mPostExecutor.getScheduler())
            .doOnError(error -> {
                if (error instanceof HttpException)
                    mObserver.onRetry("Something went wrong,Please try again.", error, mTrigger);
            })
            .retryWhen(errors -> errors.flatMap((Function<Throwable, ObservableSource<?>>) error -> {
                if (error instanceof HttpException)
                    return mTrigger;
                else
                    return Observable.error(error);
            }))
            .subscribeWith(observer));
}

/**
 * Dispose from current {@link CompositeDisposable}.
 */
public void dispose() {
    if (!mDisposable.isDisposed()) {
        mDisposable.dispose();
    }
}

/**
 * Dispose from current {@link CompositeDisposable}.
 */
private void addDisposable(Disposable disposable) {
    mDisposable.add(disposable);
}

public AndroObserver<T> getObserver() {
    return mObserver;
}

public void setObserver(AndroObserver<T> observer) {
    mObserver = observer;
}