Cfrgtkky

I have a BaseViewModel as:

public class BaseViewModel extends ViewModel {



private MutableLiveData<ApiError> apiError = new MutableLiveData<>();

private MutableLiveData<ApiProgress> apiProgress = new MutableLiveData<>();

private CompositeDisposable compositeDisposable = new CompositeDisposable();



// Emit "progress's start" on subscribe and "progress's end" on after success or error.

// Add this to the observable action sequence with ".compose(baseTransformer())" before subscribe.

<T> SingleTransformer<T, T> baseTransformer() {

    return upstream -> upstream

            .doOnSubscribe(disposable -> {

                Log.d("dis", "doOnSubscribe : " + disposable + " " + disposable.isDisposed());

                compositeDisposable.add(disposable);

                apiProgress.setValue(ApiProgress.start());

            })

            .doOnDispose(() -> Log.d("dis", "I am disposed.."))

            .doFinally(() -> apiProgress.setValue(ApiProgress.stop()))

            .doOnError(err -> {

                apiError.setValue(ApiError.create(err));

            });

}



public LiveData<ApiError> getApiError() {

    return apiError;

}



public LiveData<ApiProgress> getApiProgress() {

    return apiProgress;

}



@Override

protected void onCleared() {

    super.onCleared();

    if (!compositeDisposable.isDisposed()) {

        compositeDisposable.dispose();

        Log.d("dis", "compositeDisposable disposed");

    }

}

}

and a LoginViewModel as:

public class LoginViewModel extends BaseViewModel {



Disposable disposable;

private AuthRepository authRepository;

private MutableLiveData<Login> loginData = new MutableLiveData<>();



public LoginViewModel() {

    authRepository = new AuthRepository();

}



public LiveData<Login> getLoginData() {

    return loginData;

}



public void login(String userName, String password) {

    disposable = authRepository.login(userName, password)

            .compose(baseTransformer())

            .subscribe(login -> loginData.setValue(login), err -> {

            });

}



@Override

protected void onCleared() {

    super.onCleared();

    Log.d("dis", "LoginViewModel : " + disposable + " " + disposable.isDisposed());

}

}

I want to dispose the disposable returned by subscribe method but I want to do it in transformation function so, I don''t need to do it every time.

I got following output in Logs:

D/dis: doOnSubscribe : null false

D/dis: compositeDisposable disposed

D/dis: LoginViewModel : 0 false

Please help me in understand: why the disposable not disposed even after compositeDisposable disposed successfully.

I have achieved this goal by adding a new method

<T> void consumeApi(Single<T> apiSingle, Consumer<T> consumer) {

    compositeDisposable.add(apiSingle

            .compose(baseTransformer())

            .subscribe(accept(consumer))

    );

}

in BaseViewModel. Now I just need to call

consumeApi(

            authRepository.login(userName, password),

            login -> loginData.setValue(login)

    );

in LoginViewModel.