Beginner Level (0–1 Years)
1. What is the difference between `val` and `var` in Kotlin, and when might you prefer one over the other?
Answer:
`val` declares a read-only reference, preventing reassignment, while `var` allows reassignment. Use `val` for immutability, especially in Android ViewModels to avoid unintended state changes.
val list = mutableListOf(1); list.add(2) // Valid
var count = 0; count++ // Reassignable2. In Kotlin, what does the `!!` operator do, and why is it considered dangerous?
Answer:
The `!!` operator asserts a nullable value is non-null, throwing a `NullPointerException` if null. It’s dangerous because it bypasses Kotlin’s null safety, but can be used when null is impossible after validation.
val length = name?.length ?: 0 // Safe alternative3. What happens when you try to access an index beyond the size of a Kotlin list?
Answer:
Accessing an index beyond a list’s size throws an `IndexOutOfBoundsException` because Kotlin lists are zero-indexed. This is critical in Android for RecyclerView adapters.
val list = listOf(1, 2, 3)
list[3] // Throws IndexOutOfBoundsException4. What is the difference between `lateinit` and `by lazy` in Kotlin?
Answer:
`lateinit` delays initialization of a non-nullable `var`, common in Android Fragments for views. `by lazy` initializes a `val` on first access, ideal for expensive objects.
lateinit var view: TextView
val data by lazy { loadData() }5. How do you use View Binding in Android to access UI elements?
Answer:
View Binding generates type-safe classes for XML layouts, replacing `findViewById`. Enable in Gradle and use in Activities or Fragments.
private lateinit var binding: ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?) {
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
binding.textView.text = "Hello"
}6. What is a coroutine in Kotlin, and how is it used in Android?
Answer:
Coroutines simplify asynchronous tasks, running non-blocking code. In Android, use `lifecycleScope` for UI-related tasks to avoid leaks.
lifecycleScope.launch { val data = fetchData(); updateUI(data) }7. What does the Elvis operator (`?:`) do in Kotlin?
Answer:
The Elvis operator returns the left expression if non-null, else the right, useful for default UI values in Android.
val title = savedInstanceState?.getString("title") ?: "Default"8. What happens if you use a negative step in a Kotlin `for` loop with the `..` operator?
Answer:
A negative `step` with `..` is invalid, causing a compilation error. Use `downTo` for descending loops.
for (i in 10 downTo 1) { println(i) }9. What is the result of converting a string to an integer and adding a number in Kotlin?
Answer:
Converting a valid string to an integer with `toInt()` and adding a number produces the sum. Invalid strings throw a `NumberFormatException`.
val x = "5"
val y = x.toInt()
println(y + 2) // Prints 710. Can a Kotlin `data class` inherit from another class?
Answer:
Yes, a `data class` can inherit from an `open` class or interface, but not another `data class`. Inheritance is rare due to complexity.
open class Base
data class Child(val id: Int) : Base()11. Why might using `findViewById` be discouraged in modern Android development?
Answer:
`findViewById` is error-prone and verbose. View Binding or Jetpack Compose offers type-safe, concise UI access.
val textView = findViewById(R.id.text) // Risky
binding.textView.text = "Hello" // Safer12. How do you use Android resources (e.g., strings, drawables) in Kotlin?
Answer:
Access resources via `R` or `Context` for localization and theming.
val title = getString(R.string.app_name)
imageView.setImageResource(R.drawable.icon)13. What happens if you forget to call `super.onCreate()` in an Android activity?
Answer:
Skipping `super.onCreate()` skips base class setup, causing crashes or missing UI initialization.
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}14. Can you use a `when` statement without an argument? What’s a use case?
Answer:
A `when` statement without an argument acts like `if-else`, useful for conditional UI logic.
when {
x > 0 -> println("Positive")
x < 0 -> println("Negative")
else -> println("Zero")
}15. How does Kotlin handle default parameters in functions? Can Java code call these?
Answer:
Kotlin supports default parameters; Java requires `@JvmOverloads` for compatibility.
@JvmOverloads
fun display(name: String = "Guest") { println(name) }16. What’s the difference between `let`, `run`, and `apply` in Kotlin?
Answer:
`let` uses `it` and returns the lambda result; `run` uses `this` and returns the result; `apply` uses `this` and returns the object.
view?.let { it.text = "Hello" }
view.run { text = "Hello"; this }
view.apply { text = "Hello" }17. What is the use of `sealed` classes in Kotlin?
Answer:
Sealed classes restrict hierarchies for exhaustive `when` expressions, useful for UI states.
sealed class UiState {
object Loading : UiState()
data class Success(val data: String) : UiState()
}18. What does `@Parcelize` do in Android Kotlin development?
Answer:
`@Parcelize` generates `Parcelable` implementations for data classes, requiring `kotlin-parcelize` plugin, used for passing data via Intents.
@Parcelize
data class User(val id: Int) : Parcelable
val intent = Intent(this, SecondActivity::class.java).putExtra("user", User(1))19. What happens if you modify a list returned by `listOf()`?
Answer:
`listOf()` returns an immutable list, causing errors if modified. Use `mutableListOf()` for mutability.
val list = listOf(1, 2) // Immutable
val mutable = mutableListOf(1, 2); mutable.add(3)20. Explain the lifecycle of an Android `Activity` in brief. Why is `onSaveInstanceState()` important?
Answer:
The Activity lifecycle includes `onCreate`, `onStart`, `onResume`, `onPause`, `onStop`, `onRestart`, `onDestroy`. `onSaveInstanceState()` saves UI state for process death recovery.
override fun onSaveInstanceState(outState: Bundle) {
outState.putString("key", text)
super.onSaveInstanceState(outState)
}21. What’s the issue with starting a long-running task in `onCreate()`?
Answer:
Long-running tasks in `onCreate()` block the UI thread. Use coroutines or `WorkManager`.
lifecycleScope.launch(Dispatchers.IO) { performTask() }22. Can Kotlin interfaces have method implementations?
Answer:
Yes, Kotlin interfaces support default implementations.
interface Clickable {
fun onClick() { println("Clicked") }
}23. What is an `Intent` in Android, and how is it used?
Answer:
An `Intent` requests actions from app components, like starting activities or passing data.
val intent = Intent(this, SecondActivity::class.java)
intent.putExtra("key", value)
startActivity(intent)24. What is the purpose of the `companion object` in Kotlin?
Answer:
A `companion object` defines static-like members, useful for constants or factory methods in Android.
companion object {
const val KEY = "key"
}25. What is the difference between `Activity` and `Fragment` in Android?
Answer:
An `Activity` is a single screen; a `Fragment` is a modular UI component within an Activity, enabling reusable layouts.
supportFragmentManager.beginTransaction()
.replace(R.id.container, MyFragment())
.commit()👋 Need top Android/Kotlin developers for your project? Interview this week!
Fill out the form to book a call with our team. We’ll match you to the top developers who meet your requirements, and you’ll be interviewing this week!
Intermediate Level (1–3 Years)
1. Explain the difference between `CoroutineScope`, `lifecycleScope`, and `viewModelScope` in Android.
Answer:
`CoroutineScope` is a general-purpose scope for launching coroutines, requiring manual cancellation to prevent leaks, making it unsuitable for Android UI tasks without careful management. In Android, lifecycle-aware scopes are preferred:
- `lifecycleScope` is tied to an Activity or Fragment’s lifecycle, automatically cancelling coroutines when the lifecycle reaches `DESTROYED`. Use it for UI-related tasks like animations or one-off API calls.
- `viewModelScope` is tied to a ViewModel’s lifecycle, surviving configuration changes (e.g., rotation) and cancelling when the ViewModel is cleared. Ideal for data fetching or processing tied to UI state.
Using these scopes ensures coroutines respect Android component lifecycles, reducing memory leaks.
class MyViewModel : ViewModel() {
fun fetchData() {
viewModelScope.launch {
val data = apiService.getData()
updateUI(data)
}
}
}
class MyActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
lifecycleScope.launch {
animateView()
}
}
}2. What are inline functions in Kotlin and when should you use them?
Answer:
Inline functions insert the function’s body at the call site, reducing lambda overhead but increasing bytecode size. Use them for small, performance-sensitive higher-order functions, like timing operations:
inline fun measure(block: () -> Unit) {
val start = System.nanoTime()
block()
println(System.nanoTime() - start)
}Avoid overuse to prevent code bloat.
3. What are the benefits and risks of using `LiveData` vs `StateFlow`?
Answer:
`LiveData` is lifecycle-aware and integrates with XML layouts, but it’s less flexible for non-UI logic. `StateFlow` supports Kotlin-first development and coroutines, but requires `repeatOnLifecycle` for lifecycle safety to prevent leaks. Use `StateFlow` with `lifecycleScope` for modern apps.
4. What is the difference between `Dispatchers.IO` and `Dispatchers.Default` in Kotlin Coroutines?
Answer:
`Dispatchers.IO` is optimized for blocking I/O operations (e.g., network, database). `Dispatchers.Default` is for CPU-intensive tasks (e.g., sorting, parsing). Example:withContext(Dispatchers.IO) { fetchNetworkData() }
5. How can you avoid memory leaks when working with Fragments in Android?
Answer:
Prevent leaks by:
- Using View Binding and nullifying in `onDestroyView()`:
private var _binding: FragmentExampleBinding? = null private val binding get() = _binding!! override fun onCreateView(...) { _binding = FragmentExampleBinding.inflate(inflater, container, false) return binding.root } override fun onDestroyView() { _binding = null } - Removing listeners in `onDestroyView()`.
- Avoiding static references to Fragment instances.
6. Can you explain the role of `@JvmStatic` and `@JvmOverloads` annotations in Kotlin?
Answer:
`@JvmStatic` makes a `companion object` method appear static in Java. `@JvmOverloads` generates multiple method signatures for default parameters, improving Java compatibility. Example:@JvmOverloads fun greet(name: String = "Guest") {}
7. What are extension functions and how can they be misused?
Answer:
Extension functions add functionality to classes without inheritance, but they can’t access private members. Misuse includes creating bloated utility classes or naming conflicts. Example:fun String.toTitleCase() = this.replaceFirstChar { it.titlecase() }
8. Describe the use of `sealed` vs `enum` classes in Kotlin.
Answer:
`enum` classes are for fixed constants (e.g., days of the week). `sealed` classes allow subclasses with data, enabling exhaustive `when` expressions for state management:
sealed class Result {
object Loading : Result()
data class Success(val data: String) : Result()
data class Error(val exception: Throwable) : Result()
}9. How do you handle one-time events like navigation or toasts in Android?
Answer:
Use `Channel` for one-time events in ViewModels, consumed in Compose or Fragments:
val events = Channel()
fun sendEvent(event: Event) = events.trySend(event)
LaunchedEffect(Unit) { events.receiveAsFlow().collect { handleEvent(it) } }10. What are the key principles of Jetpack Compose compared to the View system?
Answer:
Jetpack Compose uses a declarative UI model, describing UI as a function of state, eliminating XML and enabling concise code. Unlike the View system, Compose automatically updates UI on state changes.
11. How does `rememberSaveable` differ from `remember` in Jetpack Compose?
Answer:
`remember` stores state in memory, lost on configuration changes. `rememberSaveable` persists state across process death via Bundles, e.g.:val state by rememberSaveable { mutableStateOf("") }
12. What is the role of `suspend` modifier in Kotlin functions?
Answer:
The `suspend` modifier marks functions that can pause and resume in coroutines, enabling non-blocking asynchronous code. Example:suspend fun fetchData() = withContext(Dispatchers.IO) { api.getData() }
13. What’s the difference between `runBlocking`, `launch`, and `async`?
Answer:
`runBlocking` blocks the thread, used rarely in production (e.g., testing). `launch` is fire-and-forget, returning a `Job`. `async` returns a `Deferred` for results:val result = async { fetchData() }.await()
14. Explain how to use `Flow` in Kotlin and when to use `collect`, `map`, and `filter`.
Answer:
`Flow` is a cold asynchronous stream. Use `collect` to consume values, `map` to transform values, and `filter` to select values:
flowOf(1, 2, 3).map { it * 2 }.filter { it > 2 }.collect { println(it) }15. How do you test ViewModel logic that uses coroutines?
Answer:
Use `TestCoroutineDispatcher` and `runTest` to control coroutine execution in unit tests. Example:
@Test
fun testViewModel() = runTest {
val viewModel = MyViewModel()
viewModel.fetchData()
advanceUntilIdle()
assertEquals(expected, viewModel.state.value)
}16. How does the Navigation Component help with Fragment management?
Answer:
The Navigation Component uses a navigation graph for structured Fragment navigation, handling back stack, safe args, and deep links, simplifying transitions and state management.
17. What is `@Composable` in Jetpack Compose, and what does recomposition mean?
Answer:
`@Composable` marks a function that builds UI. Recomposition updates the UI when its state changes, optimizing by only updating affected composables.
18. How do `@HiltViewModel` and `@Inject` work together in Android Hilt?
Answer:
`@HiltViewModel` marks a ViewModel for Hilt to manage. `@Inject` in the constructor provides dependencies automatically:
@HiltViewModel
class MyViewModel @Inject constructor(private val repo: Repository) : ViewModel()19. What’s the lifecycle scope of a ViewModel in Android, and how is it different from an Activity?
Answer:
A ViewModel survives configuration changes and is destroyed when the Activity or Fragment is permanently finished, unlike an Activity, which is recreated on rotation.
20. How would you cancel a long-running coroutine in a ViewModel?
Answer:
Use `viewModelScope` to automatically cancel coroutines on ViewModel clearance, or manually cancel with:val job = viewModelScope.launch { longTask() }; job.cancel()
21. What are some thread-safety concerns when using `Room` database and how are they addressed?
Answer:
Room ensures thread safety for writes via a single-threaded executor. Reads are safe on any thread, and coroutines with `withContext(Dispatchers.IO)` ensure non-blocking database access.
22. What’s the difference between `Modifier.padding()` and `Modifier.offset()` in Compose?
Answer:
`padding()` adds internal space, reducing content area. `offset()` shifts the entire composable without affecting its layout bounds:Modifier.padding(16.dp) // Internal space; Modifier.offset(16.dp) // Shifts position
23. What’s the purpose of `collectLatest` in Kotlin Flow?
Answer:
`collectLatest` cancels the previous collection block if a new value arrives, ideal for rapid updates like search:flow.collectLatest { updateUI(it) }
24. What’s the role of `@Query`, `@Insert`, and `@Delete` annotations in Room?
Answer:
`@Query` executes SQL queries, `@Insert` adds entities, and `@Delete` removes entities by primary key:@Query("SELECT * FROM users") fun getUsers(): List
25. How does `State hoisting` work in Jetpack Compose?
Answer:
State hoisting moves state to a parent composable, making the child stateless and reusable:
@Composable
fun MyScreen(state: State, onEvent: () -> Unit) { /* Stateless UI */ }26. What is the use of `snapshotFlow` in Jetpack Compose?
Answer:
`snapshotFlow` converts Compose state changes to a Flow, emitting updates only when the state changes:snapshotFlow { state.value }.collect { update(it) }
27. What’s the behavior of `repeatOnLifecycle()` in lifecycle-aware coroutine collection?
Answer:
`repeatOnLifecycle(state)` collects a Flow when the lifecycle is at least in `state` (e.g., `STARTED`), stopping when below, preventing leaks:lifecycleScope.launch { repeatOnLifecycle(Lifecycle.State.STARTED) { flow.collect { } } }
28. How do you expose a `StateFlow` from a ViewModel while preventing external mutation?
Answer:
Use a private `MutableStateFlow` and expose a read-only `StateFlow`:
private val _state = MutableStateFlow(Value)
val state: StateFlow = _state.asStateFlow()29. When should you prefer using `WorkManager` over coroutines or services?
Answer:
Use `WorkManager` for deferrable, guaranteed tasks (e.g., syncing data) that survive app restarts, with constraints like network or battery:WorkManager.getInstance(context).enqueue(workRequest)
30. What’s the purpose of `rememberCoroutineScope` in Compose?
Answer:
`rememberCoroutineScope` provides a scope tied to the Composable’s lifecycle for launching coroutines, e.g., for side effects:val scope = rememberCoroutineScope(); scope.launch { fetchData() }
31. How does Hilt provide dependencies in Fragments and ViewModels?
Answer:
Use `@AndroidEntryPoint` for Fragments and `@HiltViewModel` with `@Inject` for ViewModels:
@AndroidEntryPoint
class MyFragment : Fragment() {
@Inject lateinit var repo: Repository
}32. How can you persist user preferences using Jetpack DataStore?
Answer:
Use `PreferencesDataStore` for key-value pairs or `ProtoDataStore` for typed data, replacing SharedPreferences:
val dataStore: DataStore = context.createDataStore("settings")
dataStore.edit { it[KEY_NAME] = "value" }33. How does the `@Stable` annotation help in Jetpack Compose performance?
Answer:
`@Stable` marks types with stable equality, allowing Compose to skip recompositions if unchanged, improving performance. Requires stable `equals()` implementation.
34. What’s the difference between `Modifier.fillMaxSize()` and `Modifier.matchParentSize()`?
Answer:
`fillMaxSize()` occupies all available space, respecting constraints. `matchParentSize()` matches the parent’s exact size, ignoring sibling constraints.
35. What are `keys` in `LaunchedEffect`, and why are they important?
Answer:
Keys in `LaunchedEffect` trigger cancellation and relaunch when changed, ensuring side effects align with state:LaunchedEffect(key) { performAction() }
36. What are the implications of collecting Flow in a non-lifecycle-aware context?
Answer:
Non-lifecycle-aware Flow collection risks leaks or unnecessary processing. Use `repeatOnLifecycle` or `lifecycleScope.launchWhenStarted`:repeatOnLifecycle(Lifecycle.State.STARTED) { flow.collect { } }
37. What is a `Preview` in Jetpack Compose and how can it help?
Answer:
`@Preview` displays Composable UI in Android Studio without running the app, aiding rapid UI iteration and theme testing:@Preview @Composable fun MyScreen() {}
38. How can you handle back-press behavior in Jetpack Compose?
Answer:
Use `BackHandler` to intercept back presses in a Composable:BackHandler { onBackPressed() }
39. What’s the benefit of using `collectAsState()` in Compose?
Answer:
`collectAsState()` converts a Flow to a Compose `State`, triggering recomposition on updates:val state by flow.collectAsState(initial = null)
40. What is `rememberUpdatedState()` used for?
Answer:
`rememberUpdatedState()` ensures long-running effects use the latest state without restarting:val latestState = rememberUpdatedState(state); LaunchedEffect(Unit) { use(latestState.value) }
41. How do you animate visibility in Compose?
Answer:
Use `AnimatedVisibility` with `enter` and `exit` transitions:AnimatedVisibility(visible = isVisible, enter = fadeIn(), exit = fadeOut()) { content() }
42. What’s the correct way to clear resources in a ViewModel?
Answer:
Override `onCleared()` to release resources like timers, network clients, or manual coroutines:
override fun onCleared() {
timer.cancel()
super.onCleared()
}43. What is the difference between `Channel` and `Flow`?
Answer:
`Channel` is a hot stream for one-time, imperative events. `Flow` is a cold, declarative stream that emits on collection:channel.send(event); flow.collect { handle(it) }
44. How can you debounce text input in Compose?
Answer:
Use `LaunchedEffect` with a delay to debounce input:
LaunchedEffect(query) {
delay(300)
viewModel.onSearch(query)
}45. What is the role of `@Singleton` and `@ActivityScoped` in Hilt?
Answer:
`@Singleton` creates a single instance for the app’s lifetime. `@ActivityScoped` ties the instance to an Activity’s lifecycle, reducing memory usage:@Singleton class AppRepo @Inject constructor() {}
46. How does `SavedStateHandle` work with ViewModels in Android?
Answer:
`SavedStateHandle` persists key-value data across process death, injected into ViewModels:
@HiltViewModel
class MyViewModel @Inject constructor(savedStateHandle: SavedStateHandle) : ViewModel() {
val id: String = savedStateHandle.get("id") ?: ""
}47. What are the benefits of using `Paging 3` library in Android?
Answer:
`Paging 3` loads data incrementally, integrating with `Flow` or `LiveData` for smooth UI updates, ideal for large datasets:Pager(PagingConfig(pageSize = 20)) { MyPagingSource() }.flow
48. How do you handle configuration changes in Jetpack Compose?
Answer:
Use `rememberSaveable` for UI state and ViewModels for business logic to persist across configuration changes:val state by rememberSaveable { mutableStateOf("") }
49. What is the difference between `Flow` and `LiveData` for reactive UI updates?
Answer:
`Flow` is a versatile, cold stream for reactive data, requiring lifecycle handling. `LiveData` is lifecycle-aware, optimized for UI updates:flow.collectAsState(initial = null); liveData.observe(owner) {}
50. How would you expose error state in a Compose UI using a ViewModel?
Answer:
Use `StateFlow` to emit error states from the ViewModel, consumed in Compose:
val error by viewModel.errorState.collectAsState()
if (error != null) Text(error)
Hire Top LATAM Developers: Guide
We’ve prepared this guide that covers benefits, costs, recruitment, and remote team management to a succesful hiring of developers in LATAM.
Fill out the form to get our guide.
Advanced Level (3+ Years)
1. What are the main differences between `CoroutineScope` and `SupervisorScope`?
Answer:
`CoroutineScope` uses a regular `Job`, cancelling all children if one fails. `SupervisorScope` uses a `SupervisorJob`, allowing independent child execution. Example:
supervisorScope { launch { throw Exception() }; launch { println("Continues") } }Use `SupervisorScope` for UI tasks where failures shouldn’t affect unrelated coroutines.
2. How would you implement a custom Compose layout similar to `Row` but with spacing logic between children?
Answer:
Use `Layout` to measure and place children with custom spacing:
@Composable
fun SpacedRow(spacing: Dp, modifier: Modifier = Modifier, content: @Composable () -> Unit) {
Layout(content = content, modifier = modifier) { measurables, constraints ->
val placeables = measurables.map { it.measure(constraints) }
val width = placeables.sumOf { it.width } + (placeables.size - 1) * spacing.roundToPx()
val height = placeables.maxOfOrNull { it.height } ?: 0
layout(width, height) {
var xPos = 0
placeables.forEach {
it.place(xPos, 0)
xPos += it.width + spacing.roundToPx()
}
}
}
}3. Explain how Kotlin’s `reified` keyword works and where it’s useful.
Answer:
`reified` preserves type information at runtime in inline functions, enabling type checks or reflection:
inline fun Gson.fromJson(json: String): T =
fromJson(json, T::class.java)Useful for JSON parsing, type-safe navigation, or dependency injection.
4. Describe the architecture and benefits of using MVI (Model-View-Intent) in Android development.
Answer:
MVI follows a unidirectional flow: Intents trigger ViewModel updates, emitting immutable States to the View. Benefits include predictability, testability, and clear separation. Downsides include boilerplate:
sealed class Intent { data class LoadData(val id: String) : Intent() }
data class State(val data: String?, val error: String?)5. How can you ensure consistency between ViewModel state and UI in Compose without over-recomposing?
Answer:
Use `StateFlow` with immutable collections (e.g., `kotlinx.collections.immutable`) and `derivedStateOf` to isolate changes:
val state by viewModel.state.collectAsState()
val derived by derivedStateOf { state.someValue }Hoist state and pass minimal data to Composables.
6. How does the Kotlin compiler optimize `inline` functions, and what are potential downsides?
Answer:
The compiler copies the function body to call sites, avoiding lambda overhead. Downsides include increased bytecode size and issues with non-local returns or large captured scopes:inline fun logIfType(value: Any) { if (value is T) println(value) }
7. What’s the difference between cold and hot Flows in Kotlin? Provide a real-world example for each.
Answer:
Cold Flows (`flow {}`) emit only when collected (e.g., database query). Hot Flows (`StateFlow`, `SharedFlow`) emit independently (e.g., real-time user status updates):
val coldFlow = flow { emit(fetchFromDb()) }
val hotFlow = MutableStateFlow(userStatus)8. How would you handle an exponential backoff retry strategy in Kotlin using Flow?
Answer:
Use `retryWhen` with exponential delay:
flow { emit(apiCall()) }.retryWhen { cause, attempt ->
if (attempt < 3) { delay(2.0.pow(attempt.toDouble()).toLong() * 100); true } else false
}9. How do you handle concurrent updates to shared state in Compose without causing race conditions?
Answer:
Use `MutableStateFlow` with `update` for atomic updates or `Mutex` for thread safety:
private val _state = MutableStateFlow(0)
val state = _state.asStateFlow()
fun update() = _state.update { it + 1 }10. Explain how `SavedStateHandle` integrates with ViewModel and Compose navigation.
Answer:
`SavedStateHandle` persists state across process death, injected into ViewModels. In Compose Navigation, access arguments via:
@HiltViewModel
class MyViewModel @Inject constructor(savedStateHandle: SavedStateHandle) : ViewModel() {
val id: String = savedStateHandle["id"] ?: ""
}11. How would you optimize a Composable that recomposes too frequently due to changing state?
Answer:
Use `derivedStateOf`, hoist state, and break into smaller Composables:
val derived by derivedStateOf { state.value.someProperty }
@Composable fun SmallComposable(data: String) {}12. Describe a situation where using `Flow.combine()` is better than `zip()`.
Answer:
`combine()` emits when any input Flow changes, ideal for dynamic UI updates (e.g., combining user and settings Flows). `zip()` waits for both Flows to emit, suitable for paired data:flow1.combine(flow2) { a, b -> "$a-$b" }
13. How can you debug recomposition in Jetpack Compose?
Answer:
Use Layout Inspector, `Recomposer` tracing, or log recompositions via `SideEffect`. Check state usage to avoid unnecessary triggers:SideEffect { println("Recomposed") }
14. How would you implement dependency injection for a multi-module Android app using Hilt?
Answer:
Define Hilt modules with `@InstallIn(SingletonComponent::class)` in feature modules. Use `@AndroidEntryPoint` and interface abstractions for module boundaries:
@Module
@InstallIn(SingletonComponent::class)
object FeatureModule { @Provides fun provideRepo(): Repo }15. What are the limitations of `StateFlow` in large-scale reactive UI architectures?
Answer:
`StateFlow` retains the latest value, risking memory pressure, and conflates emissions, potentially missing intermediate states. Use `SharedFlow` for events or `Channel` for one-time actions.
16. How can you optimize database access in Room when dealing with frequent updates?
Answer:
Use `@Transaction` for batch updates, avoid `onConflict = REPLACE` overuse, and leverage `PagingSource` for large datasets:
@Transaction
fun updateUsers(users: List) { dao.deleteAll(); dao.insert(users) }17. How does Compose handle side effects and what tools does it provide to manage them safely?
Answer:
Compose offers `LaunchedEffect`, `SideEffect`, `DisposableEffect`, and `rememberUpdatedState` for lifecycle-aware side effects:LaunchedEffect(key) { fetchData() }
18. How would you write a test to validate the UI state transitions of a Composable using `StateFlow`?
Answer:
Use `ComposeTestRule` and `Turbine` to test `StateFlow` emissions:
@Test
fun testState() = runTest {
val stateFlow = MutableStateFlow(0)
composeTestRule.setContent { Text(stateFlow.collectAsState().value.toString()) }
stateFlow.test { assertEquals(0, awaitItem()) }
}19. How would you implement dynamic feature modules with Hilt and Navigation Component?
Answer:
Use `SplitInstallManager` for dynamic loading, `@EntryPoint` for injection, and “ in navigation graphs:
navController.navigate("dynamic_feature_graph")20. What is a memory leak in Android, and how do you detect and fix them in Compose?
Answer:
Memory leaks occur when objects persist unnecessarily. In Compose, use `DisposableEffect` to clean up and detect leaks with LeakCanary or Profiler:
DisposableEffect(Unit) { onDispose { cleanup() } }21. How does Jetpack Compose handle recomposition scope granularity, and how can you take advantage of it?
Answer:
Compose tracks recomposition per Composable. Use small, stateless Composables with stable parameters to minimize recompositions:@Composable fun Item(data: StableData) {}
22. What are `ViewModelStoreOwner` and `SavedStateRegistryOwner`, and when are they needed?
Answer:
`ViewModelStoreOwner` provides ViewModel scope; `SavedStateRegistryOwner` enables state restoration. Required for custom navigation or non-standard Activity/Fragment setups.
23. How would you implement undo/redo logic in a Compose text editor?
Answer:
Use a stack-based state with `MutableState` for undo/redo:
val undoStack = remember { mutableStateListOf() }
val redoStack = remember { mutableStateListOf() }
fun onTextChange(new: String) { undoStack.add(current); redoStack.clear() }24. How would you architect an offline-first Android app using Kotlin and Jetpack components?
Answer:
Use Room for persistence, `Flow` for data observation, `WorkManager` for syncing, and a Repository pattern. Monitor connectivity with `ConnectivityManager`:
val offlineFlow = dao.getItems().flowOn(Dispatchers.IO)25. How does `CoroutineDispatcher` affect coroutine performance and thread usage in Android?
Answer:
`Dispatchers.IO` shares a thread pool for I/O; `Dispatchers.Default` for CPU tasks. Use `Dispatchers.Main` for UI:withContext(Dispatchers.IO) { fetchData() }
26. How can you design a robust analytics tracking system across multiple app modules?
Answer:
Define an `AnalyticsLogger` interface in a core module, implement with Hilt injection, and use sealed classes for events:
sealed class Event { data class ScreenView(val name: String) : Event() }
interface AnalyticsLogger { fun log(event: Event) }27. What are the implications of using `@JvmStatic`, `@JvmOverloads`, and `@JvmField` in Kotlin interop with Java?
Answer:
`@JvmStatic` exposes static methods, `@JvmOverloads` creates default parameter overloads, `@JvmField` exposes properties as fields:@JvmStatic fun create() = MyClass()
28. How does `rememberInfiniteTransition` work and when would you use it?
Answer:
`rememberInfiniteTransition` creates looping animations:
val transition = rememberInfiniteTransition()
val alpha by transition.animateFloat(initialValue = 0f, targetValue = 1f, animationSpec = infiniteRepeatable(tween()))Use for pulsing UI elements or loaders.
29. How can you implement lifecycle-aware observers using Kotlin Flow?
Answer:
Use `flowWithLifecycle` for lifecycle-aware Flow collection:
lifecycleScope.launch {
flow.flowWithLifecycle(lifecycle, Lifecycle.State.STARTED).collect { handle(it) }
}30. How would you secure API keys and secrets in an Android application?
Answer:
Store secrets in NDK or `EncryptedSharedPreferences`. Use server-side token exchange and avoid hardcoding:
val prefs = EncryptedSharedPreferences.create(context, ...)31. What is a `sealed interface` in Kotlin and when would you use one?
Answer:
A `sealed interface` restricts implementations to the same module, ideal for state hierarchies:
sealed interface UiState { object Loading : UiState; data class Success(val data: String) : UiState }32. How do you avoid deep recomposition chains in a large Compose UI tree?
Answer:
Use stateless Composables, hoist state, and ensure stable parameters:
@Composable
fun Item(data: StableData, modifier: Modifier = Modifier) {}33. Describe a strategy to test asynchronous Flows and coroutines in a multi-threaded environment.
Answer:
Use `runTest` with `TestDispatcher` and `Turbine` for Flow testing:
@Test
fun testFlow() = runTest {
flow.test { assertEquals(expected, awaitItem()) }
}34. What are inline classes in Kotlin, and how do they differ from data classes?
Answer:
Inline classes wrap a single value with no runtime overhead:
@JvmInline value class UserId(val id: String)Unlike data classes, they lack multiple properties or destructuring.
35. How would you support A/B testing for UI components in a Compose-based app?
Answer:
Use Firebase Remote Config to select variants, observe with `StateFlow`, and render conditionally:
val variant by remoteConfigFlow.collectAsState()
if (variant == "A") VariantA() else VariantB()36. How can you implement scroll state preservation across navigation in Jetpack Compose?
Answer:
Store `LazyListState` in a ViewModel or use `rememberSaveable` with a custom `Saver`:
val listState = rememberSaveable(saver = LazyListState.Saver) { LazyListState() }37. What are the risks of using coroutines with global mutable state and how do you mitigate them?
Answer:
Risks include race conditions. Mitigate with `Mutex`, `AtomicReference`, or `StateFlow`:
val mutex = Mutex()
mutex.withLock { sharedState.update() }38. How would you approach performance monitoring in a Compose-heavy application?
Answer:
Use `JankStats`, Layout Inspector, and Firebase Performance Monitoring. Optimize recompositions with stable types and `derivedStateOf`:JankStats.createAndTrack(window) { frameData -> log(frameData) }
39. What are the differences between `StateFlow`, `LiveData`, and `SharedFlow` in terms of reactivity and delivery guarantees?
Answer:
`StateFlow` holds the latest value, conflating emissions. `LiveData` is lifecycle-aware, ideal for UI. `SharedFlow` supports multiple collectors and replay:val sharedFlow = MutableSharedFlow(replay = 1)
40. How would you architect a plugin-based Android app where modules can be dynamically loaded at runtime?
Answer:
Use Dynamic Feature Modules, `SplitInstallManager`, and `ServiceLoader` for plugin loading:
splitInstallManager.startInstall(request).addOnSuccessListener { navigate() }41. How does `Modifier.pointerInput` work in Compose, and how would you use it for complex gestures?
Answer:
`Modifier.pointerInput` handles low-level pointer events:
Modifier.pointerInput(Unit) {
awaitPointerEventScope { while (true) { val event = awaitPointerEvent() } }
}Use for custom drag or multi-touch gestures.
42. How would you profile and resolve jank in Compose animations?
Answer:
Use `JankStats`, Systrace, and `Macrobenchmark`. Minimize overdraw and optimize animations:AnimatedVisibility(visible = state, enter = fadeIn(), exit = fadeOut())
43. How would you implement advanced theming (dark/light/custom) in Compose?
Answer:
Use `MaterialTheme` with `DataStore` for theme persistence:
val theme by dataStore.data.collectAsState(initial = Theme.LIGHT)
CompositionLocalProvider(LocalTheme provides theme) { MaterialTheme() { content() } }44. How does Kotlin Multiplatform Mobile (KMM) affect Android development and what are its caveats?
Answer:
KMM shares logic across Android/iOS using Kotlin/Native. Caveats include limited library support and separate UI layers:expect fun getPlatformName(): String
45. How do you optimize app startup time using Baseline Profiles in Android?
Answer:
Baseline Profiles precompile critical code paths, generated via `Macrobenchmark` and integrated in Gradle:
android { baselineProfile { enabled = true } }46. What are the benefits and challenges of using `kotlinx.coroutines.flow.buffer` in high-throughput scenarios?
Answer:
`buffer` decouples emission and collection, improving throughput but risking memory pressure:
flow.buffer(Capacity.CONFLATED).collect { process(it) }47. How do you implement custom navigation animations in Jetpack Compose Navigation?
Answer:
Use `AnimatedNavHost` with custom transitions:
AnimatedNavHost(navController, startDestination = "home") {
composable("home", enterTransition = { slideInHorizontally() }) { HomeScreen() }
}48. How can you ensure thread safety in a Kotlin Multiplatform shared module?
Answer:
Use `Mutex`, `AtomicReference`, or `freeze` for shared objects:
val mutex = Mutex()
suspend fun update() = mutex.withLock { sharedState++ }49. What strategies can you use to test dynamic feature modules in Android?
Answer:
Mock `SplitInstallManager` with Robolectric, test navigation integration, and isolate module logic:
val request = SplitInstallRequest.newBuilder().addModule("feature").build()50. How do you ensure modularity and scalability in a large Compose-based codebase?
Answer:
Use clean architecture, modularize by feature, hoist state, and define clear interfaces:
@Composable
fun FeatureScreen(viewModel: FeatureViewModel = viewModel()) {}
