Android Academy · Pelajaran

Navigasi Antar-Modul

Hubungkan fitur tanpa keterikatan erat.

Navigasi Antar-Modul adalah pelajaran Android Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Android Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Android Academy mencakup 4 pelajaran total.

Tantangan Navigasi

Setelah fitur berada di modul terpisah, muncul pertanyaan baru: bagaimana :feature:home membuka layar di :feature:profile tanpa bergantung padanya? Jika fitur saling mengimpor secara langsung, akan terbentuk keterikatan dan ada risiko munculnya siklus.

Dalam pelajaran ini, Anda akan menghubungkan fitur melalui navigasi sambil menjaganya tetap mandiri.

Tempat NavHost Berada

Satu-satunya NavHost berada di modul :app, satu-satunya tempat yang diizinkan untuk mengetahui semua fitur. Setiap fitur menyumbangkan tujuannya, lalu :app merakit semuanya menjadi satu graf.

// app/AppNavHost.kt
@Composable
fun AppNavHost(navController: NavHostController = rememberNavController()) {
    NavHost(navController, startDestination = HomeRoute) {
        homeScreen(onProfileClick = { navController.navigate(ProfileRoute) })
        profileScreen(onBack = { navController.popBackStack() })
    }
}

Rute Aman Tipe

Navigation Compose modern mendukung rute aman tipe: rute berupa objek atau kelas data @Serializable, bukan string ajaib. Setiap fitur mendefinisikan tipe rutenya sendiri dalam modulnya, sehingga fitur tersebut memiliki kontrak navigasinya sendiri.

// feature/profile/ProfileRoute.kt
import kotlinx.serialization.Serializable

@Serializable
data class ProfileRoute(val userId: String)

Fitur Mengekspos Ekstensi NavGraphBuilder

Trik utamanya: setiap fitur mengekspos fungsi ekstensi NavGraphBuilder yang mendaftarkan tujuannya. Fitur memiliki layarnya sendiri; :app hanya memanggil fungsi ini. Fitur tidak pernah merujuk pada fitur lain.

// feature/profile/ProfileNavigation.kt
fun NavGraphBuilder.profileScreen(onBack: () -> Unit) {
    composable<ProfileRoute> { backStackEntry ->
        val route: ProfileRoute = backStackEntry.toRoute()
        ProfileScreen(userId = route.userId, onBack = onBack)
    }
}

Memisahkan Ketergantungan dengan Callback Navigasi

Sebuah fitur tidak boleh memanggil navigate(SomeOtherFeatureRoute) secara langsung karena hal itu akan mengharuskannya bergantung pada fitur lain. Sebagai gantinya, fitur mengekspos callback lambda seperti onProfileClick. Modul :app menentukan tujuan sebenarnya.

// feature/home/HomeNavigation.kt
fun NavGraphBuilder.homeScreen(onProfileClick: (String) -> Unit) {
    composable<HomeRoute> {
        HomeScreen(onUserClick = { userId -> onProfileClick(userId) })
    }
}
// :home does NOT know ProfileRoute exists.

Modul :app Menghubungkan Semuanya

Hanya modul :app yang mengetahui semua rute dan menghubungkan callback ke navigasi sebenarnya. Inilah satu-satunya tempat keterikatan dapat diterima—seluruh tugasnya adalah perakitan.

// app/AppNavHost.kt
NavHost(navController, startDestination = HomeRoute) {
    homeScreen(
        onProfileClick = { userId ->
            navController.navigate(ProfileRoute(userId)) // app knows both
        }
    )
    profileScreen(onBack = { navController.popBackStack() })
}

Meneruskan Argumen dengan Aman

Karena rute adalah kelas data @Serializable, argumen diperiksa tipenya saat kompilasi. Anda membacanya kembali dengan toRoute() di dalam tujuan. Tidak ada lagi penguraian string atau galat waktu berjalan dari arguments?.getString(...).

// Reading arguments inside the destination
composable<ProfileRoute> { entry ->
    val args: ProfileRoute = entry.toRoute()
    ProfileScreen(userId = args.userId)
}

