KMP #05: Menghubungkan Shared Module KMP ke Android

Di artikel sebelumnya kita sudah berhasil membangun Repository dan Domain Layer untuk Weather App. Kita juga sudah memiliki GetWeatherUseCase yang bertugas mengambil data cuaca melalui repository.

Sekarang kita masuk ke tahap berikutnya.

Kita akan mulai menggunakan business logic yang sudah dibuat di shared module dari aplikasi Android. Tujuannya sederhana: memastikan kode yang sudah kita buat di Kotlin Multiplatform benar-benar bisa digunakan oleh aplikasi Android.

Namun, sebelum mulai membangun tampilan Weather App, ada beberapa hal yang perlu kita siapkan terlebih dahulu, yaitu integrasi module, ViewModel, dan pengelolaan state menggunakan StateFlow.

Pada artikel ini kita belum akan membangun UI cuaca menggunakan Jetpack Compose. Pembahasan UI akan kita lakukan secara khusus pada artikel berikutnya agar kita bisa fokus memahami bagaimana data dari shared module dikelola oleh aplikasi Android.

Apa yang Akan Kita Buat?

Di akhir artikel ini, kita akan memiliki WeatherViewModel yang dapat memanggil GetWeatherUseCase dari shared module dan menyediakan state yang nantinya dapat digunakan oleh UI.

Secara sederhana, arsitektur yang akan kita bangun seperti berikut:

flowchart TB subgraph ANDROID["androidApp"] VM["WeatherViewModel"] STATE["StateFlow WeatherUiState"] end subgraph SHARED["shared module"] UC["GetWeatherUseCase"] REPO["WeatherRepository"] IMPL["WeatherRepositoryImpl"] API["WeatherApiClient"] end VM --> STATE VM --> UC UC --> REPO REPO --> IMPL IMPL --> API API --> OPEN["Open-Meteo API"]

Perhatikan bahwa WeatherViewModel berada di androidApp, sedangkan GetWeatherUseCase, repository, dan networking tetap berada di shared module.

Kenapa dipisahkan seperti ini?

Karena kita menggunakan pendekatan Shared Logic, Native UI. Business logic digunakan bersama oleh Android dan iOS, sedangkan masing-masing platform tetap memiliki presentation layer sendiri.

Jadi, kita tidak perlu memindahkan seluruh kode ke androidApp, dan kita juga tidak perlu membuat ulang repository khusus untuk Android.

Mengenal ViewModel dan StateFlow

Sebelum mulai coding, kita pahami dulu dua komponen yang akan kita gunakan.

ViewModel

ViewModel merupakan komponen Android yang membantu mengelola state dan logic yang berkaitan dengan kebutuhan UI.

Dalam Weather App kita, WeatherViewModel nantinya bertugas untuk:

  • Memanggil GetWeatherUseCase dari shared module.

  • Mengelola proses pengambilan data cuaca.

  • Menyimpan state ketika request sedang berlangsung.

  • Menyediakan hasil data atau informasi error.

  • Menyediakan mekanisme untuk mencoba mengambil data kembali.

Dengan begitu, UI tidak perlu mengetahui detail bagaimana repository mengambil data dari Open-Meteo API.

StateFlow

Lalu, apa fungsi StateFlow?

StateFlow merupakan bagian dari Kotlin Coroutines yang digunakan untuk merepresentasikan state yang memiliki nilai terbaru dan dapat diamati oleh collector.

Misalnya, ketika aplikasi mengambil data cuaca, kita bisa memiliki tiga kondisi utama:

  • Loading: data sedang diambil.

  • Success: data berhasil diperoleh.

  • Error: terjadi kegagalan ketika mengambil data.

Alur perubahan state tersebut bisa kita gambarkan seperti berikut:

stateDiagram-v2 [*] --> Loading Loading --> Success: Data berhasil diperoleh Loading --> Error: Request gagal Error --> Loading: Coba lagi Success --> Loading: Refresh

Pada artikel ini kita akan menyiapkan state tersebut di ViewModel. Cara menghubungkannya dengan UI akan kita bahas pada artikel berikutnya.

Let's Code!

Sekarang kita mulai mengintegrasikan shared module dengan aplikasi Android.

1. Menambahkan Shared Module sebagai Dependency

