API interface definition in Android Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a Retrofit API interface method for a GET request.

Android Kotlin

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

Drag options to blanks, or click blank then click option'

ACall

BResponse

CDeferred

DObservable

Attempts:

3 left

💡 Hint

Common Mistakes

Using Response instead of Call causes compilation errors.

Using Deferred requires additional coroutine setup.

The Retrofit interface method returns a Call object for asynchronous requests.

2fill in blank

medium

Complete the code to define a POST request method with a JSON body parameter.

Android Kotlin

interface ApiService {
    @POST("posts")
    suspend fun createPost(@Body [1]: Post): Response<Post>
}

Drag options to blanks, or click blank then click option'

ApostData

BpostBody

Cbody

Dpost

Attempts:

3 left

💡 Hint

Common Mistakes

Using ambiguous parameter names reduces code clarity.

Forgetting the @Body annotation causes runtime errors.

The parameter name can be anything, but post is a clear and common choice.

3fill in blank

hard

Fix the error in the interface method to correctly define a query parameter.

Android Kotlin

interface ApiService {
    @GET("search")
    suspend fun searchUsers(@Query("query") [1]: String): Response<List<User>>
}

Drag options to blanks, or click blank then click option'

AsearchTerm

BqueryString

Cquery

Dterm

Attempts:

3 left

💡 Hint

Common Mistakes

Using a parameter name different from the query key without specifying it causes errors.

Omitting the @Query annotation breaks the query parameter.

The parameter name must match the query key or be clearly related; here, 'query' matches the @Query key.

4fill in blank

hard

Fill both blanks to define a header parameter and a path parameter in the API interface.

Android Kotlin

interface ApiService {
    @GET("users/[1]")
    suspend fun getUser(@Header("Authorization") [2]: String): Response<User>
}

Drag options to blanks, or click blank then click option'

AuserId

BauthToken

Ctoken

Did

Attempts:

3 left

💡 Hint

Common Mistakes

Using ambiguous names for path or header parameters.

Forgetting to annotate parameters with @Header or path placeholder.

The path parameter is typically named userId to identify the user, and the header parameter for authorization is commonly named authToken.

5fill in blank

hard

Fill all three blanks to define a PATCH request with path, header, and body parameters.

Android Kotlin

interface ApiService {
    @PATCH("posts/[1]")
    suspend fun updatePost(@Header("Authorization") [2]: String, @Body [3]: Post): Response<Post>
}

Drag options to blanks, or click blank then click option'

ApostId

BauthHeader

Cpost

Dtoken

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up parameter names causing confusion.

Omitting necessary annotations like @Body or @Header.

The path parameter is postId to identify the post, the header parameter is token for authorization, and the body parameter is post representing the updated post data.

Practice

1. What is the main purpose of defining an API interface in Android Kotlin using Retrofit?

easy

A. To store data locally on the device

B. To specify how the app communicates with web services

C. To create UI components for the app

D. To manage app navigation between screens

Solution

1. Step 1: Understand API interface role

   An API interface defines methods that describe how the app sends requests and receives responses from web services.

2. Step 2: Identify the correct purpose

   It is not related to UI, local storage, or navigation but specifically to communication with web services.

3. Final Answer:

   To specify how the app communicates with web services -> Option B

4. Quick Check:

   API interface = communication with web services [OK]

Hint: API interfaces define web communication methods [OK]

Common Mistakes:

• Confusing API interface with UI components
• Thinking API interfaces handle local data storage
• Assuming API interfaces manage app navigation

2. Which of the following is the correct way to define a GET request method in a Retrofit API interface?

easy

A. @GET("users") fun getUser(): Call<User>

B. @GET fun getUser(): User

C. fun getUser(): Call<User>

D. fun getUser() @GET("users"): Call<User>

Solution

1. Step 1: Recall Retrofit syntax for GET

   Retrofit uses @GET annotation with the endpoint path as a string parameter before the method declaration.

2. Step 2: Check method return type and annotation placement

   The method should return Call<User> and the annotation must be above the method signature.

3. Final Answer:

   @GET("users") fun getUser(): Call<User> -> Option A

4. Quick Check:

   @GET("endpoint") before method with Call return [OK]

Hint: Annotations go above method with endpoint string [OK]

Common Mistakes:

• Placing @GET after method name
• Omitting endpoint path in @GET
• Returning User directly instead of Call<User>

3. Given this Retrofit interface method:

@POST("login")
fun loginUser(@Body user: User): Call<Response>

What happens when loginUser is called?

medium

A. Throws a compile-time error due to missing annotation

B. Sends a GET request to 'login' without any data

C. Sends a POST request to 'login' with user data in the body

D. Returns user data without network call

Solution

1. Step 1: Analyze the method annotation and parameters

   The method uses @POST("login") which means it sends a POST request to the 'login' endpoint.

2. Step 2: Understand the @Body parameter

   The @Body annotation sends the 'user' object as the request body in the POST request.

3. Final Answer:

   Sends a POST request to 'login' with user data in the body -> Option C

4. Quick Check:

   @POST with @Body sends data in POST request [OK]

Hint: @POST with @Body sends data in request body [OK]

Common Mistakes:

• Confusing POST with GET request
• Ignoring the @Body annotation
• Assuming no network call happens

4. Identify the error in this Retrofit API interface method:

@GET("users/{id}")
fun getUser(@Path userId: Int): Call<User>

medium

A. The return type Call<User> is incorrect

B. The method is missing the @Body annotation

C. The method should use @POST instead of @GET

D. The @Path parameter name does not match the placeholder in the URL

Solution

1. Step 1: Check the URL placeholder and @Path parameter

   The URL has {id} but the parameter is named userId, so they do not match.

2. Step 2: Understand Retrofit @Path usage

   The name inside @Path must match the placeholder in the URL exactly to replace it correctly.

3. Final Answer:

   The @Path parameter name does not match the placeholder in the URL -> Option D

4. Quick Check:

   @Path name must match URL placeholder [OK]

Hint: Match @Path name exactly with URL placeholder [OK]

Common Mistakes:

• Using different names for @Path and URL placeholder
• Confusing @GET with @POST
• Adding unnecessary @Body in GET request

5. You want to define an API interface method that sends a POST request to "submit" with a JSON body and expects a Map response. Which is the correct method signature?

hard

A. @POST("submit") fun submitData(@Body data: Map): Call>

B. fun submitData(@Body data: Map): Map

C. @POST fun submitData(data: Map): Call>

D. @POST("submit") fun submitData(@Body data: Map): Map

Solution

1. Step 1: Confirm the annotation and endpoint

   The method must have @POST("submit") to specify the POST request and endpoint.

2. Step 2: Check parameter and return types

   The parameter should be annotated with @Body to send JSON data, and the return type should be Call> for Retrofit's asynchronous call.

3. Final Answer:

   @POST("submit") fun submitData(@Body data: Map): Call> -> Option A

4. Quick Check:

   @POST with @Body and Call return type [OK]

Hint: Use @POST with @Body and Call<> return type [OK]

Common Mistakes:

• Omitting endpoint path in @POST
• Returning Map directly instead of Call<Map>
• Missing @Body annotation on parameter