Networking and Data

1. Networking Fundamentals

Q: Explain the OSI model layers relevant to mobile development.

Key Takeaway: Android developers mostly live in Layer 7 (Application), but Layer 4 (Transport) decisions (QUIC/UDP vs TCP) drastically affect app performance on unstable mobile networks.

Q: TCP vs UDP—when would you use each?

Mobile apps typically use TCP (via HTTP) for reliability. UDP for real-time where dropped packets are acceptable.

Q: Explain HTTP/1.1 vs HTTP/2 vs HTTP/3.

OkHttp supports HTTP/2 by default. HTTP/3 adoption is growing.

Q: What is TLS/SSL and why is it important?

TLS (Transport Layer Security) encrypts communication:

• Confidentiality: Data can't be read in transit
• Integrity: Data can't be modified
• Authentication: Server proves identity via certificate

Android enforces HTTPS by default (cleartext blocked). TLS 1.2+ required for modern apps.

Q: What happens during a TLS handshake?

1. Client sends supported cipher suites
2. Server chooses cipher, sends certificate
3. Client verifies certificate against trusted CAs
4. Key exchange (asymmetric) establishes session key
5. Symmetric encryption begins

This adds latency; HTTP/2 and HTTP/3 reduce repeat handshakes.

2. REST & API Design

Q: What is REST and its principles?

REST (Representational State Transfer) is an architectural style:

Q: Explain HTTP methods and when to use each.

Idempotent: Same request multiple times = same result Safe: Doesn't modify server state

Q: What are common HTTP status codes?

Q: REST vs GraphQL vs gRPC?

3. WebSocket & Real-Time

Q: When would you use WebSocket instead of HTTP?

Use WebSocket for: chat, live updates, collaborative editing, gaming.

Q: How does WebSocket work?

1. HTTP request with Upgrade: websocket header
2. Server responds 101 Switching Protocols
3. Connection upgrades to WebSocket
4. Full-duplex communication over same TCP connection
5. Either side can close

Q: What alternatives exist for real-time updates?

4. Retrofit & OkHttp

Q: Explain the Android networking stack.

The typical stack consists of:

• Retrofit: Type-safe HTTP client. It uses annotations/reflection to generate API code.
• OkHttp: The engine. Handles raw TCP connections, connection pooling, caching, and retries.
• Serialization: Gson, Moshi, or Kotlinx.serialization (KxS) to convert JSON ↔ Objects.

Snippet: Retrofit Interface

interface ApiService {
    @GET("users/{id}")
    suspend fun getUser(@Path("id") userId: String): User
}

Q: What are interceptors and what types exist?

Interceptors observe, modify, and potentially short-circuit requests/responses.

Common interceptors:

• Authentication: Add auth headers to every request
• Logging: Log request/response for debugging
• Retry: Retry failed requests with backoff
• Caching: Custom cache control

Q: How do you handle authentication token refresh?

Use an Authenticator (not interceptor). When a 401 is received, the authenticator refreshes the token and retries the request. This handles the race condition of multiple simultaneous requests hitting 401.

Q: How do you handle errors?

Map HTTP errors to domain exceptions:

• IOException: Network failures (no connection, timeout)
• HttpException: Server returned error status (401, 404, 500)

Create sealed classes like Result<T> or NetworkResult<T> to represent Success/Error states uniformly.

5. Room Database

Q: What is Room and its components?

Room is Jetpack's SQLite abstraction providing:

• Entity: Data class representing a table (@Entity).
• DAO: Interface for database access (@Dao).
• Database: The main access point (@Database).

Snippet: Room Basics

@Entity(tableName = "users")
data class User(@PrimaryKey val id: String, val name: String)

@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    fun getAll(): Flow<List<User>> // Observable query

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insert(user: User)
}

Q: How does Room integrate with reactive streams?

DAOs can return Flow<T> or LiveData<T> for observable queries. When data changes, observers automatically receive updates.

Q: What are common Room annotations?

Q: How do you handle database migrations?

Define Migration objects specifying how to alter schema from version N to N+1. Room runs migrations sequentially. If migration is missing, Room throws an exception (fail-safe). Use fallbackToDestructiveMigration() only for development.

Q: What about testing Room?

Use in-memory database for tests:

Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java)
    .allowMainThreadQueries() // Only for tests!
    .build()