Langkah pertama adalah memastikan androidApp dapat mengakses kode yang ada di shared module.

Buka file build.gradle.kts pada module androidApp.

Tambahkan dependency berikut jika belum tersedia:

dependencies {
    implementation(project(":shared"))
}

Setelah itu, lakukan Gradle Sync.

Jika konfigurasi project sudah benar, kita seharusnya dapat mengakses class dari shared module melalui package yang sesuai.

Sebagai gambaran, kita nantinya akan menggunakan:

import com.example.shared.domain.usecase.GetWeatherUseCase

Package tersebut hanya contoh. Gunakan package yang sudah kita definisikan pada artikel sebelumnya.

Perlu diperhatikan bahwa kita tidak perlu menambahkan Jetpack Compose ke shared module. Shared module tetap berisi business logic dan data layer, sedangkan UI Android akan berada di androidApp.

2. Membuat WeatherUiState

Sebelum membuat ViewModel, kita perlu menentukan bagaimana aplikasi merepresentasikan kondisi pengambilan data cuaca.

Buat file WeatherUiState.kt di package presentation pada androidApp.

sealed interface WeatherUiState {

    data object Loading : WeatherUiState

    data class Success(
        val weather: Weather
    ) : WeatherUiState

    data class Error(
        val message: String
    ) : WeatherUiState
}

Pada contoh ini, Weather merupakan model domain dari shared module. Sesuaikan nama model dan package dengan implementasi yang sudah kita buat sebelumnya.

Kenapa kita menggunakan sealed interface?

Karena state yang dibutuhkan oleh layar cuaca dapat direpresentasikan melalui beberapa kondisi yang jelas. Dengan begitu, kode yang menggunakan state tersebut dapat menangani setiap kondisi secara eksplisit.

Kita juga tidak perlu membuat beberapa variabel terpisah seperti isLoading, weather, dan errorMessage yang berpotensi menghasilkan kombinasi state yang tidak konsisten.

Misalnya, ketika request gagal, kita cukup menggunakan WeatherUiState.Error. Ketika berhasil, kita menggunakan WeatherUiState.Success.

Dengan pendekatan ini, state aplikasi menjadi lebih mudah dipahami dan dikelola.

3. Membuat WeatherViewModel

Sekarang kita buat ViewModel yang akan memanggil use case dari shared module.

Buat file WeatherViewModel.kt pada package presentation di androidApp.

Untuk contoh awal, kita akan menggunakan koordinat Jakarta sebagai lokasi default.

class WeatherViewModel(
    private val getWeatherUseCase: GetWeatherUseCase
) : ViewModel() {

    private val _uiState =
        MutableStateFlow<WeatherUiState>(
            WeatherUiState.Loading
        )

    val uiState: StateFlow<WeatherUiState> =
        _uiState.asStateFlow()

    init {
        loadWeather(
            latitude = -6.2088,
            longitude = 106.8456
        )
    }

    fun loadWeather(
        latitude: Double,
        longitude: Double
    ) {
        viewModelScope.launch {
            _uiState.value = WeatherUiState.Loading

            // Panggil GetWeatherUseCase dan
            // ubah hasilnya menjadi WeatherUiState.
        }
    }
}

Pada tahap ini, kita sudah memiliki struktur dasar ViewModel. Selanjutnya, kita perlu mengisi bagian pemanggilan use case sesuai kontrak WeatherResult yang telah kita buat pada Artikel 05.

Ada beberapa hal penting dari kode di atas.

Pertama, dependency diberikan melalui constructor.

private val getWeatherUseCase: GetWeatherUseCase

ViewModel tidak membuat repository atau API client sendiri. Kita memberikan use case yang dibutuhkan melalui constructor.

Pendekatan ini membuat ViewModel lebih mudah diuji karena dependency dapat diganti dengan implementasi lain saat testing.

Kedua, kita menggunakan MutableStateFlow untuk mengelola state.

private val _uiState =
    MutableStateFlow<WeatherUiState>(
        WeatherUiState.Loading
    )

Variabel _uiState bersifat private sehingga hanya ViewModel yang dapat mengubah nilainya.

Sementara itu, state yang akan digunakan oleh komponen lain diekspos melalui:

val uiState: StateFlow<WeatherUiState> =
    _uiState.asStateFlow()

