Paging 3 sample

Author: TheAlisher

app/src/main/java/com/alish/boilerplate/di/NetworkModule.kt

@@ -1,8 +1,10 @@
 package com.alish.boilerplate.di
 
 import android.content.Context
+import com.alish.boilerplate.data.remote.apiservices.FooApiService
 import com.alish.boilerplate.data.remote.apiservices.SignInApiService
-import com.alish.boilerplate.data.remote.apiservices.SignInApiServiceImpl
+import com.alish.boilerplate.data.remote.apiservices.mock.FooApiServiceImpl
+import com.alish.boilerplate.data.remote.apiservices.mock.SignInApiServiceImpl
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@@ -21,4 +23,12 @@ object NetworkModule {
     ): SignInApiService {
         return SignInApiServiceImpl(context)
     }
+
+    @Singleton
+    @Provides
+    fun provideFooApiService(
+        @ApplicationContext context: Context
+    ): FooApiService {
+        return FooApiServiceImpl(context)
+    }
 }

app/src/main/java/com/alish/boilerplate/di/RepositoriesModule.kt

@@ -1,6 +1,8 @@
 package com.alish.boilerplate.di
 
+import com.alish.boilerplate.data.repositories.FooRepositoryImpl
 import com.alish.boilerplate.data.repositories.SignInRepositoryImpl
+import com.alish.boilerplate.domain.repositories.FooRepository
 import com.alish.boilerplate.domain.repositories.SignInRepository
 import dagger.Binds
 import dagger.Module
@@ -15,4 +17,9 @@ abstract class RepositoriesModule {
     abstract fun bindSignInRepository(
         signInRepositoryImpl: SignInRepositoryImpl
     ): SignInRepository
+
+    @Binds
+    abstract fun bindFooRepository(
+        fooRepositoryImpl: FooRepositoryImpl
+    ): FooRepository
 }

app/src/main/java/com/alish/boilerplate/presentation/base/BaseDiffUtil.kt

@@ -0,0 +1,19 @@
+package com.alish.boilerplate.presentation.base
+
+import androidx.recyclerview.widget.DiffUtil
+
+interface IBaseDiffModel<T> {
+    val id: T
+    override fun equals(other: Any?): Boolean
+}
+
+class BaseDiffUtilItemCallback<T : IBaseDiffModel<S>, S> : DiffUtil.ItemCallback<T>() {
+
+    override fun areItemsTheSame(oldItem: T, newItem: T): Boolean {
+        return oldItem.id == newItem.id
+    }
+
+    override fun areContentsTheSame(oldItem: T, newItem: T): Boolean {
+        return oldItem == newItem
+    }
+}

app/src/main/java/com/alish/boilerplate/presentation/base/BaseFragment.kt

@@ -9,6 +9,7 @@ import androidx.fragment.app.Fragment
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.lifecycleScope
 import androidx.lifecycle.repeatOnLifecycle
+import androidx.paging.PagingData
 import androidx.viewbinding.ViewBinding
 import com.alish.boilerplate.domain.utils.NetworkError
 import com.alish.boilerplate.presentation.ui.state.UIState
@@ -83,6 +84,16 @@ abstract class BaseFragment<ViewModel : BaseViewModel, Binding : ViewBinding>(
         }
     }
 
