Vfrdtyky

I would like to implement ProgressBar for my server delay.

I am based on :

Consuming REST API using Retrofit Library with the help of MVVM, Dagger 2, LiveData and RxJava 2 in Android

https://medium.com/@saquib3705/consuming-rest-api-using-retrofit-library-with-the-help-of-mvvm-dagger-livedata-and-rxjava2-in-67aebefe031d

I do some work but I have several issue (LogCat at bottom)

my code (edited - full view in my ViewModel Class)

public class ViewModelApp extends ViewModel {



    //services

    private ServiceItune serviceItune;

    private ServiceLastFm serviceLastFm;



    @Inject

    @Named("apiLastFm")

    Retrofit apiLastFm;



    @Inject

    @Named("apiItune")

    Retrofit apiItune;





    // Rx

    private final CompositeDisposable disposables = new CompositeDisposable();

    Disposable disposable;



    // LifeData

    private MutableLiveData<ApiResponse> responseLiveDataCombinedResult;



    public MutableLiveData<ApiResponse> getResponseLiveDataCombinedResult () {



        if (responseLiveDataCombinedResult == null){

            responseLiveDataCombinedResult = new MutableLiveData<ApiResponse>();

        }

        return responseLiveDataCombinedResult;

    }



    // Constructor

    public ViewModelApp() {



        MainApplication.component.inject(this);

        serviceItune = apiItune.create(ServiceItune.class);

        serviceLastFm = apiLastFm.create(ServiceLastFm.class);

        getAll("");



    }



    public Observable getMergedObservable (String query) {



        Observable<RootiTune> iTuneObservable =serviceItune.getItuneArtistNameRx2NoList(ServiceItune.API_ITUNE_BASE_FULL_URL,query);

        Observable <RootLastFm>  lastFmObservable = serviceLastFm.searchArtistRx(ServiceLastFm.API_LAST_FM_FULL_URL, query, ServiceLastFm.KEY_LAST_FM,"json");



        return iTuneObservable.flatMap((Function<RootiTune, ObservableSource<CombinedResult>>)

                rootiTune -> {

                    return Observable.just(rootiTune).zipWith(lastFmObservable,

                            (rootiTune1, rootLastFm) -> new CombinedResult(rootiTune1, rootLastFm));

                });

    }



    public void getAll (String query){



        disposables.add(getMergedObservable(query)

                .subscribeOn(Schedulers.io())

                .observeOn(AndroidSchedulers.mainThread())

                //  do something (update the UI) before the task started

                .doOnSubscribe(new Consumer<Disposable>() {

                    @Override

                    public void accept(Disposable disposable) throws Exception {

                        responseLiveDataCombinedResult.setValue(ApiResponse.loading());

                        Log.v("Disposablevariable ",disposable.toString());

                    }

                })

                .subscribe((Consumer<CombinedResult>) combinedResult -> responseLiveDataCombinedResult.setValue(ApiResponse.success(combinedResult))

                        ,(Consumer<Throwable>)throwable -> responseLiveDataCombinedResult.setValue(ApiResponse.error(throwable))

                )

        );

    }



    @Override

    protected void onCleared() {

        disposables.clear();

    }

}

+

    public class ApiResponse {



        public final Status status;



        @Nullable

        public final CombinedResult combinedResult;



        @Nullable

        public final Throwable error;



        private ApiResponse(Status status, @Nullable CombinedResult combinedResult, @Nullable Throwable error) {

            this.status = status;

            this.combinedResult = combinedResult;

            this.error = error;

        }



        public static ApiResponse loading() {



            return new ApiResponse(LOADING, null, null);

        }



        public static ApiResponse success(@NonNull CombinedResult combinedResult) {

            return new ApiResponse(SUCCESS, combinedResult, null);

        }



        public static ApiResponse error(@NonNull Throwable error) {

            return new ApiResponse(ERROR, null, error);

        }



    }

my http client:

@Provides

@Singleton

public OkHttpClient okHttpClient(HttpLoggingInterceptor loggingInterceptor) {





    return new OkHttpClient.Builder()

            .addInterceptor(loggingInterceptor)

            .addInterceptor(chain -> {

                Request original = chain.request();

                Request request = original.newBuilder()

                        .build();

                return chain.proceed(request);

            })

            .connectTimeout(100, TimeUnit.SECONDS)

            .readTimeout(300, TimeUnit.SECONDS)

            .build();

}

and finally:

class MainListFragment



   public void onActivityCreated(@Nullable Bundle savedInstanceState) {

        super.onActivityCreated(savedInstanceState);



        viewModel =

                ViewModelProviders

                .of(getActivity())

                .get(ViewModelApp.class);



        observeViewModel(viewModel);

    }



    private void observeViewModel(ViewModelApp viewModelAppe) {



        viewModelAppe.getResponseLiveDataCombinedResult().observe(getActivity(), this::consumeResponse);



    }



    private void consumeResponse(ApiResponse apiResponse) {



        switch (apiResponse.status){



            case LOADING:



                progressDialog.show();

                break;



            case SUCCESS:

                progressDialog.dismiss();

                if (apiResponse.combinedResult.getArtistsWithPhoto() != null){

                    mainAdapter.setProjectList(apiResponse.combinedResult.getArtistsWithPhoto());

                    combinedLocalResult = apiResponse.combinedResult;

                }





            case ERROR:

                if (!Constant.checkInternetConnection(getActivity())) {

                    progressDialog.dismiss();

                    Toast.makeText(getActivity(), getResources().getString(R.string.errorString), Toast.LENGTH_SHORT).show();

                }

            default:



                break;

        }



    }

my LogCat:

 Attempt to invoke virtual method 'void android.arch.lifecycle.MutableLiveData.setValue(java.lang.Object)' on a null object reference

To resolve that problem you need to initialize responseLiveDataCombinedResult variable inside ViewModelApp. You can do it like that

private MutableLiveData<ApiResponse> responseLiveDataCombinedResult = new MutableLiveData<ApiResponse>();

or if you don't want do it for some reason, you need access that live data variable through call of getResponseLiveDataCombinedResult().

public void getAll (String query){



    disposables.add(getMergedObservable(query)

            .subscribeOn(Schedulers.io())

            .observeOn(AndroidSchedulers.mainThread())

            //  do something (update the UI) before the task started

            .doOnSubscribe(new Consumer<Disposable>() {

                @Override

                public void accept(Disposable disposable) throws Exception {

                    getResponseLiveDataCombinedResult().setValue(ApiResponse.loading());

                    Log.v("Disposablevariable ",disposable.toString());

                }

            })

            .subscribe((Consumer<CombinedResult>) combinedResult -> getResponseLiveDataCombinedResult().setValue(ApiResponse.success(combinedResult))

                    ,(Consumer<Throwable>)throwable -> getResponseLiveDataCombinedResult().setValue(ApiResponse.error(throwable))

            )

    );

}

Both ways are acceptable. Also it would be more clear if your rewrite your Rx chain in that way

getMergedObservable(query)

    .map(result -> ApiResponse.success(result))

    .onErrorReturn(error -> ApiResponse.error(error))

    .startWith(ApiResponse.loading())

    .subscribeOn(Schedulers.io())

    .observeOn(AndroidSchedulers.mainThread())

    .subscribe(response -> getResponseLiveDataCombinedResult().setValue(response), error -> {/* should not happen*/})