Unit 3 - Practice Quiz

Retrofit is a library that simplifies making network requests to web services and handling their API responses in a type-safe manner.

Retrofit is an open-source HTTP client library developed and maintained by Square, Inc.

The Retrofit.Builder class uses the builder pattern to configure and create a new Retrofit instance, allowing you to set the base URL, converters, and other options.

External library dependencies like Retrofit are added to the dependencies block in the module-level build.gradle file.

The @GET annotation is used on a method in your API interface to declare that it will perform an HTTP GET request, which is typically used for fetching data from a server.

Retrofit turns your API into a Java/Kotlin interface. You define endpoints as methods within this interface, using annotations like @GET, @POST, etc. to specify the HTTP method and URL.

The @Path annotation binds the value of a method parameter to a named placeholder in the URL path. For example, in /users/{id}, @Path("id") would replace {id}.

The @Query annotation adds a parameter to the URL's query string. For example, @Query("sort") sortBy: String with the value "new" would append ?sort=new to the URL.

Gson is a library from Google used to convert Java/Kotlin Objects into their JSON representation and vice versa. It's frequently integrated with Retrofit via GsonConverterFactory.

A data class (in Kotlin) or a POJO (Plain Old Java Object) defines the fields that match the keys in the JSON data. A converter like Gson uses this model to automatically parse the JSON into an object.

Calling .addConverterFactory(GsonConverterFactory.create()) on the Retrofit builder registers Gson as the converter that will handle converting JSON responses into objects and vice versa.

RecyclerView is a highly efficient and flexible component designed for displaying large, scrollable lists of data, making it ideal for showing data fetched from an API.

By default, converters like Gson map the keys from the JSON object to the properties in your data class that have the exact same name.

The enqueue() method asynchronously sends the request and notifies your app with a callback when a response is ready, without blocking the main thread. execute() runs the request synchronously.

Long-running operations like network calls must be done off the main (UI) thread. Asynchronous execution keeps the UI responsive to user input, preventing ANR errors.

The suspend keyword marks a function as one that can be paused and resumed later. Retrofit uses this to perform the network request on a background thread without blocking the calling coroutine.

An OkHttp Interceptor is the ideal solution. It can intercept every outgoing request, allowing you to dynamically add a header (like Authorization) before the request is sent to the server.

The Authorization header is the standard HTTP header for sending credentials. For token-based authentication, the value is typically formatted as Bearer {your_token}.

The @Header annotation lets you add a custom HTTP header to a single API call by passing it as a method parameter. For adding a header to all requests, an Interceptor is preferred.

The @Body annotation is used on a method parameter to specify that its value (usually a data class instance) should be serialized and used as the HTTP request body.

Retrofit iterates through the list of converters in the order they were added. It uses the first one that can handle the given type. Therefore, the order of adding converters is significant.

A base URL is mandatory for Retrofit to resolve the relative paths defined in the API interface. Without it, Retrofit will throw an IllegalStateException when you try to create the service.

The annotated interface acts as a blueprint. Retrofit uses Java's dynamic proxy feature to create a concrete implementation of this interface that handles making the HTTP requests based on the annotations.

While Retrofit creates a default OkHttpClient, providing a custom one allows for fine-grained control over the networking layer, which is essential for production apps to handle things like logging, authentication headers, and connection timeouts.

The @Path("id") annotation replaces the {id} placeholder in the URL with the value 42. The @Query("sort") annotation appends ?sort=desc as a query parameter to the URL.

You use @Body to pass a complete object that a converter (like Gson) will serialize into the request body. In contrast, @Field is used with the @FormUrlEncoded annotation to send data as if it were from an HTML form.

@Header("X-Request-ID") requestId: String allows you to pass the value for the header dynamically when you invoke the method. @Headers is for static headers, and @HeaderMap is for when you have multiple dynamic headers to pass in a Map.

The @FormUrlEncoded annotation specifies the request's MIME type. The @Field("key") annotation then provides the individual key-value pairs that will be form-encoded into the request body.

When using @Url, the parameter provides the full URL for the request, completely overriding the base URL and any relative path in the @GET, @POST, etc., annotation. Therefore, the path in the method annotation (e.g., @GET("")) must be empty.

By default, Gson is lenient and will simply ignore any fields in the JSON that do not have a corresponding property in the target Java/Kotlin object. This makes APIs more robust to changes.

The @SerializedName annotation is provided by the Gson library specifically for this purpose. It tells Gson to map the JSON key specified in the annotation to the class property it annotates.