+    /**
+     * Collect [PagingData] with [collectFlowSafely]
+     */
+    protected fun <T : Any> Flow<PagingData<T>>.collectPaging(
+        lifecycleState: Lifecycle.State = Lifecycle.State.STARTED,
+        action: suspend (value: PagingData<T>) -> Unit
+    ) {
+        collectFlowSafely(lifecycleState) { this.collectLatest { action(it) } }
+    }
+
     /**
      * Setup views visibility depending on [UIState] states.
      * @param isShowViewIfSuccess is responsible for displaying views depending on whether

app/src/main/java/com/alish/boilerplate/presentation/base/BaseViewModel.kt

@@ -1,13 +1,17 @@
 package com.alish.boilerplate.presentation.base
 
-import androidx.lifecycle.ViewModel
+import  androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import androidx.paging.PagingData
+import androidx.paging.cachedIn
+import androidx.paging.map
 import com.alish.boilerplate.domain.utils.Either
 import com.alish.boilerplate.domain.utils.NetworkError
 import com.alish.boilerplate.presentation.ui.state.UIState
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
 
 abstract class BaseViewModel : ViewModel() {
@@ -18,6 +22,18 @@ abstract class BaseViewModel : ViewModel() {
     @Suppress("FunctionName")
     protected fun <T> MutableUIStateFlow() = MutableStateFlow<UIState<T>>(UIState.Idle())
 
+    /**
+     * Reset [MutableUIStateFlow] to [UIState.Idle]
+     */
+    fun <T> MutableStateFlow<UIState<T>>.reset() {
+        value = UIState.Idle()
+    }
+
+    /**
+     * Collect network request
+     *
+     * @return [UIState] depending request result
+     */
     protected fun <T> Flow<Either<NetworkError, T>>.collectRequest(
         state: MutableStateFlow<UIState<T>>,
     ) {
@@ -33,11 +49,12 @@ abstract class BaseViewModel : ViewModel() {
     }
 
     /**
-     * Collect network request and return [UIState] depending request result
+     * Collect network request with mapping from domain to ui
+     *
+     * @return [UIState] depending request result
      */
     protected fun <T, S> Flow<Either<NetworkError, T>>.collectRequest(
-        state: MutableStateFlow<UIState<S>>,
-        mappedData: (T) -> S
+        state: MutableStateFlow<UIState<S>>, mappedData: (T) -> S
     ) {
         viewModelScope.launch(Dispatchers.IO) {
             state.value = UIState.Loading()
@@ -49,4 +66,11 @@ abstract class BaseViewModel : ViewModel() {
             }
         }
     }
+
+    /**
+     * Collect paging request
+     */
+    protected fun <T : Any, S : Any> Flow<PagingData<T>>.collectPagingRequest(
+        mappedData: (T) -> S
+    ) = map { it.map { data -> mappedData(data) } }.cachedIn(viewModelScope)
 }

app/src/main/java/com/alish/boilerplate/presentation/models/foo/FooUI.kt

@@ -0,0 +1,13 @@
+package com.alish.boilerplate.presentation.models.foo
+
+import com.alish.boilerplate.domain.models.foo.Foo
+import com.alish.boilerplate.presentation.base.IBaseDiffModel
+
+data class FooUI(
+    override val id: Long,
+    val bar: String
+) : IBaseDiffModel<Long>
+
+fun Foo.toUI() = FooUI(
+    id, bar
+)

app/src/main/java/com/alish/boilerplate/presentation/ui/adapters/FooPagingAdapter.kt

@@ -0,0 +1,33 @@
+package com.alish.boilerplate.presentation.ui.adapters
+
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.paging.PagingDataAdapter
+import androidx.recyclerview.widget.RecyclerView
+import com.alish.boilerplate.presentation.base.BaseDiffUtilItemCallback
+import com.alish.boilerplate.databinding.ItemFooBinding
+import com.alish.boilerplate.presentation.models.foo.FooUI
+
+class FooPagingAdapter : PagingDataAdapter<FooUI, FooPagingAdapter.FooPagingViewHolder>(
+    BaseDiffUtilItemCallback()
+) {
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): FooPagingViewHolder {
+        return FooPagingViewHolder(
+            ItemFooBinding.inflate(LayoutInflater.from(parent.context), parent, false)
+        )
+    }
+
+    override fun onBindViewHolder(holder: FooPagingViewHolder, position: Int) {
+        getItem(position)?.let { holder.onBind(it) }
+    }
+
+    inner class FooPagingViewHolder(private val binding: ItemFooBinding) : RecyclerView.ViewHolder(
+        binding.root
+    ) {
+
+        fun onBind(item: FooUI) = with(binding) {
+            textItemFoo.text = item.bar
+        }
+    }
+}

app/src/main/java/com/alish/boilerplate/presentation/ui/adapters/paging/CommonLoadStateAdapter.kt

