Mobile Client Architecture Questions

Principles and patterns used to design maintainable, testable, and scalable mobile applications. Covers separation of concerns between user interface, presentation, domain, and data layers; common mobile patterns such as model view view model, model view presenter, and clean architecture; platform specific considerations such as coordinator and modular approaches on the Apple mobile platform, and feature modules on the Android mobile platform. Includes cross platform approaches such as Redux style state management for React Native and business logic component patterns for Flutter. Topics assessed include dependency injection strategies, reactive data flow and bindings, testing at each layer, performance and memory considerations, incremental modularization to support team scaling, and how architecture choices affect release cadence and maintainability.

MediumTechnical

33 practiced

Define a testing strategy for a mobile application at each architecture layer. For the ViewModel/presenter layer, repository/data layer, and UI layer, specify what to unit test, what to integration-test, and what to cover with end-to-end UI tests. Include tooling recommendations for Android and iOS and how architecture choices affect testability.

MediumTechnical

37 practiced

Implement a Kotlin ViewModel for Android that exposes UI state using StateFlow. The ViewModel must fetch a list of items from a Repository with suspend function getItems(): List<Item>, handle loading and error states, expose an immutable StateFlow for the UI, and properly use viewModelScope for coroutine cancellation. Describe important test cases for this ViewModel.

Sample Answer

**Approach — key points**- Represent UI state with a sealed UIState (Loading/Success/Error).- Expose immutable StateFlow via asStateFlow().- Use viewModelScope.launch to fetch and ensure cancellation on ViewModel clear.- Catch exceptions and emit Error; provide a retry function.

**Kotlin implementation**

kotlin

// Kotlin
sealed class ItemsUiState {
    object Loading : ItemsUiState()
    data class Success(val items: List<Item>) : ItemsUiState()
    data class Error(val message: String) : ItemsUiState()
}

class ItemsViewModel(private val repository: Repository) : ViewModel() {
    private val _uiState = MutableStateFlow<ItemsUiState>(ItemsUiState.Loading)
    val uiState: StateFlow<ItemsUiState> = _uiState.asStateFlow()

    init { fetchItems() }

    fun fetchItems() {
        _uiState.value = ItemsUiState.Loading
        viewModelScope.launch {
            try {
                val items = repository.getItems() // suspend
                _uiState.value = ItemsUiState.Success(items)
            } catch (e: Exception) {
                _uiState.value = ItemsUiState.Error(e.message ?: "Unknown error")
            }
        }
    }

    fun retry() = fetchItems()
}

**Explanation**- MutableStateFlow holds current state; asStateFlow prevents external mutation.- viewModelScope ensures coroutines cancel when ViewModel is cleared.- Init loads immediately; retry exposes explicit re-fetch.

**Important tests**- Success: repository returns list -> uiState transitions Loading -> Success(items).- Error handling: repository throws -> Loading -> Error(with message).- Cancellation: simulate long-running repository and verify coroutine cancels when ViewModel cleared.- Retry behavior: initial failure then success on retry -> states reflect both attempts.- Concurrency: multiple rapid fetch/retry calls produce deterministic final state (last call wins).- Empty list: repository returns empty list -> Success(emptyList) and UI handles it.

EasyTechnical

38 practiced

Describe the BLoC (Business Logic Component) pattern in Flutter. Explain streams and sinks, how the UI subscribes to the BLoC, where validation and repository calls should live, and provide a high-level example for implementing a paginated list including events and states.

Sample Answer

**Brief description**BLoC (Business Logic Component) separates UI from business logic by exposing Streams (output) and Sinks (input). The UI sends events into sinks; the BLoC processes them, interacts with repos/validation, and emits new states on streams the UI listens to.

**Streams & Sinks**- Stream<T>: read-only output the UI subscribes to (e.g., Stream<State>).- Sink<Event>: input where UI adds events (user actions).- Use StreamController or flutter_bloc package (Bloc/BlocProvider) for lifecycle.