Dengan begitu, komponen yang mengamati state tidak dapat mengubahnya secara langsung.

Ketiga, kita menggunakan viewmodelScope

viewModelScope.launch {
    // Operasi asynchronous
}

viewModelScope menyediakan coroutine scope yang mengikuti lifecycle ViewModel. Kita tidak perlu menggunakan GlobalScope untuk menjalankan proses pengambilan data.

Keempat, kita memisahkan state UI dari hasil domain.

WeatherResult yang berasal dari shared module merepresentasikan hasil operasi domain, sedangkan WeatherUiState merepresentasikan kondisi yang dibutuhkan oleh presentation layer Android.

Keduanya memiliki tanggung jawab yang berbeda. Dengan pemisahan ini, kita dapat mengubah cara UI menampilkan loading atau error tanpa perlu mengubah kontrak repository.

4. Menghubungkan ViewModel dengan GetWeatherUseCase

Sekarang kita masuk ke bagian yang menghubungkan ViewModel dengan business logic dari shared module.

Pada Artikel 05, GetWeatherUseCase dan WeatherRepository menggunakan WeatherResult sebagai hasil operasi. Karena itu, kita perlu mempertahankan kontrak tersebut, bukan menganggap use case selalu mengembalikan objek Weather secara langsung.

Alur pemanggilannya secara konseptual seperti berikut:

sequenceDiagram participant VM as WeatherViewModel participant UC as GetWeatherUseCase participant REPO as WeatherRepository participant API as WeatherApiClient participant OM as Open-Meteo API VM->>UC: Request weather UC->>REPO: getForecast(lat, lon) REPO->>API: fetchForecast(lat, lon) API->>OM: HTTP request OM-->>API: JSON response API-->>REPO: ForecastResponse REPO-->>UC: WeatherResult UC-->>VM: WeatherResult VM->>VM: Update WeatherUiState

Bagian yang perlu kita implementasikan di ViewModel adalah pemetaan hasil WeatherResult menjadi WeatherUiState.

Misalnya, jika hasil operasi berhasil, ViewModel menyimpan model cuaca ke dalam state success. Jika operasi gagal, ViewModel menyimpan informasi error ke dalam state error.

Nama varian WeatherResult dan properti modelnya harus mengikuti implementasi Artikel 05. Karena kontrak lengkapnya tidak ditampilkan di sini, kita tidak akan mengarang nama seperti WeatherResult.Success atau WeatherResult.Error dan menganggapnya pasti sama dengan kode project kita.

Hal yang perlu diingat adalah ViewModel bertugas mengubah hasil domain menjadi state presentation, bukan mengulang proses networking atau mapping JSON.

5. Menyiapkan Dependency ViewModel

Karena WeatherViewModel membutuhkan GetWeatherUseCase melalui constructor, kita perlu menyediakan cara untuk membuat instance ViewModel tersebut.

Untuk tutorial ini, kita dapat menggunakan ViewModelProvider.Factory sederhana.

Buat file WeatherViewModelFactory.kt.

class WeatherViewModelFactory(
    private val getWeatherUseCase: GetWeatherUseCase
) : ViewModelProvider.Factory {

    override fun <T : ViewModel> create(
        modelClass: Class<T>
    ): T {
        if (modelClass.isAssignableFrom(
                WeatherViewModel::class.java
            )
        ) {
            @Suppress("UNCHECKED_CAST")
            return WeatherViewModel(
                getWeatherUseCase
            ) as T
        }

        throw IllegalArgumentException(
            "Unknown ViewModel class: ${modelClass.name}"
        )
    }
}

Factory ini bertugas membuat ViewModel dengan dependency yang dibutuhkan.

Kita belum menggunakan Dependency Injection framework pada tahap ini. Tujuannya agar kita memahami terlebih dahulu bagaimana dependency dari shared module diberikan kepada ViewModel Android.

Pada artikel advanced nanti, kita dapat membahas Koin untuk mengelola dependency secara lebih terstruktur.

6. Menyiapkan Dependency dari Shared Module

Sekarang kita membutuhkan instance GetWeatherUseCase.

Secara konseptual, dependency yang dibutuhkan adalah:

