Send specific request multiple times with different parameters using Retrofit & RxJava

I am not very familiar with Android programing, so sorry if I am missing something and make any mistake, but why don't you pass a reference to the EditText that has been focused to the getNewValue method?

Consider for instance:

private final MutableLiveData<Pair<EditText, String>> newValueResponse = new MutableLiveData<>();
private final MutableLiveData<air<EditText, Throwable>> newValueError = new MutableLiveData<>();

//...

public void getNewValue(final EditText editText, final String currentValue) {
    apiService.getNewValue(currentValue)
            .subscribeOn(Schedulers.io())
            .subscribe(new SingleObserver<String>() {
                @Override
                public void onSubscribe(@NonNull Disposable d) {
                    compositeDisposable.add(d);
                }

                @Override
                public void onSuccess(@NonNull String newValue) {
                    newValueResponse.postValue(Pair.create(editText, newValue));
                }

                @Override
                public void onError(@NonNull Throwable throwable) {
                    newValueError.postValue(Pair.create(editText, throwable));
                }
            });
}

public LiveData<Pair<EditText, String>> getNewValueResponse() {
    return newValueResponse;
}

public LiveData<Pair<EditText, Throwable>> getNewValueError() {
    return newValueError;
}

The OnFocusChangeListener will look like the following:

private View.OnFocusChangeListener getEtFocusChangeListener(String currentValue) {
    return (view, hasFocus) -> {
        if (hasFocus) {
            EditText et = (EditText) v;
            viewModel.getNewValue(et, currentValue);
            viewModel.getNewValueResponse().observe(getViewLifecycleOwner(), newValue -> newValue.first.setText(newValue.second));
            viewModel.getNewValueError().observe(getViewLifecycleOwner(), throwable -> Log.i(TAG, "New Value Error -----> " + throwable.second));
        }
    };
}

In a certain way I found this last code fragment strange, because if you thing about it, due to the asynchronous nature of the API call, the actual result can be for a different EditText. Perhaps the problem could me mitigated with something like that:

private View.OnFocusChangeListener getEtFocusChangeListener(String currentValue) {
    return (view, hasFocus) -> {
        if (hasFocus) {
            EditText et = (EditText) v;
            viewModel.getNewValue(et, currentValue);
            viewModel.getNewValueResponse().observe(getViewLifecycleOwner(), newValue -> {
    // Only perform the operation if the `EditText` is the affected one
    if (et.equals(newValue.first)) {
        newValue.first.setText(newValue.second);
    }
});
            viewModel.getNewValueError().observe(getViewLifecycleOwner(), throwable -> {
    if (et.equals(throwable.first)) {
        Log.i(TAG, "New Value Error -----> " + throwable.second);
    }
});
        }
    };
}

In my opinion, according to the use case, you could get rid of the newValueResponse and newValueError MutableLiveData instances. For example:

public void getNewValue(final EditText editText, final String currentValue) {
    apiService.getNewValue(currentValue)
            .subscribeOn(Schedulers.io())
            .subscribe(new SingleObserver<String>() {
                @Override
                public void onSubscribe(@NonNull Disposable d) {
                    compositeDisposable.add(d);
                }

                @Override
                public void onSuccess(@NonNull String newValue) {
                    editText.seText(newValue);
                }

                @Override
                public void onError(@NonNull Throwable throwable) {
                    Log.i(TAG, "New Value Error -----> " + throwable);
                }
            });
}

And:

private View.OnFocusChangeListener getEtFocusChangeListener(String currentValue) {
    return (view, hasFocus) -> {
        if (hasFocus) {
            EditText et = (EditText) v;
            viewModel.getNewValue(et, currentValue);
        }
    };
}

Or perhaps more semantically:

public void getNewValue(final String currentValue) {
    return apiService.getNewValue(currentValue)
                     .subscribeOn(Schedulers.io());
}

private View.OnFocusChangeListener getEtFocusChangeListener(String currentValue) {
    return (view, hasFocus) -> {
        if (hasFocus) {
            EditText et = (EditText) v;
            viewModel.getNewValue(et, currentValue)
                         .subscribe(new SingleObserver<String>() {
                             @Override
                             public void onSubscribe(@NonNull Disposable d) {
                                 compositeDisposable.add(d);
                             }

                             @Override
                             public void onSuccess(@NonNull String newValue) {
                                 et.seText(newValue);
                             }

                             @Override
                             public void onError(@NonNull Throwable throwable) {
                                 Log.i(TAG, "New Value Error -----> " + throwable);
                             }
                         });
        }
    };
}