@@ -0,0 +1,20 @@
+package com.alish.boilerplate.presentation.ui.adapters.paging
+
+import android.view.ViewGroup
+import androidx.paging.LoadState
+import androidx.paging.LoadStateAdapter
+
+class CommonLoadStateAdapter(
+    private val retry: () -> Unit
+) : LoadStateAdapter<CommonLoadStateViewHolder>() {
+
+    override fun onCreateViewHolder(
+        parent: ViewGroup, loadState: LoadState
+    ): CommonLoadStateViewHolder {
+        return CommonLoadStateViewHolder.create(parent, retry)
+    }
+
+    override fun onBindViewHolder(holder: CommonLoadStateViewHolder, loadState: LoadState) {
+        holder.bind(loadState)
+    }
+}

app/src/main/java/com/alish/boilerplate/presentation/ui/adapters/paging/CommonLoadStateViewHolder.kt

@@ -0,0 +1,38 @@
+package com.alish.boilerplate.presentation.ui.adapters.paging
+
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.core.view.isVisible
+import androidx.paging.LoadState
+import androidx.recyclerview.widget.RecyclerView
+import com.alish.boilerplate.R
+import com.alish.boilerplate.databinding.LoadStateFooterViewItemBinding
+
+class CommonLoadStateViewHolder(
+    private val binding: LoadStateFooterViewItemBinding,
+    retry: () -> Unit
+) : RecyclerView.ViewHolder(binding.root) {
+
+    init {
+        binding.retryButton.setOnClickListener { retry.invoke() }
+    }
+
+    fun bind(loadState: LoadState) = with(binding) {
+        if (loadState is LoadState.Error) {
+            errorMsg.text = loadState.error.localizedMessage
+        }
+
+        progressBar.isVisible = loadState is LoadState.Loading
+        retryButton.isVisible = loadState is LoadState.Error
+        errorMsg.isVisible = loadState is LoadState.Error
+    }
+
+    companion object {
+        fun create(parent: ViewGroup, retry: () -> Unit): CommonLoadStateViewHolder {
+            val view = LayoutInflater.from(parent.context)
+                .inflate(R.layout.load_state_footer_view_item, parent, false)
+            val binding = LoadStateFooterViewItemBinding.bind(view)
+            return CommonLoadStateViewHolder(binding, retry)
+        }
+    }
+}

app/src/main/java/com/alish/boilerplate/presentation/ui/fragments/home/HomeFragment.kt

@@ -1,10 +1,15 @@
 package com.alish.boilerplate.presentation.ui.fragments.home
 
+import androidx.core.view.isVisible
 import androidx.fragment.app.viewModels
+import androidx.paging.LoadState
+import androidx.recyclerview.widget.LinearLayoutManager
 import by.kirich1409.viewbindingdelegate.viewBinding
 import com.alish.boilerplate.R
 import com.alish.boilerplate.databinding.FragmentHomeBinding
 import com.alish.boilerplate.presentation.base.BaseFragment
+import com.alish.boilerplate.presentation.ui.adapters.FooPagingAdapter
+import com.alish.boilerplate.presentation.ui.adapters.paging.CommonLoadStateAdapter
 import dagger.hilt.android.AndroidEntryPoint
 
 @AndroidEntryPoint
@@ -14,4 +19,32 @@ class HomeFragment : BaseFragment<HomeViewModel, FragmentHomeBinding>(
 
     override val viewModel: HomeViewModel by viewModels()
     override val binding by viewBinding(FragmentHomeBinding::bind)
+
+    private val fooAdapter = FooPagingAdapter()
+
+    override fun initialize() {
+        setupFooRecycler()
+    }
+
+    private fun setupFooRecycler() = with(binding) {
+        recyclerHomeFoo.layoutManager = LinearLayoutManager(context)
+        recyclerHomeFoo.adapter = fooAdapter.withLoadStateFooter(
+            footer = CommonLoadStateAdapter { fooAdapter.retry() }
+        )
+
+        fooAdapter.addLoadStateListener { loadStates ->
+            recyclerHomeFoo.isVisible = loadStates.refresh is LoadState.NotLoading
+            binding.loaderHome.isVisible = loadStates.refresh is LoadState.Loading
+        }
+    }
+
+    override fun setupRequests() {
+        fetchFoo()
+    }
+
+    private fun fetchFoo() {
+        viewModel.fetchFoo().collectPaging {
+            fooAdapter.submitData(it)
+        }
+    }
 }