**Where to place logic**- Validation: in the BLoC (or small validator helpers) so UI stays dumb.- Repository/API calls: in repository layer; BLoC coordinates calls and maps results to states.

**Paginated list — high level**Events:

dart

abstract class ListEvent {}
class FetchPage extends ListEvent { final int page; FetchPage(this.page); }
class Refresh extends ListEvent {}

States:

dart

abstract class ListState {}
class ListLoading extends ListState {}
class ListLoaded extends ListState { final List<Item> items; final bool hasMore; }
class ListError extends ListState { final String message; }

Flow:- UI dispatches FetchPage when scrolled near bottom.- BLoC checks current page, calls repository.fetchPage(page), emits ListLoading or appends to ListLoaded, sets hasMore.- UI subscribes via StreamBuilder or BlocBuilder to rebuild on state changes.

**Best practices**- Keep BLoC testable, small, persist only UI state; handle errors and debounce rapid events (e.g., scroll).

EasyTechnical

35 practiced

Compare MVP, MVVM, and Clean Architecture for mobile clients. For each pattern summarize the core idea, typical class responsibilities, and the trade-offs in terms of testability, complexity, and suitability for small versus large teams. Provide short examples of when you would choose each in a mobile project.

EasyTechnical

37 practiced

Compare reactive data-flow mechanisms commonly used in mobile: RxJava/RxKotlin, Kotlin Flow/Coroutines, and Combine (iOS). Explain key differences in backpressure handling, cancellation, error propagation, and lifecycle integration on Android and iOS, and give examples of where each excels.

Sample Answer

**Overview**Compare RxJava/RxKotlin, Kotlin Flow (with Coroutines), and Combine across backpressure, cancellation, error handling, and lifecycle integration — with mobile-specific examples.

**Backpressure**- RxJava: Built-in backpressure (Flowable) vs non-backpressured Observable. Mature operators (onBackpressureBuffer/drop/latest). Good for streams that can outrun consumers (sensors, BLE).- Kotlin Flow: Designed with backpressure by suspending emitter when downstream is slow (cold, sequential). Simpler mental model for coroutine users.- Combine: Has backpressure via Demand (Subscribers request n). Powerful but slightly verbose compared to Flow.

**Cancellation**- RxJava: Disposable to cancel subscription; integration with scopes requires manual wiring (CompositeDisposable).- Flow: Cancellation is structured via CoroutineScope; cancel coroutine to cancel flow collection automatically.- Combine: Cancellable via AnyCancellable; tie to lifecycle manually or via frameworks (e.g., store cancellables).

**Error propagation**- RxJava: Rich error operators (onErrorResumeNext, retryWhen). Terminal errors unless handled.- Flow: Uses exceptions — catch, retry, retryWhen. Operators are coroutine-friendly.- Combine: Similar to Rx with Failure type; errors propagate as completion with failure; mapError etc.

**Lifecycle integration (mobile)**- Android: RxJava needs lifecycle-aware management (AutoDispose, LifecycleScope adapters). Flow integrates smoothly with lifecycle-aware CoroutineScope (viewModelScope, lifecycleScope) and Jetpack (repeatOnLifecycle). Use flowWithLifecycle for UI.- iOS: Combine integrates with UIKit/SwiftUI via AnyCancellable and lifecycle of views/view models; SwiftUI provides .onReceive and @Published interop.

**Where each excels**- RxJava: Complex multi-stream composition, legacy codebases, extensive operator set, robust backpressure options.- Flow: Modern Kotlin apps — concise, structured cancellation, excellent with coroutines and Jetpack (ViewModel/lifecycle).- Combine: Native iOS reactive in SwiftUI/Combine stacks; tight Swift type safety and Swift concurrency interop.

Use Rx for heavy reactive transformations, Flow for coroutine-first Android apps, Combine for native Swift UI pipelines.

Unlock Full Question Bank

Get access to hundreds of Mobile Client Architecture interview questions and detailed answers.

Join thousands of developers preparing for their dream job.