Android における Paging 3 を用いたページングの導入

class CatPagingSource(
    private val repository: CatRepository
): PagingSource<Int, Cat>() {

    override suspend fun load(params: LoadParams<Int>): LoadResult<Int, Cat> {
        val currentKey = params.key ?: 1
        return repository.cats(params.loadSize, currentKey)
            .fold(
                onSuccess = {
                    LoadResult.Page(
                        data = it,
                        prevKey = (currentKey - 1).takeIf { key -> key > 0 },
                        nextKey = (currentKey + 1).takeIf { _ -> it.isNotEmpty() }
                    )
                },
                onFailure = {
                    LoadResult.Error(it)
                }
            )
    }

    override fun getRefreshKey(state: PagingState<Int, Cat>): Int? =
        state.anchorPosition?.let { anchorPosition ->
            val anchorPage = state.closestPageToPosition(anchorPosition)
            anchorPage?.prevKey?.plus(1) ?: anchorPage?.nextKey?.minus(1)
        }
}

class CatViewModel(
    private val useCase: CatUseCase
): ViewModel() {

    val cats: LiveData<PagingData<Cat>> =
        Pager(PagingConfig(pageSize = useCase.limit, initialLoadSize = useCase.limit)) {
            useCase.cats()
        }.liveData.cachedIn(this)
}

class CatPagingAdapter: PagingDataAdapter<Cat, CatPagingAdapter.ViewHolder>(diffCallBack) {

    inner class ViewHolder(val binding: ViewCatBinding): RecyclerView.ViewHolder(binding.root)

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder =
        ViewHolder(
            ViewCatBinding.inflate(LayoutInflater.from(parent.context), parent, false)
        )

    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        holder.binding.cat = getItem(position)
    }

}

private val diffCallBack = object: DiffUtil.ItemCallback<Cat>() {
    override fun areItemsTheSame(oldItem: Cat, newItem: Cat): Boolean = oldItem.id == newItem.id
    override fun areContentsTheSame(oldItem: Cat, newItem: Cat): Boolean = oldItem == newItem
}

class CatActivity : AppCompatActivity() {

    private val viewModel: CatViewModel by viewModels()

    private val listAdapter = CatPagingAdapter()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        binding.catList.adapter = listAdapter

        viewModel.cats.observe(this) {
            lifecycleScope.launchWhenStarted { 
                listAdapter.submitData(it)
            }
        }
    }
}

private typealias RetryListener = () -> Unit

class CatPagingLoadStateAdapter(
    private val retry: RetryListener
): LoadStateAdapter<CatPagingLoadStateAdapter.ViewHolder>() {

    inner class ViewHolder(
        private val binding: ViewCatLoadStateBinding
    ): RecyclerView.ViewHolder(binding.root) {
        fun bind(loadState: LoadState) {
            Log.d(this::class.simpleName, "LoadState: $loadState")

            binding.isLoading = loadState is LoadState.Loading
            binding.isError = loadState is LoadState.Error

            binding.retry.setOnClickListener { retry() }

            binding.executePendingBindings()
        }
    }

    override fun onCreateViewHolder(parent: ViewGroup, loadState: LoadState): ViewHolder =
        ViewHolder(
            ViewCatLoadStateBinding.inflate(LayoutInflater.from(parent.context), parent, false)
        )

    override fun onBindViewHolder(holder: ViewHolder, loadState: LoadState) {
        holder.bind(loadState)
    }
}

class CatActivity : AppCompatActivity() {

   private val listAdapter = CatPagingAdapter()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        binding.catList.adapter = listAdapter
            .withLoadStateFooter(CatPagingLoadStateAdapter { listAdapter.retry() })
   }
}

fun withLoadStateFooter(
    footer: LoadStateAdapter<*>
): ConcatAdapter {
    addLoadStateListener { loadType, loadState ->
        if (loadType == LoadType.APPEND) {
            footer.loadState = loadState
        }
    }
    return ConcatAdapter(this, footer)
}

launch {
    var prev = LoadStates.IDLE
    accessor.state.collect {
        if (prev.refresh != it.refresh) {
            loadStates.set(REFRESH, true, it.refresh)
            dispatchIfValid(REFRESH, it.refresh)
        }
        if (prev.prepend != it.prepend) {
            loadStates.set(PREPEND, true, it.prepend)
            dispatchIfValid(PREPEND, it.prepend)
        }
        if (prev.append != it.append) {
            loadStates.set(APPEND, true, it.append)
            dispatchIfValid(APPEND, it.append)
        }
        prev = it
    }
}

class CatActivity : AppCompatActivity() {

    private val listAdapter = CatPagingAdapter()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        binding.catList.adapter = listAdapter
            .withLoadStateFooter(CatPagingLoadStateAdapter { listAdapter.retry() })

        listAdapter.addLoadStateListener {
            binding.refreshLayout.isRefreshing = it.refresh is LoadState.Loading
        }
        binding.refreshLayout.setOnRefreshListener {
            listAdapter.refresh()
        }
    }
}

implementation 'androidx.paging:paging-compose:1.0.0-alpha12'

// SwipeRefreshLayout を使用する場合
implementation "com.google.accompanist:accompanist-swiperefresh:0.19.0"

@Composable
fun CatListScreen(viewModel: CatViewModel) {
    val pagingItems = viewModel.cat.collectAsLazyPagingItems()

    SwipeRefresh(
        state = rememberSwipeRefreshState(pagingItems.loadState.refresh is LoadState.Loading),
        onRefresh = { pagingItems.refresh() }
    ) {
        LazyColumn {
            items(pagingItems) { cat ->
                cat?.let { CatItem(it) }
            }
            item {
                LoadingStateView(state = pagingItems.loadState) {
                    pagingItems.retry()
                }
            }
        }
    }
}

@Composable
fun LoadingStateView(
    state: CombinedLoadStates,
    modifier: Modifier = Modifier
        .fillMaxWidth()
        .padding(24.dp),
    onError: () -> Unit
) {
    if (state.append !is LoadState.NotLoading)
        Column(
            modifier = modifier,
            verticalArrangement = Arrangement.Center,
            horizontalAlignment = Alignment.CenterHorizontally
        ) {
            when (state.append) {
                is LoadState.Loading -> ProgressIndicator()
                is LoadState.Error -> RetryIcon(onError = onError)
                is LoadState.NotLoading -> { /* Do nothing */ }
            }
        }
}

@Composable
fun ProgressIndicator(
    modifier: Modifier = Modifier.size(36.dp, 36.dp)
) {
    CircularProgressIndicator(
        modifier = modifier,
        color = colorResource(R.color.indicator)
    )
}

@Composable
fun RetryIcon(
    modifier: Modifier = Modifier.padding(6.dp),
    onError: () -> Unit
) {
    IconButton(modifier = modifier, onClick = onError) {
        Image(painterResource(R.drawable.ic_paging_load_state_error), contentDescription = "Retry")
    }
}