Kotlin Multiplatform Masterclass - KMP, KMM - Android, iOS

Explore the essentials of Kotlin Multiplatform and learn how a KMP project is structured, how to share code for Android and iOS, and maintain a common API.

Set up a Kotlin multiplatform project in Android Studio, download the course-provided Daily Pulse app, and run hello world on Android and iOS via emulators and Xcode.

Explain the expect and actual mechanisms in Kotlin multiplatform to declare common signatures and implement them per platform, Android and iOS, via a common platform interface.

Build the first screen to display device information on Android and iOS using Kotlin Multiplatform. Implement an expect class for os name, os version, device model, and density.

Implement the iOS platform in Kotlin multiplatform using UI device to get system name, OS version, and device model, and UI screen to get density, then log with NSS log.

Build an android about screen with jetpack compose using composable functions and a top app bar, and a lazy column of label-value pairs for os, device, and density.

Create a SwiftUI about list view and a detail screen displaying OS name, version, device model, and density. Demonstrate Kotlin multiplatform sharing an interface across Android and iOS.

Begin the presentation layer by building a shared view model and UI state across Android and iOS using an MVI architecture with a single stream of UI data.

Learn clean architecture with a shared domain and data layer in a Kotlin multiplatform project, implementing mvvm with state and sharing presentation logic via expect mechanisms and platform-specific view models.

Add third-party dependencies across Kotlin multiplatform modules, including common main, Android main, and iOS main. Use Gradle source sets, version catalogs, and proper implementation scope, with coroutines and ViewModel examples.

Learn to implement a shared base view model across Android and iOS using expect/actual, with a shared coroutine scope for structured concurrency, and platform-specific lifecycle handling to prevent memory leaks.

Implement the articles view model in common code for Android and iOS, using Kotlin flow and state flow to represent loading, success, error, and empty states.

Create a private getArticles in the articles view model that launches a coroutine, emits a mocked state via a state flow after 500 ms, and runs in the init block.

Create an articles entity and article state using Kotlin data classes, including title, description, date, and image url. Implement loading, successful state (list of articles), and error states with defaults.

Explore the UI layer using Jetpack Compose for Android and Swift UI for iOS to display articles and implement lazy loading lists that handle large data efficiently.

Wire the article screen to the app via the articles view model, test loading, error, and success with mocked data and delays, including coil image loading and internet permission.

Add a toolbar with a single toolbar item labeled done on the iOS about screen and wire it to an environmental dismiss to close the popover within the navigation stack.

Add android navigation by wiring the article screen's about button callback into the app bar as an icon action, implement a back button on the about screen, and scaffold app.

Define a screen enum and add the Jetpack Compose navigation dependency. Wire an application scaffold with a NavHost to navigate between article and about screens.

Learn to implement networking by integrating a public API into the daily pulse application, using kata for an effective, performant, and easy-to-use solution.

Parse backend responses in a Kotlin multiplatform project by defining data classes, applying serializable annotations, and mapping API field names to app properties for article data.

Create a Kotlin articles service that uses a Ktor http client to fetch articles via the top headlines endpoint with suspend fetchArticles function and configurable country, category, and api key.

Test the Kotlin multiplatform masterclass implementation across Android and iOS by running the app, verifying the manifest internet permission, and fetching articles from the backend with shared logic.

Explore dependency injection and see how injecting dependencies via an injector keeps the view model clean, reduces coupling, and improves readability, testability, and maintainability.

Integrate the coin dependency injection library into a Kotlin Multiplatform project by updating Gradle with Android and shared module dependencies, syncing, and applying platform-specific steps to Android and iOS.

Create an articles module to build the dependency graph, declare single-scope dependencies, and wire the article service, use case, and iOS view model with a shared http client.

Discover how to design a shared Koin network module that provides a single Http client instance across Android and iOS projects, enabling clean dependency injection and smaller view models.

Learn to initialize Koin in iOS for a Kotlin multiplatform project by adding a shared coin initializer, building a dependency graph, and exposing the articles view model via an injector.

Apply proper dependency injection across iOS and Android using the articles injector to instantiate the articles view model in a shared KMP module, improving readability, testability, and maintainability.

Integrate a local caching database by using SQL delight to cast the API results, as your app nears its final state.

Discover why a local database boosts app performance, reduces backend traffic, and enables offline access by serving prefetched data, minimizing repeated requests, and supporting periodic refresh.

Integrate sql delight into a Kotlin multiplatform project by adding the sql core routines extension and the Android and iOS drivers, enabling type safe APIs and compile-time schema checks.

Enable SQL delight plugins and generate Kotlin code from SQL statements via Gradle, and declare the daily pulse SQLite database in the Petros Efthymiou.daily.pulse.DB package.

Install and enable the SQL delight plugin in Android Studio from the marketplace, then restart, and place SQL statements in the SQL delight directory beside the Kotlin directory.

Implement the articles data source part 2 for the Kotlin Multiplatform Masterclass by inserting fetched articles into the database within a transaction, using title, description, date, and image URL.

Wire up the Android side by wiring dependencies, expose the articles repository and data source, configure the sql driver and Daily Pulse database, and test by fetching article counts.

Run the Android app in Android Studio, verify build and emulator launch, observe initial zero articles, then twenty after backend fetch and local database storage, and demonstrate offline mode.

Complete the iOS database implementation by wiring a Kotlin iOS database module, providing a single SQL driver and the daily pulse database, and integrating it into the iOS dependency graph.

Enable pull to refresh by adding a force fetch option in the articles repository and propagate it through the use case and view model for shared KMP logic.

Integrate the accompanist swipe refresh library for Android with Jetpack Compose. Bind swipe refresh state to the view model and wrap the article list to trigger a fetch on swipe.

Fetch sources from news api.org using the v2/top-headlines/sources endpoint, parse the json to extract id, name, and description, and merge language and country for the user interface display.

Discover bonus resources, discounts, and newsletters for the Kotlin Multiplatform Masterclass. Learn how Compose Multiplatform shares 100% of the UI between Android and iOS, enabling desktop and web apps.