Retry load next page in horizontal list

Author: hoc081098

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

@@ -9,9 +9,16 @@ import androidx.recyclerview.widget.DiffUtil
 import androidx.recyclerview.widget.ListAdapter
 import androidx.recyclerview.widget.RecyclerView
 import com.hoc.pagination_mvi.R
+import com.hoc.pagination_mvi.asObservable
 import com.hoc.pagination_mvi.ui.main.MainContract.Item.HorizontalList.HorizontalItem
 import com.hoc.pagination_mvi.ui.main.MainContract.PlaceholderState
 import com.hoc.pagination_mvi.ui.main.MainContract.PostVS
+import com.jakewharton.rxbinding3.view.clicks
+import com.jakewharton.rxbinding3.view.detaches
+import io.reactivex.disposables.CompositeDisposable
+import io.reactivex.rxkotlin.addTo
+import io.reactivex.rxkotlin.subscribeBy
+import io.reactivex.subjects.PublishSubject
 import kotlinx.android.synthetic.main.recycler_item_horizontal_placeholder.view.*
 import kotlinx.android.synthetic.main.recycler_item_horizontal_post.view.*
 
@@ -36,14 +43,19 @@ private object HorizontalItemItemCallback : DiffUtil.ItemCallback<HorizontalItem
   }
 }
 
-class HorizontalAdapter :
+class HorizontalAdapter(
+  private val compositeDisposable: CompositeDisposable
+) :
   ListAdapter<HorizontalItem, HorizontalAdapter.VH>(HorizontalItemItemCallback) {
 
+  private val retryS = PublishSubject.create<Unit>()
+  val retryObservable get() = retryS.asObservable()
+
   override fun onCreateViewHolder(parent: ViewGroup, @LayoutRes viewType: Int): VH {
     val itemView = LayoutInflater.from(parent.context).inflate(viewType, parent, false)
     return when (viewType) {
       R.layout.recycler_item_horizontal_post -> PostVH(itemView)
-      R.layout.recycler_item_horizontal_placeholder -> PlaceholderVH(itemView)
+      R.layout.recycler_item_horizontal_placeholder -> PlaceholderVH(itemView, parent)
       else -> error("Unknown viewType=$viewType")
     }
   }
@@ -82,11 +94,26 @@ class HorizontalAdapter :
     }
   }
 
-  private class PlaceholderVH(itemView: View) : VH(itemView) {
+  private inner class PlaceholderVH(itemView: View, parent: ViewGroup) : VH(itemView) {
     private val progressBar = itemView.progress_bar!!
     private val textError = itemView.text_error!!
     private val buttonRetry = itemView.button_retry!!
 
+    init {
+      buttonRetry
+        .clicks()
+        .takeUntil(parent.detaches())
+        .filter {
+          val position = adapterPosition
+          if (position == RecyclerView.NO_POSITION) {
+            false
+          } else {
+            (getItem(position) as? HorizontalItem.Placeholder)?.state is PlaceholderState.Error
+          }
+        }
+        .subscribeBy { retryS.onNext(Unit) }
+        .addTo(compositeDisposable)
+    }
 
     override fun bind(item: HorizontalItem) {
       if (item !is HorizontalItem.Placeholder) return

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

@@ -58,6 +58,9 @@ class MainAdapter(private val compositeDisposable: CompositeDisposable) :
   private val loadNextPageHorizontalS = PublishSubject.create<Unit>()
   val loadNextPageHorizontalObservable get() = loadNextPageHorizontalS.asObservable()
 
+  private val retryHorizontalS = PublishSubject.create<Unit>()
+  val retryHorizontalObservable get() = retryHorizontalS.asObservable()
+
   override fun onCreateViewHolder(parent: ViewGroup, @LayoutRes viewType: Int): VH {
     val itemView = LayoutInflater.from(parent.context).inflate(viewType, parent, false)
     return when (viewType) {
@@ -161,7 +164,7 @@ class MainAdapter(private val compositeDisposable: CompositeDisposable) :
     private val progressBar = itemView.progress_bar_horizontal!!
     private val textError = itemView.text_error_horizontal!!
     private val buttonRetry = itemView.button_retry_horizontal!!
-    private val adapter = HorizontalAdapter()
+    private val adapter = HorizontalAdapter(compositeDisposable)
     private val visibleThreshold get() = 2
 
     init {
@@ -182,6 +185,11 @@ class MainAdapter(private val compositeDisposable: CompositeDisposable) :
         })
       }
 
+      adapter
+        .retryObservable
+        .subscribe(retryHorizontalS::onNext)
+        .addTo(compositeDisposable)
+
       recycler
         .scrollEvents()
         .takeUntil(parent.detaches())

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

@@ -40,6 +40,16 @@ interface MainContract {
       return horizontalList.postItems.size
     }
 
+    fun shouldRetryHorizontal(): Boolean {
+      val horizontalList =
+        items.singleOrNull { it is Item.HorizontalList } as? Item.HorizontalList ?: return false
+      return !horizontalList.isLoading &&
+          horizontalList.error == null &&
+          horizontalList.postItems.isNotEmpty() &&
+          (horizontalList.items.singleOrNull { it is HorizontalItem.Placeholder } as? HorizontalItem.Placeholder)
+            ?.state is PlaceholderState.Error
+    }
+
     companion object Factory {
       @JvmStatic
       fun initial() = ViewState(

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

@@ -143,7 +143,11 @@ class MainFragment : Fragment() {
           .map { ViewIntent.RetryLoadPage },
         adapter
           .loadNextPageHorizontalObservable
-          .map { ViewIntent.LoadNextPageHorizontal }
+          .map { ViewIntent.LoadNextPageHorizontal },
+        adapter
+          .retryHorizontalObservable
+          .throttleFirst(500, TimeUnit.MILLISECONDS)
+          .map { ViewIntent.RetryLoadPageHorizontal }
       )
     ).addTo(compositeDisposable)
   }

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

@@ -81,6 +81,15 @@ class MainVM @Inject constructor(
         .exhaustMap { interactor.postNextPageChanges(start = it, limit = POST_PAGE_SIZE) }
     }
 
+  private val retryLoadPageHorizontalProcessor =
+    ObservableTransformer<ViewIntent.RetryLoadPageHorizontal, PartialStateChange> { intents ->
+      intents
+        .withLatestFrom(stateObservable)
+        .filter { (_, vs) -> vs.shouldRetryHorizontal() }
+        .map { (_, vs) -> vs.getHorizontalListCount() }
+        .exhaustMap { interactor.postNextPageChanges(start = it, limit = POST_PAGE_SIZE) }
+    }
+
   private val toPartialStateChange =
     ObservableTransformer<ViewIntent, PartialStateChange> { intents ->
       intents
@@ -91,6 +100,9 @@ class MainVM @Inject constructor(
             shared.ofType<ViewIntent.RetryLoadPage>().compose(retryLoadPageProcessor),
             shared.ofType<ViewIntent.LoadNextPageHorizontal>().compose(
               loadNextPageHorizontalProcessor
+            ),
+            shared.ofType<ViewIntent.RetryLoadPageHorizontal>().compose(
+              retryLoadPageHorizontalProcessor
             )
           )
         }