Intermediate everything in Android & Kotlin, page 8
Dagger's Assisted Injection: Creating Objects with Runtime Data
Assisted Injection lets Dagger provide some dependencies while you supply the rest at runtime. It's for objects that need both graph-provided services and user-supplied data, like a specific ID. The footgun: you can't inject the object, only its factory.
Manual Dependency Injection: No Frameworks, Just Code
Manual dependency injection means you are the 'framework,' creating and passing dependencies yourself via constructors. It's great for simple apps where a full DI library is overkill, but the footgun is creating dependencies inside the class that needs them.
Retrofit Converters: Speaking Your API's Language
A Retrofit Converter is a translator that turns raw network data into your app's data classes (e.g., JSON to Kotlin objects). You add a converter factory, like for Moshi or Gson, when building your Retrofit instance. The footgun: converter order matters.
Android Navigation Actions: Defined Paths, Not Just Destinations
A Navigation Action is a configured pathway between screens, not just a destination. It bundles the target screen with transition animations and arguments. Use them in your XML nav graph to keep UI code clean.
NavController: The Single Source of Truth for App Navigation
NavController is the central API for managing screen transitions. Think of it as an air traffic controller for your UI, directing users between destinations. It's the core of Jetpack Navigation, handling clicks that lead to new screens.
Android Navigation Graph: A Map for Your UI
Think of the Navigation Graph as a visual map of your app's screens. It centralizes all navigation logic in one XML file, defining destinations (screens) and actions (paths between them), simplifying transitions and deep linking.
ConstraintLayout in Compose
ConstraintLayout in Compose lets you position elements relative to each other and to guidelines using constraints, the same model as the View system's ConstraintLayout. It solves layouts that would otherwise need deeply nested Row and Column combinations.
VectorDrawable: Scalable Graphics for Android
A VectorDrawable is like an SVG for your app, defining images with math, not pixels. Use it for icons that need to look sharp on any screen without bloating your APK. The footgun: complex vectors can be slower to render than a comparable bitmap.
ViewBinding: Say Goodbye to findViewById
ViewBinding generates a type-safe class from your XML layout, giving you direct, non-null access to views with IDs. It's a compile-time safe replacement for findViewById used in Activities and Fragments. If a view is missing, you forgot to give it an ID.
Google Play's Target API Level Requirement
Think of targetSdkVersion as a contract with Android. You promise your app handles all new security and privacy features up to that OS version. Google Play enforces this, blocking updates that target old APIs to protect users.
In-app Updates: Update Your App Without Leaving It
In-app updates prompt users to update without leaving your app. Use the 'Flexible' flow for routine updates and the 'Immediate' flow for critical fixes. The footgun is overusing the disruptive 'Immediate' flow for non-critical changes.
Play Core Library: Your App's Runtime API to the Play Store
The Play Core Library is your app's direct line to the Google Play Store at runtime. Use it to request features like in-app updates, on-demand modules, or user reviews without leaving the app.
Staged Rollouts: Limit Your Update's Blast Radius
Staged rollouts are a safety net, letting you release an update to a small percentage of users first. This lets you find crashes or major bugs before they affect everyone. The footgun: halting a rollout only stops new users from getting the update, it doesn't.
Google Play Dynamic Delivery: Ship Features On-Demand
Shrink your app's initial install size by delivering features on-demand. Instead of one giant APK, Dynamic Delivery sends a small base app, then downloads larger features like AR modes or special tools only when the user needs them.
App Signing by Google Play: Trust Google with Your Keys
App Signing by Google Play separates your app's identity from the key you use for uploads. Google manages the final, user-facing signing key, which is mandatory for new apps. The footgun is thinking your upload key is the final key; losing it is recoverable.
Android Biometric Authentication: The BiometricPrompt API
Android's BiometricPrompt is a unified API for fingerprint, face, or iris scans, replacing older, fragmented methods. Use it to authorize payments or unlock features. The footgun: never assume a specific biometric type is available; always have a fallback.
EncryptedSharedPreferences: Secure Key-Value Storage on Android
EncryptedSharedPreferences is a drop-in replacement for SharedPreferences that automatically encrypts keys and values, protecting sensitive data at rest. Use it to store small, sensitive data like API tokens. The main footgun is mismanaging the master key.
Android Keystore System
The Android Keystore System stores cryptographic keys in hardware backed secure storage instead of app memory or disk. Apps can use the keys to sign or encrypt data, but the raw key material never leaves the secure environment, even on a rooted device.
Android App Startup: From Cold to Hot
App startup has three types: cold, warm, and hot. Optimization focuses on the cold start—when the app launches from scratch. This is critical for user retention, as slow launches are a common reason for uninstalls. The footgun: don't just test warm starts.
Espresso for Android UI Testing
Espresso is an Android framework for automated UI tests. As an instrumented test, it runs on a device or emulator to simulate user interactions, helping you verify app behavior and UI correctness as part of a complete testing strategy.
We are hiring for this. Every open role lists the topics its interview covers, so you can prepare for the real thing rather than guessing.
See open roles