Pagination basics in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What happens when you scroll to the bottom of this RecyclerView?

Given this Kotlin code snippet for a RecyclerView with pagination, what is the expected behavior when the user scrolls to the bottom?

Android Kotlin

recyclerView.addOnScrollListener(object : RecyclerView.OnScrollListener() {
  override fun onScrolled(rv: RecyclerView, dx: Int, dy: Int) {
    super.onScrolled(rv, dx, dy)
    val layoutManager = rv.layoutManager as LinearLayoutManager
    val totalItemCount = layoutManager.itemCount
    val lastVisible = layoutManager.findLastVisibleItemPosition()
    if (lastVisible == totalItemCount - 1) {
      loadNextPage()
    }
  }
})

A The app loads the next page of data by calling loadNextPage() when the last item is visible.

B The app refreshes the entire list from the first page when the bottom is reached.

C Nothing happens because onScrolled is not triggered at the bottom.

D The app crashes because findLastVisibleItemPosition() is not a valid method.

💡 Hint

Think about what happens when the last visible item matches the total items minus one.

The code listens for scroll events and checks if the last visible item is the last in the list. If yes, it triggers loading the next page.

🧠 Conceptual

intermediate

Why use pagination in mobile apps?

Which of these is the main reason to implement pagination in a mobile app?

A To make the UI more colorful and attractive.

B To reduce memory usage and improve performance by loading data in chunks.

C To load all data at once for faster access.

D To prevent users from scrolling too fast.

💡 Hint

Think about how loading large data sets affects app speed and memory.

Pagination helps by loading only a small part of data at a time, saving memory and making the app faster.

📝 Syntax

advanced

What is the output of this Kotlin code for a paginated list?

Consider this code snippet that appends new items to a list during pagination. What will be the size of 'items' after running?

Android Kotlin

val items = mutableListOf(1, 2, 3)
val newItems = listOf(4, 5)
items.addAll(newItems)
println(items.size)

A Compilation error

B 3

C 2

D 5

💡 Hint

What does addAll() do to the list?

addAll() adds all elements from newItems to items, increasing its size from 3 to 5.

❓ lifecycle

advanced

When should you reset pagination state in an Android app?

In an app with pagination, when is it best to reset the current page number and clear loaded data?

A When the user performs a new search or refreshes the list.

B Only when the app is closed and reopened.

C Never, keep loading pages continuously without reset.

D When the device orientation changes.

💡 Hint

Think about when the data source changes completely.

Resetting pagination on new search or refresh ensures the list shows fresh data from page one.

🔧 Debug

expert

Why does this pagination code cause duplicate items?

This Kotlin code appends new page data but sometimes shows duplicates. Why?

Android Kotlin

fun loadNextPage() {
  val newData = fetchData(page)
  items.addAll(newData)
  adapter.notifyDataSetChanged()
  page += 1
}

// fetchData returns the same data for page 1 and 2 by mistake

A adapter.notifyDataSetChanged() removes old items causing duplicates.

B items.addAll(newData) clears the list before adding, so duplicates appear.

C fetchData returns duplicate data for different pages, causing duplicates in 'items'.

D page variable is never incremented, so same page loads repeatedly.

💡 Hint

Check what fetchData returns for each page.

If fetchData returns the same data for multiple pages, adding it causes duplicates in the list.

Practice

1. What is the main purpose of pagination in mobile apps?

easy

A. To split data into smaller pages for faster loading and less memory use

B. To combine all data into one big list

C. To delete old data permanently

D. To change the app's theme colors

Solution

1. Step 1: Understand pagination concept

   Pagination divides large data into smaller parts called pages.

2. Step 2: Identify benefits of pagination

   This helps apps load data faster and use less memory by not loading everything at once.

3. Final Answer:

   To split data into smaller pages for faster loading and less memory use -> Option A

4. Quick Check:

   Pagination = split data for speed and memory [OK]

Hint: Pagination means loading data in small parts, not all at once [OK]

Common Mistakes:

• Thinking pagination deletes data
• Believing pagination merges all data
• Confusing pagination with UI themes

2. Which Kotlin code snippet correctly represents fetching page 2 with page size 10?

easy

A. val page = 2
val size = 10
val start = size - page

B. val page = 2
val size = 10
val start = page * size

C. val page = 2
val size = 10
val start = (page - 1) * size

D. val page = 2
val size = 10
val start = page + size

Solution

1. Step 1: Calculate start index for page 2

   Start index = (page number - 1) * page size, so (2 - 1) * 10 = 10.

2. Step 2: Check code snippets

   val page = 2 val size = 10 val start = (page - 1) * size uses correct formula; others use wrong math.

3. Final Answer:

   val start = (page - 1) * size -> Option C

4. Quick Check:

   Start index formula = (page - 1) * size [OK]

Hint: Start index = (page - 1) times page size [OK]

Common Mistakes:

• Using page * size instead of (page - 1) * size
• Subtracting page from size incorrectly
• Adding page and size instead of multiplying

3. Given this Kotlin code snippet, what will be printed?

val page = 3
val size = 5
val start = (page - 1) * size
println("Loading items from index $start to ${start + size - 1}")

medium

A. Loading items from index 10 to 14

B. Loading items from index 15 to 19

C. Loading items from index 5 to 9

D. Loading items from index 0 to 4

Solution

1. Step 1: Calculate start index

   start = (3 - 1) * 5 = 2 * 5 = 10.

2. Step 2: Calculate end index

   end = start + size - 1 = 10 + 5 - 1 = 14.

3. Final Answer:

   Loading items from index 10 to 14 -> Option A

4. Quick Check:

   Start=10, End=14 [OK]

Hint: End index = start + size - 1 for page ranges [OK]

Common Mistakes:

• Calculating start as page * size
• Forgetting to subtract 1 for end index
• Mixing up start and end indexes

4. What is wrong with this Kotlin pagination code?

val page = 1
val size = 10
val start = page * size
println("Loading items from index $start to ${start + size - 1}")

medium

A. Page size should be multiplied by 2

B. Start index calculation is off by one page

C. Page number should start from 0

D. No error, code is correct

Solution

1. Step 1: Check start index formula

   Correct formula is (page - 1) * size, but code uses page * size.

2. Step 2: Understand impact

   For page 1, start should be 0, but code gives 10, skipping first 10 items.

3. Final Answer:

   Start index calculation is off by one page -> Option B

4. Quick Check:

   Start index must be (page - 1) * size [OK]

Hint: Page 1 start index is zero, so subtract 1 in formula [OK]

Common Mistakes:

• Using page * size instead of (page - 1) * size
• Starting page count at 0 incorrectly
• Assuming no off-by-one errors

5. You want to load pages of data in your app. If the total data size is 47 items and page size is 10, how many pages do you need to load all items?

hard

A. 4

B. 7

C. 6

D. 5

Solution

1. Step 1: Calculate full pages

   47 items divided by 10 per page gives 4 full pages (4 * 10 = 40 items).

2. Step 2: Account for leftover items

   Remaining 7 items need an extra page, so total pages = 4 + 1 = 5.

3. Step 3: Re-check calculation

   Wait, 4 full pages cover 40 items, leftover 7 items need 1 page, total 5 pages.

4. Final Answer:

   5 -> Option D

5. Quick Check:

   Pages = ceil(47/10) = 5 [OK]

Hint: Divide total items by page size and round up [OK]

Common Mistakes:

• Using integer division without rounding up
• Counting only full pages
• Miscounting leftover items