Infinite Scroll with Paging Library

dependencies {
  val paging_version = "3.1.1"

  implementation("androidx.paging:paging-runtime:$paging_version")

  // alternatively - without Android dependencies for tests
  testImplementation("androidx.paging:paging-common:$paging_version")

  // optional - RxJava2 support
  implementation("androidx.paging:paging-rxjava2:$paging_version")

  // optional - RxJava3 support
  implementation("androidx.paging:paging-rxjava3:$paging_version")

  // optional - Guava ListenableFuture support
  implementation("androidx.paging:paging-guava:$paging_version")

  // optional - Jetpack Compose integration
  implementation("androidx.paging:paging-compose:1.0.0-alpha15")
}

data class Response(
    @SerializedName("total")
    val total : Int,
    @SerializedName("total_pages")
    val pages : Int,
    @SerializedName("results")
    val results : List<Picture>
)

data class Picture(
    @SerializedName("id")
    val id: String,
    @SerializedName("urls")
    val url: Url
)

data class Url(
    @SerializedName("thumb")
    val url: String
)

interface UnsplashService {

    @GET("search/photos")
    suspend fun getPhotoList(
        @Query("page") page: Int,
        @Query("query") query: String = "android",
        @Query("client_id") key: String = "키 값",
        @Query("per_page") perPage: Int = PAGE_SIZE
    ): Response
}

override suspend fun load(params: LoadParams<Int>): LoadResult<Int, Picture> {
        TODO("Not yet implemented")
    }
   override fun getRefreshKey(state: PagingState<Int, Picture>): Int? {
        TODO("Not yet implemented")
    }

const val STARTING_KEY = 1

...

override suspend fun load(params: LoadParams<Int>): LoadResult<Int, Picture> {
        val position = params.key ?: STARTING_KEY
        return try {
            val pictures = unsplashService.getPhotoList(position).results
            LoadResult.Page(
                data = pictures,
                prevKey = if (position == STARTING_KEY) null else position - 1,
                nextKey = if (pictures.isEmpty()) null else position + 1
            )
        } catch (e: IOException) {
            return LoadResult.Error(e)
        }
    }

override fun getRefreshKey(state: PagingState<Int, Picture>): Int? {
				// 페이지의 이전 키(또는 이전이 null 인경우 다음 키)를 가져와야 합니다. 
        return state.anchorPosition?.let { position ->
            state.closestPageToPosition(position)?.prevKey?.plus(1)
                ?: state.closestPageToPosition(position)?.nextKey?.minus(1)
        }
}

const val STARTING_KEY = 1

class PicturePagingSource(
    private val unsplashService: UnsplashService
) : PagingSource<Int, Picture>() {

    override fun getRefreshKey(state: PagingState<Int, Picture>): Int? {
        return state.anchorPosition?.let { position ->
            state.closestPageToPosition(position)?.prevKey?.plus(1)
                ?: state.closestPageToPosition(position)?.nextKey?.minus(1)
        }
    }

    override suspend fun load(params: LoadParams<Int>): LoadResult<Int, Picture> {
        val position = params.key ?: STARTING_KEY
        return try {
            val pictures = unsplashService.getPhotoList(position).results
            LoadResult.Page(
                data = pictures,
                prevKey = if (position == STARTING_KEY) null else position - 1,
                nextKey = if (pictures.isEmpty()) null else position + 1
            )
        } catch (e: Exception) {
            return LoadResult.Error(e)
        }
    }

}

interface PictureRepository {

    fun getPictureList(): Flow<PagingData<Picture>>

}

class PictureRepositoryImpl @Inject constructor(
    private val service: UnsplashService
) : PictureRepository {

    companion object {
        const val PAGE_SIZE = 30
    }

    override fun getPictureList(): Flow<PagingData<Picture>> =
        Pager(PagingConfig(PAGE_SIZE)) {
            PicturePagingSource(service)
        }.flow

}

class PictureFlowUseCase @Inject constructor(
    private val pictureRepository: PictureRepository
) {
    operator fun invoke() = pictureRepository.getPictureList()
        .flowOn(Dispatchers.Default)
}

@HiltViewModel
class PagingViewModel @Inject constructor(
    private val pictureFlowUseCase: PictureFlowUseCase
) : ViewModel() {

    private val _picList = MutableStateFlow<PagingData<Picture>>(PagingData.empty())
    val picList = _picList.asStateFlow()

    fun getPictureList() {
        viewModelScope.launch {
            pictureFlowUseCase()
                .cachedIn(viewModelScope)
                .collectLatest { picture ->
                    _picList.emit(picture)
                }
        }
    }
}

class PicturePagingAdapter : PagingDataAdapter<Picture, PictureViewHolder>(PICTURE_DIFF_CALLBACK) {

    override fun onBindViewHolder(holder: PictureViewHolder, position: Int) {
        getItem(position)?.let { holder.bind(it) }
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PictureViewHolder {
        return PictureViewHolder(
            ItemPicBinding.inflate(LayoutInflater.from(parent.context), parent, false)
        )
    }

    companion object {
        private val PICTURE_DIFF_CALLBACK = object : DiffUtil.ItemCallback<Picture>() {
            override fun areItemsTheSame(oldItem: Picture, newItem: Picture): Boolean =
                oldItem.id == newItem.id

            override fun areContentsTheSame(oldItem: Picture, newItem: Picture): Boolean =
                oldItem == newItem

        }
    }

}

class PictureViewHolder(
    private val binding: ItemPicBinding
) : RecyclerView.ViewHolder(binding.root) {
    fun bind(item: Picture) {
        binding.apply {
            picture = item
            executePendingBindings()
        }
    }
}

private fun initRecyclerView() {
	binding.rvPicture.apply {
			layoutManager = GridLayoutManager(requireContext(), 2)
	    adapter = picturePagingAdapter
	}
}

private fun collectFlows() {
	viewLifecycleOwner.lifecycleScope.launch {
		viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
			launch {
		        viewModel.picList.collectLatest { picture ->
		            picturePagingAdapter.submitData(picture)
			    }
			}
      
			launch {
		      picturePagingAdapter.loadStateFlow
	            .collectLatest {
	                if (it.source.append is LoadState.Loading) dialog.show()
                    else dialog.dismiss()
				}
			}
        }
    }
}

const val DELAY_MILLIS = 1_000L

...

override suspend fun load(params: LoadParams<Int>): LoadResult<Int, Picture> {
        val position = params.key ?: STARTING_KEY
				// 1초의 지연시간 시뮬레이션
        if (position != STARTING_KEY) delay(DELAY_MILLIS)
				
				...