Support for different types of UseCases (Fix #18)

easymvp-rx2-api/src/main/java/easymvp/usecase/FlowableUseCase.java

@@ -0,0 +1,40 @@
+package easymvp.usecase;
+
+import javax.annotation.Nullable;
+
+import easymvp.executer.PostExecutionThread;
+import easymvp.executer.UseCaseExecutor;
+import io.reactivex.Flowable;
+import io.reactivex.FlowableTransformer;
+
+/**
+ * @author Saeed Masoumi (s-masoumi@live.com)
+ */
+
+public abstract class FlowableUseCase<R, Q> extends UseCase<Flowable, Q> {
+ private final FlowableTransformer<? super R, ? extends R> schedulersTransformer;
+
+ public FlowableUseCase(final UseCaseExecutor useCaseExecutor,
+ final PostExecutionThread postExecutionThread) {
+ super(useCaseExecutor, postExecutionThread);
+ schedulersTransformer = new FlowableTransformer<R, R>() {
+ @Override
+ public Flowable<R> apply(Flowable<R> rObservable) {
+ return rObservable.subscribeOn(useCaseExecutor.getScheduler())
+ .observeOn(postExecutionThread.getScheduler());
+ }
+ };
+ }
+
+ @Override
+ public Flowable<R> execute(@Nullable Q param) {
+ return interact(param).compose(getSchedulersTransformer());
+ }
+
+ @Override
+ protected abstract Flowable<R> interact(@Nullable Q param);
+
+ private FlowableTransformer<? super R, ? extends R> getSchedulersTransformer() {
+ return schedulersTransformer;
+ }
+}

easymvp-rx2-api/src/main/java/easymvp/usecase/MaybeUseCase.java

@@ -0,0 +1,40 @@
+package easymvp.usecase;
+
+import javax.annotation.Nullable;
+
+import easymvp.executer.PostExecutionThread;
+import easymvp.executer.UseCaseExecutor;
+import io.reactivex.Maybe;
+import io.reactivex.MaybeTransformer;
+
+/**
+ * @author Saeed Masoumi (s-masoumi@live.com)
+ */
+
+public abstract class MaybeUseCase<R, Q> extends UseCase<Maybe, Q> {
+ private final MaybeTransformer<? super R, ? extends R> schedulersTransformer;
+
+ public MaybeUseCase(final UseCaseExecutor useCaseExecutor,
+ final PostExecutionThread postExecutionThread) {
+ super(useCaseExecutor, postExecutionThread);
+ schedulersTransformer = new MaybeTransformer<R, R>() {
+ @Override
+ public Maybe<R> apply(Maybe<R> single) {
+ return single.subscribeOn(useCaseExecutor.getScheduler())
+ .observeOn(postExecutionThread.getScheduler());
+ }
+ };
+ }
+
+ @Override
+ public Maybe execute(@Nullable Q param) {
+ return interact(param).compose(getSchedulersTransformer());
+ }
+
+ @Override
+ protected abstract Maybe<R> interact(@Nullable Q param);
+
+ private MaybeTransformer<? super R, ? extends R> getSchedulersTransformer() {
+ return schedulersTransformer;
+ }
+}

easymvp-rx2-api/src/main/java/easymvp/usecase/SingleUseCase.java

@@ -0,0 +1,39 @@
+package easymvp.usecase;
+
+import easymvp.executer.PostExecutionThread;
+import easymvp.executer.UseCaseExecutor;
+import io.reactivex.Single;
+import io.reactivex.SingleTransformer;
+import io.reactivex.annotations.Nullable;
+
+/**
+ * @author Saeed Masoumi (s-masoumi@live.com)
+ */
+
+public abstract class SingleUseCase<R, Q> extends UseCase<Single, Q> {
+ private final SingleTransformer<? super R, ? extends R> schedulersTransformer;
+
+ public SingleUseCase(final UseCaseExecutor useCaseExecutor,
+ final PostExecutionThread postExecutionThread) {
+ super(useCaseExecutor, postExecutionThread);
+ schedulersTransformer = new SingleTransformer<R, R>() {
+ @Override
+ public Single<R> apply(Single<R> single) {
+ return single.subscribeOn(useCaseExecutor.getScheduler())
+ .observeOn(postExecutionThread.getScheduler());
+ }
+ };
+ }
+
+ @Override
+ public Single<R> execute(@Nullable Q param) {
+ return interact(param).compose(getSchedulersTransformer());
+ }
+
+ @Override
+ protected abstract Single<R> interact(@Nullable Q param);
+
+ private SingleTransformer<? super R, ? extends R> getSchedulersTransformer() {
+ return schedulersTransformer;
+ }
+}

easymvp-rx2-api/src/main/java/easymvp/usecase/UseCase.java

@@ -7,6 +7,14 @@
 import javax.annotation.Nullable;
 
 /**
+ * Each {@code UseCase} of the system orchestrate the flow of data to and from the entities.
+ * <p>
+ * Outer layers of system can execute use cases by calling {@link #execute(Object)}} method. Also
+ * you can use {@link #useCaseExecutor} to execute the job in a background thread and {@link
+ * #postExecutionThread} to post the result to another thread(usually UI thread).
+ *
+ * @param <P> The response type of a use case.
+ * @param <Q> The request type of a use case.
  * Created by megrez on 2017/3/12.
  */
 public abstract class UseCase<P,Q> {