Intermediate concepts in Android & Kotlin, page 3
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 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 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.
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.
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.
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.
CoroutineWorker: Background Tasks with Coroutines
CoroutineWorker simplifies background tasks by letting you use suspend functions inside a WorkManager job. It's for deferrable work, like syncing data, that needs to survive process death.
Isolating Units for Tests with Mockito-Kotlin
Mockito-Kotlin creates fake objects (mocks) to stand in for real dependencies in your tests. This lets you test a class in isolation, for example, testing a ViewModel without making a real network call. The footgun is testing implementation, not behavior.
Android Network Security Configuration
Define your app's network trust rules in a simple XML file instead of writing complex code. Use it to block cleartext (HTTP) traffic, trust self-signed certs in debug builds, or pin certificates.
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