6. DataStore

Q: What is DataStore and how does it differ from SharedPreferences?

DataStore is the modern replacement for SharedPreferences:

Q: What are the two types of DataStore?

1. Preferences DataStore: Key-value pairs, like SharedPreferences but async
2. Proto DataStore: Typed objects using Protocol Buffers, schema-defined

Q: When do you use each?

• Preferences DataStore: Like generic SharedPreferences. Uses edit { settings -> settings[KEY] = value }.
• Proto DataStore: Uses a .proto schema. Guarantee types at compile time.

Snippet: Preferences Keys

val USER_AGE = intPreferencesKey("user_age")
val IS_PREMIUM = booleanPreferencesKey("is_premium")
// Usage: context.dataStore.data.map { prefs -> prefs[IS_PREMIUM] ?: false }

7. Caching Strategies

Q: What caching strategies are common in Android?

Q: How do you implement cache-first with Room + Retrofit?

1. Repository observes Room via Flow
2. On request, emit cached data immediately
3. Fetch from network in parallel
4. Insert network data into Room
5. Room Flow automatically emits updated data

NetworkBoundResource Pattern: This is the industry standard for offline-first apps. It exposes a single Flow<Result<Type>> that emits: Loading → Success(CachedData) → Loading → Success(FreshData).

Q: How do you determine cache validity?

• Timestamp-based: Store fetch time, expire after duration
• ETags: Let server determine if data changed
• Server-provided expiry: Use Cache-Control headers
• Event-based: Invalidate on specific user actions

8. Pagination

Q: How does Paging 3 work?

Paging 3 loads data in chunks as the user scrolls:

Q: PagingSource vs RemoteMediator?

• PagingSource alone: Simple pagination, network-only or database-only
• RemoteMediator + PagingSource: Offline-first. RemoteMediator fetches network data into DB, PagingSource loads from DB. Best practice for production apps.

Snippet: PagingSource Stub

class UserPagingSource(val api: ApiService) : PagingSource<Int, User>() {
    override suspend fun load(params: LoadParams<Int>): LoadResult<Int, User> {
        // 1. Load data from network
        // 2. Return LoadResult.Page(data, prevKey, nextKey)
    }
}

Q: How do you handle errors and retry in Paging?

LoadState contains Loading, NotLoading, and Error states for prepend, append, and refresh. Display loading/error UI based on these states. Provide retry action that calls adapter.retry().

9. Image Loading

Q: What does an image loading library do?

• Async download with disk/memory caching
• Image transformations (resize, crop, round)
• Placeholder and error images
• Lifecycle awareness (cancel on destroy)
• Memory management (avoid OOM)

Q: Coil vs Glide?

Both are excellent. Coil is preferred for new Kotlin-only projects; Glide for maximum feature set.

Q: How do you optimize image loading?

• Request correct size (don't load 4000px for 100dp view)
• Use appropriate format (WebP for compression)
• Enable hardware bitmaps where supported
• Cache appropriately (memory for frequent, disk for all)
• Preload upcoming images in lists

10. Advanced Scenarios & Security

Q: What is Certificate Pinning?

It defends against Man-in-the-Middle (MitM) attacks by hardcoding the expected server certificate (or public key hash) in the app.

• How: Configure CertificatePinner in OkHttp.
• Trade-off: If the server rotates keys without app update, the app breaks. Pin the backup keys too.

Q: How do you handle large file downloads?

Q: Strategies for Offline Sync Conflicts?

When local data differs from server data:

1. Last Write Wins: Server timestamp dictates truth. Simple/Common.
2. User Resolution: Prompt user to keep "Local" or "Server" version.
3. Merge/diff: Smart merge if fields don't overlap.

Q: JSON Parsing Performance: Reflection vs Code Gen?

• Reflection (Gson): Easiest setup, but slower configuration at runtime. Bad for cold start.
• Code Gen (Moshi-kapt / KxS): Generates adapters at compile time. Faster runtime, smaller footprint, better for large apps.

Q: How does Doze Mode affect networking?

Doze mode defers background network activity when the device is idle to save battery.

• Restrictions: Network access is suspended, wakelocks are ignored, alarms are deferred.
• Solution: Use WorkManager for deferrable jobs (it honors maintenance windows) or FCM High Priority messages for immediate requirements.

Quick Reference