API interface definition in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

📝 Syntax

intermediate

Correct Kotlin interface syntax for API calls

Which option correctly defines a Kotlin interface method for a GET request to fetch a list of users using Retrofit?

Android Kotlin

interface ApiService {
  @GET("users")
  suspend fun getUsers(): List<User>
}

A

interface ApiService {
  @GET("users")
  suspend fun getUsers(): List<User>
}

B

interface ApiService {
  @GET("users")
  fun getUsers(): List<User>
}

C

interface ApiService {
  @GET("users")
  fun getUsers(): Call<List<User>>
}

D

interface ApiService {
  @GET("users")
  suspend fun getUsers(): List<String>
}

💡 Hint

Remember Retrofit uses suspend functions for coroutines and the return type should match the expected data.

Option A correctly uses suspend fun with the expected return type List. Option A misses suspend, so it won't work with coroutines. Option A returns Call> which is not a suspend function. Option A returns List which mismatches the expected User type.

❓ ui_behavior

intermediate

API interface method effect on UI loading state

Given a Retrofit API interface method defined as a suspend function, what is the expected UI behavior when calling it inside a coroutine?

A The API call runs synchronously and updates UI automatically.

B The UI thread blocks until the API call finishes, freezing the app.

C The API call runs on a background thread but UI updates must be done manually on the main thread.

D The API call runs asynchronously without blocking the UI thread, allowing loading indicators to show.

💡 Hint

Think about how suspend functions work with coroutines and UI responsiveness.

Suspend functions in Retrofit run asynchronously without blocking the UI thread, so loading indicators can show while waiting. UI updates must be done on the main thread, but the call itself does not block UI.

❓ lifecycle

advanced

Handling API interface calls during Android lifecycle changes

What is the best practice to avoid memory leaks when calling a Retrofit API interface method inside an Android Activity that may be destroyed during the call?

A Use lifecycleScope in the Activity to launch the coroutine for the API call.

B Call the API method directly inside the Activity without lifecycle awareness.

C Use GlobalScope to launch the coroutine for the API call.

D Call the API method inside a background thread without coroutine.

💡 Hint

Consider how Android lifecycleScope helps manage coroutines tied to lifecycle.

Using lifecycleScope ties the coroutine to the Activity lifecycle, automatically cancelling it if the Activity is destroyed, preventing memory leaks. GlobalScope is not lifecycle-aware and can cause leaks. Direct calls without coroutine or lifecycle awareness risk leaks.

❓ navigation

advanced

Navigating after successful API interface call

After a successful login API call defined in an interface, what is the correct way to navigate from LoginActivity to HomeActivity?

Android Kotlin

val response = apiService.loginUser(credentials)
if (response.isSuccessful) {
  // Navigate to HomeActivity
}

A

finish()
startActivity(Intent(this, HomeActivity::class.java))

B startActivity(Intent(this, HomeActivity::class.java))

C

startActivity(Intent(this, HomeActivity::class.java))
finish()

D Intent(this, HomeActivity::class.java).apply { start() }

💡 Hint

Think about removing LoginActivity from back stack after navigation.

Option C starts HomeActivity and finishes LoginActivity to prevent returning to login screen on back press. Option C does not finish LoginActivity, so back button returns there. Option C finishes before starting, which may cause errors. Option C uses incorrect method start() instead of startActivity().

🔧 Debug

expert

Identify the cause of runtime error in Retrofit API interface call

Given this Retrofit interface method: interface ApiService { @POST("submit") suspend fun submitData(@Body data: DataModel): Response } And this call: val response = apiService.submitData(data) The app crashes with: kotlin.KotlinNullPointerException at submitData. What is the most likely cause?

A The Response<Unit> return type is invalid and causes null pointer.

B The data parameter passed to submitData is null.

C The Retrofit interface method is missing suspend keyword.

D The @POST annotation URL is incorrect causing null pointer.

💡 Hint

NullPointerException usually means a null value was used where not allowed.

Passing a null data parameter to a suspend function expecting a non-null @Body causes KotlinNullPointerException. Missing suspend would cause compile error, not runtime. Response is valid. Incorrect URL causes HTTP errors, not null pointer.