stockwatcher

A modern android development stack showcase

showcase items:

future showcase items:

Setup:

Core Code

RxUtil

package com.bignerdranch.stockwatcher.util;
import com.bignerdranch.stockwatcher.ui.RxFragment;
import io.reactivex.ObservableTransformer;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.schedulers.Schedulers;
public final class RxUtil {
 private static final String LOADING_MESSAGE = "Loading";
 private static final ObservableTransformer schedulersTransformer =
 observable -> observable.subscribeOn(Schedulers.io())
 .observeOn(AndroidSchedulers.mainThread());
 public static <T> ObservableTransformer<T, T> applyUIDefaults(RxFragment rxFragment) {
 return upstream -> upstream
 .compose(RxUtil.addToCompositeDisposable(rxFragment))
 .compose(RxUtil.applySchedulers())
 .compose(RxUtil.applyRequestStatus(rxFragment))
 .compose(RxUtil.showLoadingDialog(rxFragment));
 }
 private static <T> ObservableTransformer<T, T> applySchedulers() {
 return (ObservableTransformer<T, T>) schedulersTransformer;
 }
 private static <T> ObservableTransformer<T, T> addToCompositeDisposable(RxFragment rxFragment) {
 return upstream -> upstream.doOnSubscribe(
 disposable -> rxFragment.getCompositeDisposable().add(disposable));
 }
 private static <T> ObservableTransformer<T, T> applyRequestStatus(RxFragment rxFragment) {
 return upstream -> upstream
 .doOnSubscribe(disposable -> rxFragment.setRequestInProgress(true))
 .doOnTerminate(() -> rxFragment.setRequestInProgress(false));
 }
 private static <T> ObservableTransformer<T, T> showLoadingDialog(RxFragment rxFragment) {
 return observable -> observable
 .doOnSubscribe(disposable -> DialogUtils.showProgressDialog(
 rxFragment.getFragmentManager(), LOADING_MESSAGE))
 .doOnTerminate(() -> DialogUtils.hideProgressDialog(rxFragment.getFragmentManager()));
 }
}

RxFragment

package com.bignerdranch.stockwatcher.ui;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import io.reactivex.disposables.CompositeDisposable;
import lombok.Getter;
import lombok.Setter;
public abstract class RxFragment extends Fragment {
 private static final String EXTRA_RX_REQUEST_IN_PROGRESS = "EXTRA_RX_REQUEST_IN_PROGRESS";
 @Getter
 @Setter
 private boolean requestInProgress;
 @Getter
 private CompositeDisposable compositeDisposable;
 @Override
 public void onCreate(@Nullable Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 compositeDisposable = new CompositeDisposable();
 if (savedInstanceState != null) {
 this.requestInProgress = savedInstanceState.getBoolean(EXTRA_RX_REQUEST_IN_PROGRESS, false);
 }
 }
 @Override
 public void onSaveInstanceState(Bundle outState) {
 super.onSaveInstanceState(outState);
 outState.putBoolean(EXTRA_RX_REQUEST_IN_PROGRESS, requestInProgress);
 }
 @Override
 public void onResume() {
 super.onResume();
 if (isRequestInProgress()) {
 loadRxData();
 }
 }
 @Override
 public void onPause() {
 this.compositeDisposable.clear();
 super.onPause();
 }
 public abstract void loadRxData();
}

StockInfoFragment

package com.bignerdranch.stockwatcher.ui;
import android.databinding.DataBindingUtil;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Toast;
import com.bignerdranch.stockwatcher.R;
import com.bignerdranch.stockwatcher.StockWatcherApplication;
import com.bignerdranch.stockwatcher.databinding.FragmentStockInfoBinding;
import com.bignerdranch.stockwatcher.model.service.StockInfoForSymbol;
import com.bignerdranch.stockwatcher.model.service.repository.StockDataRepository;
import com.bignerdranch.stockwatcher.util.RxUtil;
import java.util.NoSuchElementException;
import javax.inject.Inject;
import io.reactivex.Observable;
public final class StockInfoFragment extends RxFragment {
 @Inject
 StockDataRepository stockDataRepository;
 private FragmentStockInfoBinding binding;
 @Override
 public void onCreate(@Nullable Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 StockWatcherApplication.getAppComponent(getContext()).inject(this);
 }
 @Nullable
 @Override
 public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container,
 @Nullable Bundle savedInstanceState) {
 super.onCreateView(inflater, container, savedInstanceState);
 binding = DataBindingUtil.inflate(inflater, R.layout.fragment_stock_info, container, false);
 // Fetch Stock Data
 binding.fetchDataButton.setOnClickListener(v -> {
 binding.errorMessage.setVisibility(View.GONE);
 loadRxData();
 });
 binding.tickerSymbol.setOnEditorActionListener((v, actionId, event) -> {
 if (event.getKeyCode() == KeyEvent.KEYCODE_ENTER) {
 loadRxData();
 return true;
 }
 return false;
 });
 // Clear Observable Cache
 binding.clearCacheButton.setOnClickListener(v -> {
 stockDataRepository.clearCache();
 Toast.makeText(getContext(), "observable cache cleared!", Toast.LENGTH_LONG).show();
 });
 return binding.getRoot();
 }
 @Override
 public void loadRxData() {
 Observable.just(binding.tickerSymbol.getText().toString())
 .filter(symbolText -> symbolText.length() > 0)
 .singleOrError()
 .toObservable()
 .flatMap(s -> stockDataRepository.getStockInfoForSymbol(s))
 .compose(RxUtil.applyUIDefaults(StockInfoFragment.this))
 .subscribe(this::displayStockResults, this::displayErrors);
 }
 private void displayErrors(Throwable throwable) {
 String message = throwable.getMessage();
 if (throwable instanceof NoSuchElementException) {
 message = "Enter a stock symbol first!!";
 }
 binding.errorMessage.setVisibility(View.VISIBLE);
 binding.errorMessage.setText(message);
 }
 private void displayStockResults(StockInfoForSymbol stockInfoForSymbol) {
 binding.stockValue.setText(stockInfoForSymbol.toString());
 }
}