Android Kmp Modern

Implementation Rules

• Use suspend and Flow APIs with explicit dispatcher handling; inject dispatchers where needed.
• Keep side effects at boundaries (repositories, use cases, platform services), not inside Composables.
• Use StateFlow for persistent UI state and one-off event channels/shared flow only when needed.
• Treat nullability deliberately; avoid force unwraps (!!) in production code.
• Serialize network/data contracts with kotlinx.serialization unless the codebase already standardizes another modern approach.
• Favor feature-based packages/modules over type-based dumping grounds.
• Prefer unidirectional data flow (intent -> reducer/use case -> new state).

Android Native Guidance

• Use Navigation Compose for screen transitions in Compose-based apps.
• Use lifecycle-aware collection (collectAsStateWithLifecycle) for flows in UI.
• Use rememberSaveable for user-entered transient state that should survive process recreation.
• Follow Material 3 tokens/theming from a single design system entry point.

KMP Guidance

• Keep pure business rules in commonMain whenever platform APIs are not required.
• Use expect/actual for platform-specific capabilities (storage, secure settings, notifications, etc.).
• Keep platform entry points thin; delegate shared behavior to common modules.
• When Compose Multiplatform is not practical for a feature, share state/domain and keep UI platform-native.

Quality Bar

• Add or update tests for each behavioral change.
• Preserve deterministic behavior across Android/iOS for shared logic.
• Keep APIs stable and explicit; avoid leaking data-layer types into UI layer.
• Minimize tech debt in touched areas by opportunistic cleanup (small, safe refactors).

Review Checklist

• Is the change using Kotlin 2.x idioms and modern coroutine patterns?
• Is UI declarative and state-driven (Compose), without business logic in Composables?
• Are dependencies provided through Koin with clear module ownership?
• Is KMP sharing done at the correct layer (domain/data first, UI only when justified)?
• Are tests meaningful and covering changed behavior?

References

• Read Modern Android KMP Playbook for detailed architecture, module templates, dependency decisions, and test strategy.
• Apply the playbook selectively to fit the codebase while keeping modern defaults.