To map a JSON array to a collection of objects, you should use a parameterized type like List<T> or Array<T> (which can be represented as User[] in Java). Call<List<User>> is the most common and idiomatic way to handle a list of objects in Kotlin/Java.

A TypeAdapter gives you complete control over serialization and deserialization. It's perfect for handling non-standard or inconsistent JSON structures, such as a field that is sometimes an object and sometimes an array, which would otherwise cause a parsing error.

Calling a blocking network operation like execute() on the Android main thread will cause a NetworkOnMainThreadException. enqueue() is designed for Android's event-driven model, performing work in the background and posting results back on the main thread.

suspend functions allow you to write asynchronous operations as if they were synchronous. You can use standard try-catch blocks for error handling and the code is generally more readable and maintainable than nested callbacks.

The onFailure() callback is reserved for network errors (e.g., no internet connection). An HTTP error code like 404 is a valid response from the server, so onResponse() is called. You must then check response.isSuccessful() (which checks for codes in the 200-299 range) to determine if the call succeeded.

Retrofit's coroutine adapter throws exceptions for failures. Network-level issues (like timeouts) typically throw an IOException, while HTTP error codes (like 4xx or 5xx) throw an HttpException. These must be caught using a standard try-catch block.

An OkHttp Interceptor is the ideal solution. It intercepts every request before it's sent, allowing you to modify it (e.g., by adding a header). This is centralized, reusable, and separates authentication logic from the API interface definitions.

OkHttp's Authenticator is specifically designed for this purpose. It is invoked automatically when the server responds with a 401 or 407 status code, giving you a chance to refresh the token and return a new request with the updated credentials, which OkHttp will then retry.

An interceptor provides a single, centralized place to modify all outgoing requests. You can get the original request's URL, use HttpUrl.Builder to add the api_key query parameter, and then build a new request to proceed with. This avoids cluttering every method in your API interface with the same parameter.

Retrofit iterates through its list of converter factories in the order they were added. For a given type, it calls the factory's responseBodyConverter method. If a factory returns null, it signifies that it cannot handle that specific type, and Retrofit proceeds to the next factory in the list. The call only fails if no registered factory can handle the type.

When multiple threads fail authentication simultaneously, they all enter the authenticate method. Without synchronization, each will independently trigger a token refresh request, which is inefficient and can lead to server-side issues. The standard solution is to use a synchronized block. The first thread entering performs the refresh, while subsequent threads wait. Once the token is refreshed, waiting threads can retry their original request with the new token.

This scenario demonstrates structured concurrency and exception propagation in coroutines. When multiple async builders are used within a coroutine scope, a failure in any one of them will cause the parent job (and thus all other child jobs in that scope) to be cancelled immediately. When postsDeferred.await() throws the exception, the parent Job is cancelled. Even if userDeferred had completed, its result is effectively discarded because the coroutine is cancelled before the result can be used, and the exception propagates up.

While Retrofit's converters can automatically convert objects to RequestBody for @Body, this mechanism does not apply to @Part in the same way for complex types like JSON. To explicitly set the Content-Type for a multipart part, you must manually create a RequestBody using RequestBody.create(), specifying the correct MediaType (application/json) and the raw JSON string as the content.

Moshi provides excellent support for polymorphism with sealed classes. By annotating the sealed parent class with @JsonClass(generator = "sealed:<label_key>") (where <label_key> is the field name, e.g., "type"), you instruct Moshi to use this field to determine which subclass to deserialize into. Each subclass can then be annotated with @Json(name = "<label_value>") to map it to a specific value of the type field.

If the token refresh call itself fails with a 401 error, and it uses the same OkHttpClient, it will re-trigger the same Authenticator, leading to an infinite recursive loop. To break this cycle, you must ensure the refresh call does not trigger the authenticator. The cleanest way is to use a dedicated OkHttpClient instance for the refresh service that omits the Authenticator. Alternatively, you could add a distinguishing header to the refresh request and add logic to your Authenticator to ignore 401s for requests with that header.

