Experience with iOS and/or Android Platforms Questions

Have a clear answer about which platform(s) you have hands-on experience with. Know the basics: What is iOS? What is Android? What languages are used (Swift/Objective-C for iOS, Kotlin/Java for Android, or React Native/Flutter for cross-platform)? Have 1-2 project examples you can discuss (even if they are learning projects).

MediumTechnical

90 practiced

Implement a thread-safe singleton suitable for a mobile application in both Swift and Kotlin. Provide idiomatic implementations for each language, explain why they are thread-safe, and discuss scenarios where singletons may harm testability and alternative patterns to prefer.

Sample Answer

**Approach (brief)** Show idiomatic thread-safe singletons in Swift and Kotlin, explain why thread-safe, then discuss testability concerns and alternatives.

**Swift (iOS)**

swift

final class AnalyticsManager {
    static let shared = AnalyticsManager() // lazy, thread-safe
    private init() {}
    func track(event: String) { /* ... */ }
}

- Why thread-safe: Swift’s static let uses lazy initialization guaranteed to be atomic and thread-safe by the runtime.

**Kotlin (Android)**

kotlin

class AnalyticsManager private constructor() {
    companion object {
        val instance: AnalyticsManager by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
            AnalyticsManager()
        }
    }
    fun track(event: String) { /* ... */ }
}

- Why thread-safe: Kotlin’s by lazy with SYNCHRONIZED ensures only one instance created across threads.

**Testability issues**- Singletons introduce global state, hidden dependencies, and make unit tests order-dependent and hard to isolate.- Hard to inject test doubles; lifecycle tied to process.

**Alternatives / Best practices**- Prefer dependency injection (constructor injection or DI frameworks: Hilt, Koin, Resolver).- Use protocols/interfaces and provide a test implementation.- For app-scoped single instance, use DI scope (e.g., Application-scoped component) instead of a global singleton.

This demonstrates mobile-idiomatic singletons and why DI improves testability and maintainability.

MediumTechnical

88 practiced

Explain how dependency injection is commonly applied in mobile apps on both platforms. Discuss popular DI frameworks (Hilt/Dagger/Koin on Android, Swinject/Resolver on iOS), the difference between constructor injection and service locators, lifecycle scoping for UI components, and how DI improves testing and modularity.

MediumTechnical

89 practiced

Write concise code to parse a JSON array of user objects into platform models in either Swift using Codable or Kotlin using kotlinx.serialization or Moshi. Include robust error handling for malformed JSON, missing optional fields with sensible defaults, and explain how you would evolve the model to remain backward compatible when the backend adds new fields.

Sample Answer

**Approach**- Use Swift Codable for concise parsing, provide defaults for optional fields, and robust error handling via do/catch and keyed decoding with fallback values. Describe backward-compatible evolution.

**Code (Swift Codable)**

swift

import Foundation

struct User: Codable {
    let id: Int
    let name: String
    let email: String
    let isActive: Bool
    let signupDate: Date?

    // Provide defaults for missing/nullable fields
    init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        id = try c.decode(Int.self, forKey: .id)
        name = try c.decodeIfPresent(String.self, forKey: .name) ?? "Unknown"
        email = try c.decodeIfPresent(String.self, forKey: .email) ?? ""
        isActive = try c.decodeIfPresent(Bool.self, forKey: .isActive) ?? false
        let dateString = try c.decodeIfPresent(String.self, forKey: .signupDate)
        if let ds = dateString {
            signupDate = ISO8601DateFormatter().date(from: ds)
        } else {
            signupDate = nil
        }
    }
}

func parseUsers(from data: Data) throws -> [User] {
    do {
        let decoder = JSONDecoder()
        return try decoder.decode([User].self, from: data)
    } catch let DecodingError.dataCorrupted(ctx) {
        throw NSError(domain: "ParseError", code: 1, userInfo: [NSLocalizedDescriptionKey: "Malformed JSON: \(ctx.debugDescription)"])
    } catch let DecodingError.keyNotFound(key, ctx) {
        throw NSError(domain: "ParseError", code: 2, userInfo: [NSLocalizedDescriptionKey: "Missing key \(key.stringValue): \(ctx.debugDescription)"])
    } catch {
        throw error
    }
}

**Why this works**- decodeIfPresent + nil-coalescing gives sensible defaults.- Specific DecodingError branches make diagnostics actionable for logging/analytics.

**Evolution / Backward compatibility**- Ignore unknown keys (default Codable behavior) — new fields won’t break older clients.- Use optional properties with defaults for newly added nonbreaking fields.- For breaking changes, use API versioning or migration code paths: add new model version preserving old fields, map server fields in init(from:) with feature flags.- Write unit tests with older/newer JSON samples and schema/contract tests to catch regressions.

EasyTechnical

92 practiced

