handle single event

Author: hoc081098

app/src/main/java/com/hoc/pagination_mvi/ui/main/MainContract.kt

@@ -123,10 +123,16 @@ interface MainContract {
 
   sealed class ViewIntent {
     object Initial : ViewIntent()
+    object Refresh : ViewIntent()
+
+    // Vertical
     object LoadNextPage : ViewIntent()
+
     object RetryLoadPage : ViewIntent()
 
+    // Horizontal
     object LoadNextPageHorizontal : ViewIntent()
+
     object RetryLoadPageHorizontal : ViewIntent()
   }
 
@@ -174,9 +180,13 @@ interface MainContract {
               vs.items.filterIsInstance<Item.Photo>() + this.photos.map { Item.Photo(it) }
 
             vs.copy(
-              items = vs.items.filter { it !is Item.Photo && it !is Item.Placeholder }
-                  + photoItems
-                  + Item.Placeholder(PlaceholderState.Idle),
+              items = vs.items.filter { it !is Item.Photo && it !is Item.Placeholder } +
+                  photoItems +
+                  if (this.photos.isNotEmpty()) {
+                    listOf(Item.Placeholder(PlaceholderState.Idle))
+                  } else {
+                    emptyList()
+                  },
               photoItems = photoItems
             )
           }
@@ -270,7 +280,11 @@ interface MainContract {
                   val postItems = item.items.filterIsInstance<HorizontalItem.Post>() +
                       this.posts.map { HorizontalItem.Post(it) }
                   item.copy(
-                    items = postItems + HorizontalItem.Placeholder(PlaceholderState.Idle),
+                    items = postItems + if (this.posts.isNotEmpty()) {
+                      listOf(HorizontalItem.Placeholder(PlaceholderState.Idle))
+                    } else {
+                      emptyList()
+                    },
                     postItems = postItems
                   )
                 } else {
@@ -315,7 +329,18 @@ interface MainContract {
   }
 
   sealed class SingleEvent {
+    object RefreshSuccess : SingleEvent()
+    data class RefreshFailure(val error: Throwable) : SingleEvent()
+
+    // Horizontal
+    data class GetPostsFailure(val error: Throwable) : SingleEvent()
+
+    object HasReachedMaxHorizontal : SingleEvent()
+
+    // Vertical
+    data class GetPhotosFailure(val error: Throwable) : SingleEvent()
 
+    object HasReachedMax : SingleEvent()
   }
 
   interface Interactor {

app/src/main/java/com/hoc/pagination_mvi/ui/main/MainFragment.kt

@@ -2,7 +2,6 @@ package com.hoc.pagination_mvi.ui.main
 
 import android.graphics.Rect
 import android.os.Bundle
-import android.util.Log
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
@@ -14,13 +13,15 @@ import androidx.recyclerview.widget.GridLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import com.hoc.pagination_mvi.R
 import com.hoc.pagination_mvi.isOrientationPortrait
+import com.hoc.pagination_mvi.toast
 import com.hoc.pagination_mvi.ui.main.MainContract.ViewIntent
 import com.jakewharton.rxbinding3.recyclerview.scrollEvents
 import dagger.android.support.AndroidSupportInjection
 import io.reactivex.Observable
 import io.reactivex.ObservableSource
 import io.reactivex.disposables.CompositeDisposable
 import io.reactivex.rxkotlin.addTo
+import io.reactivex.rxkotlin.subscribeBy
 import kotlinx.android.synthetic.main.fragment_main.*
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import java.util.concurrent.TimeUnit
@@ -114,9 +115,12 @@ class MainFragment : Fragment() {
     mainVM.stateD.observe(viewLifecycleOwner, Observer {
       it ?: return@Observer
       adapter.submitList(it.items)
-
-      Log.d("###", "[LAST] ${it.items.lastOrNull()}")
     })
+    mainVM
+      .singleEventObservable
+      .subscribeBy(onNext = ::handleSingleEvent)
+      .addTo(compositeDisposable)
+
     mainVM.processIntents(
       Observable.mergeArray(
         Observable.just(ViewIntent.Initial),
@@ -132,6 +136,35 @@ class MainFragment : Fragment() {
     ).addTo(compositeDisposable)
   }
 
+  private fun handleSingleEvent(event: MainContract.SingleEvent) {
+    return when (event) {
+      MainContract.SingleEvent.RefreshSuccess -> {
+        toast("Refresh success")
+      }
+      is MainContract.SingleEvent.RefreshFailure -> {
+        toast(
+          "Refresh failure: ${event.error.message ?: ""}"
+        )
+      }
+      is MainContract.SingleEvent.GetPostsFailure -> {
+        toast(
+          "Get posts failure: ${event.error.message ?: ""}"
+        )
+      }
+      MainContract.SingleEvent.HasReachedMaxHorizontal -> {
+        toast("Got all posts")
+      }
+      is MainContract.SingleEvent.GetPhotosFailure -> {
+        toast(
+          "Get photos failure: ${event.error.message ?: ""}"
+        )
+      }
+      MainContract.SingleEvent.HasReachedMax -> {
+        toast("Got all photos")
+      }
+    }
+  }
+
   private fun loadNextPageIntent(): ObservableSource<ViewIntent> {
     return recycler
       .scrollEvents()

app/src/main/java/com/hoc/pagination_mvi/ui/main/MainVM.kt

@@ -7,6 +7,7 @@ import com.hoc.pagination_mvi.asObservable
 import com.hoc.pagination_mvi.domain.dispatchers_schedulers.RxSchedulerProvider
 import com.hoc.pagination_mvi.exhaustMap
 import com.hoc.pagination_mvi.ui.main.MainContract.*
+import com.hoc.pagination_mvi.ui.main.MainContract.PartialStateChange.*
 import io.reactivex.Observable
 import io.reactivex.ObservableTransformer
 import io.reactivex.disposables.CompositeDisposable
@@ -25,14 +26,18 @@ class MainVM @Inject constructor(
   private val rxSchedulerProvider: RxSchedulerProvider
 ) : ViewModel() {
   private val initial = ViewState.initial()
+
   private val _stateD = MutableLiveData<ViewState>().apply { value = initial }
   private val stateS = BehaviorSubject.createDefault(initial)
-
   private val stateObservable get() = stateS.asObservable()
+
   private val intentS = PublishSubject.create<ViewIntent>()
+  private val singleEventS = PublishSubject.create<SingleEvent>()
   private val compositeDisposable = CompositeDisposable()
 
+  /// Expose view state live data & single event observable
   val stateD get() = _stateD.distinctUntilChanged()
+  val singleEventObservable get() = singleEventS.asObservable()
 
   fun processIntents(intents: Observable<ViewIntent>) = intents.subscribe(intentS::onNext)!!
 
@@ -78,14 +83,43 @@ class MainVM @Inject constructor(
 
   private val toPartialStateChange =
     ObservableTransformer<ViewIntent, PartialStateChange> { intents ->
-      intents.publish { shared ->
-        Observable.mergeArray(
-          shared.ofType<ViewIntent.Initial>().compose(initialProcessor),
-          shared.ofType<ViewIntent.LoadNextPage>().compose(nextPageProcessor),
-          shared.ofType<ViewIntent.RetryLoadPage>().compose(retryLoadPageProcessor),
-          shared.ofType<ViewIntent.LoadNextPageHorizontal>().compose(loadNextPageHorizontalProcessor)
-        )
-      }
+      intents
+        .publish { shared ->
+          Observable.mergeArray(
+            shared.ofType<ViewIntent.Initial>().compose(initialProcessor),
+            shared.ofType<ViewIntent.LoadNextPage>().compose(nextPageProcessor),
+            shared.ofType<ViewIntent.RetryLoadPage>().compose(retryLoadPageProcessor),
+            shared.ofType<ViewIntent.LoadNextPageHorizontal>().compose(
+              loadNextPageHorizontalProcessor
+            )
+          )
+        }
+        .compose(sendSingleEvent)
+    }
+
+  private val sendSingleEvent =
+    ObservableTransformer<PartialStateChange, PartialStateChange> { changes ->
+      changes
+        .observeOn(rxSchedulerProvider.main)
+        .doOnNext { change ->
+          when (change) {
+            is PhotoFirstPage.Data -> if (change.photos.isEmpty()) singleEventS.onNext(SingleEvent.HasReachedMax)
+            is PhotoFirstPage.Error -> singleEventS.onNext(SingleEvent.GetPhotosFailure(change.error))
+            PhotoFirstPage.Loading -> Unit
+            ///
+            is PhotoNextPage.Data -> if (change.photos.isEmpty()) singleEventS.onNext(SingleEvent.HasReachedMax)
+            is PhotoNextPage.Error -> singleEventS.onNext(SingleEvent.GetPhotosFailure(change.error))
+            PhotoNextPage.Loading -> Unit
+            ///
+            is PostFirstPage.Data -> if (change.posts.isEmpty()) singleEventS.onNext(SingleEvent.HasReachedMaxHorizontal)
+            is PostFirstPage.Error -> singleEventS.onNext(SingleEvent.GetPostsFailure(change.error))
+            PostFirstPage.Loading -> Unit
+            ///
+            is PostNextPage.Data -> if (change.posts.isEmpty()) singleEventS.onNext(SingleEvent.HasReachedMaxHorizontal)
+            is PostNextPage.Error -> singleEventS.onNext(SingleEvent.GetPostsFailure(change.error))
+            PostNextPage.Loading -> Unit
+          }
+        }
     }
 
   init {

app/src/main/java/com/hoc/pagination_mvi/util.kt

@@ -2,7 +2,9 @@ package com.hoc.pagination_mvi
 
 import android.content.Context
 import android.content.res.Configuration
+import android.widget.Toast
 import androidx.annotation.CheckResult
+import androidx.fragment.app.Fragment
 import io.reactivex.BackpressureStrategy
 import io.reactivex.Observable
 import io.reactivex.subjects.Subject
@@ -19,3 +21,7 @@ inline fun <T : Any, R : Any> Observable<T>.exhaustMap(crossinline transform: (T
 inline fun <T> Subject<T>.asObservable(): Observable<T> = this
 
 val Context.isOrientationPortrait get() = this.resources.configuration.orientation == Configuration.ORIENTATION_PORTRAIT
+
+fun Context.toast(text: CharSequence) = Toast.makeText(this, text, Toast.LENGTH_SHORT).show()
+
+fun Fragment.toast(text: CharSequence) = requireContext().toast(text)