The @Url annotation is designed to completely replace the base URL configured on the Retrofit instance. As such, it requires a fully-qualified URL including the scheme (e.g., https://). If a relative path is provided, Retrofit cannot resolve it and will throw an IllegalArgumentException at runtime, stating that the URL must have a scheme.

When a suspend function returns the direct body type T, Retrofit's suspend adapter will check if the response was successful (in the 2xx range). If not, it throws an HttpException. This forces you to use try-catch for server-side errors. Conversely, returning Response<T> wraps the result. The call itself succeeds from the perspective of the coroutine (no exception is thrown for HTTP error codes), and you receive a Response object where you must manually check response.isSuccessful() and handle the success or error case by parsing response.body() or response.errorBody().

By default, Retrofit's @DELETE annotation does not permit a request body, as it's unconventional for the DELETE HTTP method. Attempting to add a @Body will result in a compile-time error. To override this behavior for APIs that require it, you must use the more generic @HTTP annotation, explicitly specifying the method, path, and setting the hasBody parameter to true.

This is a classic data inconsistency problem best solved at the parsing layer. A custom JsonAdapter (for Moshi) or TypeAdapter (for Gson) gives you direct control over the parsing stream. By peeking at the next JSON token (JsonReader.peek()), you can detect whether the incoming value is an array or an object and handle each case gracefully within a single parsing logic, mapping the inconsistent API behavior to a consistent data model.

A Converter.Factory handles data format conversion. A CallAdapter.Factory, on the other hand, determines the return type of your service methods. Retrofit's default adapter supports Call<T>. The kotlinx-coroutines-adapter adds support for suspend functions. If you want your service methods to return a different container type, like an RxJava observable (Single, Observable) or a custom sealed class for handling success/failure (e.g., ApiResponse<T>), you must provide a CallAdapter.Factory that knows how to create and handle that specific type.

Returning null from the authenticate method is the signal to OkHttp/Retrofit that authentication has failed and cannot be recovered (e.g., the refresh token is invalid). This action causes the original request to fail permanently. Furthermore, OkHttp will not attempt any other requests that were enqueued and waiting for authentication, and it will fail all of them immediately. It is the definitive 'give up' signal.

Retrofit is designed to handle nullable query parameters gracefully. If the value passed to a @Query annotated parameter is null, Retrofit simply omits that parameter and its key from the generated URL. Kotlin's default parameter values work as expected; if the caller does not provide a value for sort, the compiler will pass the default value "asc", which Retrofit will then include in the URL as sort=asc.

Gson's default behavior is to skip fields in a data class that are not present in the JSON payload. For a lateinit var, this means the property is never assigned a value during deserialization. The creation of the object itself succeeds, but the property remains in an uninitialized state. The application will only crash with an UninitializedPropertyAccessException at the point where your code first attempts to read or write to that specific property.

The flatMapLatest operator is key to building responsive UIs that depend on the latest data. When a new value is emitted by the upstream flow (searchQuery), flatMapLatest cancels the coroutine that was executing the block for the previous value. Because Retrofit's suspend functions are cancellable, this action effectively cancels the in-flight network request, preventing outdated results from being processed and ensuring system resources are used efficiently for the most recent user input.

Application interceptors operate on the high-level, logical request and see it only once, before any network-level concerns like redirects or retries. Network interceptors operate closer to the wire. They see the request as it's about to be sent over the network. In a redirect scenario, the network interceptor will fire for the initial request, see the 301 response, and then fire again for the new request that OkHttp automatically creates to follow the redirect.

The primary purpose of @QueryMap is to provide flexibility. When you have a variable number of query parameters (e.g., for applying user-selected filters), you can construct a Map with these filters at runtime and pass it to @QueryMap. This avoids having to define a method with a potentially huge number of nullable @Query parameters. @Query is used when the parameters are fixed and known at compile time.

While no client-side storage is 100% secure, storing secrets in native code (NDK) offers significantly higher protection than other methods. Java/Kotlin bytecode (even when obfuscated) is easier to decompile and analyze than compiled native machine code. BuildConfig fields and XML resources are trivial to extract from an APK. Storing the key in a .so native library and loading it via JNI makes it much harder for attackers to find the key through static analysis.

This question tests the core principle of supervisorScope (or SupervisorJob). Unlike a regular coroutineScope, a supervisorScope's cancellation policy is that a failure in one child does not affect the scope itself or any of its other children. The exception is confined to the specific child coroutine where it occurred. This is useful for UI-related tasks where you want independent operations to proceed even if one fails.

callTimeout is the total timeout for the entire call, from the moment the request is initiated to the moment the response is fully read. readTimeout is a more specific timer that applies to the time between receiving consecutive data packets from the server. If the server connects but then takes longer than the readTimeout to start sending the response body, OkHttp will throw a SocketTimeoutException, even if the total time is still within the callTimeout. The most restrictive, relevant timeout is the one that triggers the failure.