Explain at a high level: what is iOS and what is Android? Describe their core architecture components such as kernel/runtime, app frameworks and UI layers, and packaging formats (IPA for iOS, APK/AAB for Android). Provide one sentence on how the runtime or VM differs between the platforms and why that matters for app developers.

HardTechnical

94 practiced

Design and outline a custom camera frame processing pipeline for low-latency per-frame filters on Android (Camera2/CameraX) or iOS (AVCaptureSession). Include buffer management strategies to minimize copies, how to offload processing to GPU (OpenGL/Metal/Vulkan), thread model for capture, processing and rendering, fallback paths for older devices, and how to measure and reduce end-to-end latency.

Sample Answer

**High-level approach**- Build a three-stage pipeline: Capture → GPU-accelerated processing → Render/encode. Keep data in GPU memory whenever possible to avoid CPU copies.

**Capture & buffers**- Android: use Camera2/CameraX with ImageReader configured to YUV_420_888 or use AHardwareBuffer/SurfaceTexture (via Surface) to receive frames directly into GPU-backed buffers. Prefer Surface (CameraDevice.createCaptureSession with a Surface from SurfaceTexture or SurfaceView) to avoid ImageReader copies.- iOS: use AVCaptureVideoDataOutput with videoSettings = kCVPixelFormatType_420YpCbCr8BiPlanarFullRange and set alwaysDiscardsLateVideoFrames = false; prefer using AVCaptureVideoPreviewLayer or AVSampleBufferDisplayLayer + CVPixelBuffer -> Metal texture (CVMetalTextureCache) for zero-copy.

**Zero-copy GPU upload**- Android: use SurfaceTexture / GLES external texture or AHardwareBuffer -> EGLImage -> GL texture / Vulkan import. With NDK, use AImageReader/AHardwareBuffer to produce GPU-importable buffers.- iOS: use CVPixelBufferPool + CVMetalTextureCache to create CVMetalTextureRef without copying.

**GPU processing**- Implement filters as fragment/compute shaders (OpenGL ES / Metal / Vulkan). Use compute shaders for heavy operations (denoise, morph) and fragment shaders for color/blur effects.- Chain shader passes on GPU; ping-pong between textures using framebuffer objects (FBOs) to avoid readbacks.

**Thread model**- Capture thread: platform callback (Camera2 captureCallback / AVCaptureOutput callback) posts buffer/texture handles to a lock-free queue.- GPU worker(s): single GLES/Metal context bound to a render thread that consumes queue entries and runs shader passes. Use synchronization primitives (EGLSync, MTLCommandBuffer completion handlers) to track GPU work.- Rendering/UI: separate UI thread reads final texture via shared texture or presents using SurfaceView/MTKView. Avoid blocking UI; use semaphore-limited inflight frames (2–3).

**Buffer management strategies**- Use preallocated pool of GPU-importable buffers (CVPixelBufferPool / AHardwareBuffer pool) to limit allocations and GC.- Keep inflight frame count small (2) and use semaphores for backpressure.- Reuse textures and FBOs; avoid glReadPixels or CVPixelBufferLockBaseAddress unless unavoidable.

**Fallbacks for older devices**- Detect capabilities (EGL extensions, Vulkan support, Metal feature set). If no zero-copy import, fallback to optimized CPU path: - Use semi-native memcpy with NEON/Accelerate/VImage for conversions, minimize runtime allocations, and run SIMD-optimized filters. - Reduce resolution/frame-rate or degrade effects to simpler shaders.- For Android API < 21, use Camera1 with preview callbacks but strongly prefer SurfaceTexture path.

**Measuring and reducing end-to-end latency**- Measure: stamp frames at camera capture (sensor timestamp), at GPU submission, and at frame presentation. On Android use CaptureResult.SENSOR_TIMESTAMP and System.nanoTime; on iOS use CMSampleBufferGetPresentationTimeStamp. Correlate with GPU timestamps (EGL_ANDROID_get_sync_values / MTLCommandBuffer GPU start/complete).- Tools: Android systrace, Perfetto, GPU profiler (Adreno/Tegra/Mali tools), Xcode GPU Frame Capture.- Reduce latency: - Keep inflight count low (1–2). - Use direct-to-GPU paths and avoid CPU conversions. - Batch shader passes into fewer passes or use compute to combine steps. - Use dynamic resolution/P-frame skipping under load. - Prefer async presentation paths and avoid blocking synchronization.

**Example trade-offs**- Aggressive zero-copy reduces CPU but requires device support. CPU fallback easier to implement but adds latency. Aim for adaptive pipeline that queries capabilities at startup and chooses optimal path.

This design keeps per-frame latency minimal by minimizing copies, leveraging GPU shaders, strict buffer pools, and careful thread/sync design.

Unlock Full Question Bank

Get access to hundreds of Experience with iOS and/or Android Platforms interview questions and detailed answers.

Join thousands of developers preparing for their dream job.