// Or directly in a ViewModel via SavedStateHandle
val route: ProfileRoute = savedStateHandle.toRoute()

Berbagi Tipe Rute melalui Modul api

Terkadang sebuah fitur benar-benar perlu menavigasi ke fitur lain dan menginginkan tipe rutenya. Alih-alih bergantung pada seluruh fitur, ekspos hanya rute tersebut dalam modul :feature:profile:api kecil yang hanya berisi rute @Serializable. Modul :impl yang berat tetap privat.

// feature/profile/api  -> only the route type
@Serializable
data class ProfileRoute(val userId: String)

// feature/home/build.gradle.kts
// home may depend on the lightweight api to build the route,
// but never on :feature:profile:impl
implementation(project(":feature:profile:api"))

Navigasi Bertingkat per Fitur

Fitur dengan beberapa layar dapat mengekspos seluruh graf bertingkat menggunakan navigation<T>. Fitur tersebut memiliki alur internalnya sendiri; :app hanya memasang graf itu pada satu titik masuk.

// feature/onboarding/OnboardingNavigation.kt
fun NavGraphBuilder.onboardingGraph(onFinished: () -> Unit) {
    navigation<OnboardingGraph>(startDestination = WelcomeRoute) {
        composable<WelcomeRoute> { WelcomeScreen() }
        composable<PermissionsRoute> { PermissionsScreen(onDone = onFinished) }
    }
}

Tautan Dalam Antarmodul

Rute aman tipe juga mendukung tautan dalam. Sebuah fitur menyatakan pola URI tautan dalam untuk tujuannya; NavHost :app mengarahkan tautan yang masuk ke layar fitur yang tepat, tanpa memerlukan impor lintas fitur.

composable<ProfileRoute>(
    deepLinks = listOf(
        navDeepLink<ProfileRoute>(basePath = "https://myapp.com/profile")
    )
) { entry ->
    ProfileScreen(userId = entry.toRoute<ProfileRoute>().userId)
}

Rangkuman Pola Pemisahan Ketergantungan

Jika disatukan, aturannya sederhana:

Setiap fitur memiliki tipe rutenya dan ekstensi NavGraphBuilder.
Fitur menyampaikan maksud melalui callback lambda, bukan navigasi langsung.
Hanya :app yang mengetahui semua fitur dan menghubungkan callback ke rute sebenarnya.
Jika rute harus dibagikan, ekspos melalui modul :api kecil.

Dengan begitu, fitur tetap mandiri, dapat memanfaatkan tembolok pembangunan, dan bebas dari siklus.

Pemeriksaan Singkat

Dalam aplikasi multi-modul, :feature:home perlu mengarahkan pengguna ke layar di :feature:profile. Apa cara paling rapi untuk menjaga fitur tetap terpisah?

Rangkuman: Navigasi Antarmodul

Anda telah mempelajari cara menghubungkan fitur tanpa membuatnya saling terikat:

Satu-satunya NavHost berada di modul :app yang tipis.
Setiap fitur memiliki rute @Serializable dan ekstensi NavGraphBuilder.
Fitur mengekspos callback, bukan menavigasi langsung ke fitur lain.
Bagikan rute hanya melalui modul :api kecil jika benar-benar diperlukan; tautan dalam dan graf bertingkat mengikuti pola yang sama.

Dengan demikian, Arsitektur Aplikasi Multi-Modul selesai dipelajari: kini Anda dapat membagi, menghubungkan, dan menavigasi basis kode Android yang dapat diskalakan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Navigasi Antar-Modul” gratis?

Ya — teks lengkap “Navigasi Antar-Modul” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Android Academy, upgrade ke CoddyKit PRO. Kursus Android Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Navigasi Antar-Modul”?

Hubungkan fitur tanpa keterikatan erat. Kamu berlatih Android Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Android Academy?

Tidak diperlukan pengalaman sebelumnya. Android Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Navigasi Antar-Modul” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Android Academy ini?

Ya. Setiap pelajaran Android Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Android Academy