flowchart TB API["WeatherApiClient"] REPO["WeatherRepositoryImpl"] CONTRACT["WeatherRepository"] UC["GetWeatherUseCase"] VM["WeatherViewModel"] API --> REPO REPO -.-> CONTRACT CONTRACT --> UC UC --> VM

Implementasi repository tetap berada di shared module. Android hanya perlu mendapatkan instance use case yang dapat diakses dari module tersebut.

Cara membuat instance-nya harus mengikuti constructor dan konfigurasi networking yang sudah kita buat pada artikel sebelumnya. Kita juga perlu memastikan HttpClient tidak dibuat berulang kali secara tidak perlu.

Untuk sekarang, cukup pastikan bahwa dependency dapat dirangkai dengan benar. Kita tidak perlu memperkenalkan dependency injection framework baru hanya untuk menyelesaikan tahap ini.

7. Memastikan Integrasi Berjalan

Setelah dependency dan ViewModel disiapkan, kita perlu memastikan bahwa Android dapat mengakses shared module dengan benar.

Beberapa hal yang perlu diperiksa:

  • Gradle Sync berhasil tanpa error.

  • androidApp dapat mengakses GetWeatherUseCase.

  • ViewModel dapat dibuat dengan dependency yang dibutuhkan.

  • Pemanggilan use case menggunakan parameter latitude dan longitude yang benar.

  • Hasil WeatherResult dapat dipetakan ke state presentation.

  • Error dari proses pengambilan data tidak membuat aplikasi berhenti secara tidak terduga.

Pada tahap ini, kita belum perlu membangun layar cuaca. Fokus kita adalah memastikan jalur data dari Android menuju shared module sudah benar.

Setelah integrasi berhasil, ViewModel akan siap digunakan oleh UI pada artikel berikutnya.

Struktur Project Kita Sekarang

Setelah menyelesaikan artikel ini, struktur project secara konseptual menjadi seperti berikut:

"weather-app-kmp/
├── shared/
│   └── src/
│       └── commonMain/
│           └── kotlin/
│               ├── domain/
│               │   ├── model/
│               │   └── usecase/
│               └── data/
│                   ├── repository/
│                   └── remote/
│
├── androidApp/
│   └── src/
│       └── main/
│           └── java/
│               └── com/example/weather/
│                   └── presentation/
│                       ├── WeatherUiState.kt
│                       ├── WeatherViewModel.kt
│                       └── WeatherViewModelFactory.kt
│
└── iosApp/
    └── ...

Struktur folder aktual dapat berbeda sesuai package yang digunakan dalam project kita.

Yang paling penting adalah pembagian tanggung jawabnya tetap konsisten:

  • shared: domain, repository, networking, dan business logic.

  • androidApp: ViewModel dan state khusus presentation Android.

  • iosApp: presentation layer native iOS yang akan kita bangun pada fase berikutnya.

Dengan struktur ini, kita dapat menggunakan kembali business logic yang sama tanpa memaksakan struktur UI Android ke aplikasi iOS.

Kesimpulan

Pada artikel keenam ini kita sudah mempersiapkan integrasi antara shared module dan aplikasi Android.

Kita sudah membahas bagaimana GetWeatherUseCase digunakan dari Android, mengapa ViewModel berada di platform layer, dan bagaimana StateFlow digunakan untuk menyediakan state yang dapat diamati oleh UI.

Kita juga mempertahankan pemisahan antara WeatherResult dari domain layer dan WeatherUiState untuk presentation layer.

Jadi, sampai di sini kita sudah memiliki fondasi untuk melanjutkan pengembangan Weather App. Kita belum membangun UI cuaca karena bagian tersebut akan menjadi fokus artikel berikutnya.

Pada Artikel 07, kita akan mulai membangun CurrentWeatherScreen menggunakan Jetpack Compose. Kita akan menampilkan suhu, kondisi cuaca, ikon, dan lokasi, kemudian menghubungkan UI tersebut dengan state dari ViewModel.

Dengan begitu, kita bisa mempelajari integrasi data terlebih dahulu, kemudian fokus pada UI tanpa mencampur terlalu banyak konsep dalam satu artikel.

Source code: Repository GitHub Weather App KMP

Sekian, terima kasih.

0 Komentar

Post a Comment

Don't be a Silent Reader!
Please leave your comments, critiques or suggestions.
Because your opinion means a lot for this blog :)

← Previous Post Home