Android
433 bites tagged Android — interview questions with model answers, and 60-second explainers.
How would you manage API keys in Gradle without version control?
Tests secure credential handling in Android builds. A good answer proposes the Secrets Gradle Plugin, which reads from an untracked properties file and exposes keys via BuildConfig, while also noting this doesn't protect against APK decompilation.
How do you diagnose a memory leak with Android Studio Profiler?
This tests your systematic process for debugging memory issues. A good answer outlines using the Memory Profiler, forcing GC, capturing heap dumps, and analyzing object references. A red flag is just naming the tool without explaining the 'how'.
Gradle Build Types vs. Product Flavors
This tests your understanding of Gradle's build matrix for creating different app versions. A great answer defines build types (how it's built) vs. flavors (what is built) and explains that variants are the cross-product. A red flag is confusing their roles.
What is the Android Debug Bridge (ADB)?
This tests practical command-line proficiency and understanding of the host-device link. A good answer defines the client-server-daemon architecture and gives two commands like `adb install` and `adb logcat`.
How do you debug a running app's view hierarchy?
Tests practical debugging skills. A good answer names the Layout Inspector, describes the component tree and attributes panes, and explains how the 3D view finds hidden elements. A red flag is only naming the tool without explaining its use.
Explain Gradle product flavors with a free/pro app example
This tests your grasp of the build variant matrix, not just flavors. A great answer defines flavors, explains how they combine with build types, details Gradle config (`applicationIdSuffix`), and mentions source sets.
How do you debug an app crash in Android Studio?
Tests your systematic problem-solving process. A great answer outlines reproducing the crash, analyzing the Logcat stack trace for the FATAL EXCEPTION, and then using strategic breakpoints and the variable inspector to find the root cause of the bad state.
Explain the res/ directory and resource qualifiers for layouts
Tests your grasp of Android's core resource system. A good answer defines `res/` for non-code assets, explains how qualifiers like `layout-land` match device state, and provides a concrete example.
Project-level vs. module-level build.gradle files
This tests your grasp of Gradle's project/module structure. A good answer defines the project-level file for global settings (repositories, plugins) and the module-level for specifics (SDK versions, dependencies). A red flag is confusing their roles.
Describe the purpose of the AndroidManifest.xml file
This tests if you view the manifest as a contract with the OS. Define its role, then list key elements like components (`<activity>`), permissions (`<uses-permission>`), and hardware features. A red flag is just listing tags without explaining their purpose.
Implement a type-safe DSL in Kotlin for a UI component
Tests understanding of Kotlin's type-safe builders via lambdas with receivers. A great answer defines model classes, creates a top-level builder function taking a `Receiver.() -> Unit` lambda, and defines nested builder methods.
How does coroutine cancellation work internally?
This tests your grasp of cooperative cancellation. Explain that `cancel()` sets a flag, causing a `CancellationException` at the next suspension point. A non-suspending loop must explicitly check `isActive` to stop.
Explain backpressure in Kotlin Flows and its management operators
This tests your understanding of Flow's sequential nature and strategies for decoupling producers and consumers. Explain default suspension, then detail buffer(), conflate(), and collectLatest(). A red flag is confusing conflate() with collectLatest().
What is a CoroutineDispatcher and when to use IO vs Default?
Tests your grasp of thread pool strategy for CPU vs. I/O-bound tasks. A good answer defines Dispatchers, contrasts the fixed-size Default pool (for CPU work) with the larger IO pool (for blocking I/O), and gives clear examples.
Hot vs. Cold Streams: StateFlow vs. Flow in Android
This tests your grasp of stream lifecycles. A great answer defines cold `Flow` (lazy, per-collector) vs. hot `StateFlow` (active, shared state) and uses a ViewModel UI state scenario. A red flag is mischaracterizing a `Flow` as a one-time operation.
Explain Structured Concurrency in Kotlin Coroutines
Tests your grasp of coroutine lifecycle management. A great answer defines the parent-child relationship within a CoroutineScope, explains cancellation propagation, and details how exceptions cancel the entire hierarchy.
Explain Kotlin's five scope functions: let, run, with, apply, also
This tests your grasp of idiomatic Kotlin. A great answer categorizes functions by their context object (`this`/`it`) and return value (object/lambda result). Provide a clear use case for `apply` (object configuration).
What is a Kotlin `suspend` function and how does it work?
Tests your grasp of Kotlin's non-blocking concurrency. A great answer defines a suspend function as pausable, states its two calling rules (from another suspend function or coroutine builder), and mentions the compiler's CPS transformation.
Explain launch vs. async in Kotlin Coroutines
Tests your grasp of structured concurrency, return values, and exceptions. `launch` is for fire-and-forget tasks (returns `Job`), while `async` is for tasks that produce a result (returns `Deferred`).
Compare and contrast `apply` and `let` scope functions
Tests Kotlin scope function knowledge: context (`this`/`it`) & return value. `apply` uses `this`, returns the object (for config). `let` uses `it`, returns lambda result (for null-checks/transforms). Red flag: mixing up return values or use cases.
When to use a sealed class instead of an enum?
Tests your grasp of Kotlin's type hierarchies. Use `sealed class` for states with associated data (e.g., `Success(data)`), as subclasses can have unique properties. Use `enum` for simple, constant states. A red flag is treating them as interchangeable.
lateinit var vs. val by lazy in Android
Tests your grasp of Kotlin property initialization and its lifecycle implications. A good answer contrasts mutability (var/val), initialization timing, and thread safety.
What are the advantages of a Kotlin data class and its functions?
Tests knowledge of Kotlin's idiomatic features. A good answer explains the main advantage (boilerplate reduction), lists generated functions like toString() and equals(), and describes copy() for immutable state updates.
What is a Kotlin extension function? Write one for String.
Tests adding functionality to classes without inheritance. Define extension functions as static utilities, explain their use case (e.g., third-party libs), then write `hasWhitespace` using an idiomatic method like `any`. A red flag is manually looping.
Get Android bites daily.
Five a day, five minutes, offline. With quizzes so it sticks.
Open testing — you’ll join as an early tester.