Android Academy · Ders

Özellik ve Çekirdek Modüller

Modül sınırlarını çizin.

Özellik ve Çekirdek Modüller, CoddyKit'te ücretsiz bir Android Academy dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Android Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Android Academy kursu toplamda 4 dersten oluşur.

İki Tür Modül

Modülerleştirilmiş Android uygulamalarının çoğu kodu iki ana modül türünde düzenler: feature modülleri ve core modülleri; bunların üzerinde de ince bir :app modülü bulunur.

Feature modülleri, uygulamanın kullanıcıya sunulan bir bölümünü (bir ekranı veya akışı) barındırır.
Core modülleri, birçok özellik tarafından kullanılan ortak altyapıyı barındırır.

Bu derste bu sınırları nasıl doğru çizeceğinizi öğreneceksiniz.

Bir Feature Modülünün Anatomisi

:feature:profile gibi bir feature modülü, tek bir özelliğin ihtiyaç duyduğu her şeyi içerir: Compose ekranlarını, ViewModel öğesini ve kullanıcı arayüzü durumunu. Bu yapı dikeydir; kullanıcı arayüzünden görünüm modeline kadar olan tüm bölüme sahiptir.

Paylaşılan parçalar için core modüllerine bağımlıdır; ancak diğer feature modüllerine bağımlı olmamalıdır.

// feature/profile/ProfileScreen.kt
@Composable
fun ProfileScreen(viewModel: ProfileViewModel = hiltViewModel()) {
    val state by viewModel.uiState.collectAsStateWithLifecycle()
    when (state) {
        is ProfileUiState.Loading -> CircularProgressIndicator()
        is ProfileUiState.Success -> ProfileContent((state as ProfileUiState.Success).user)
        is ProfileUiState.Error -> ErrorMessage()
    }
}

Feature ViewModel'i

Her özellik kendi ViewModel öğesine sahiptir. Verileri bir core modülündeki depo üzerinden alır ve kullanıcı arayüzü durumunu dışa açar. Feature modülü verilerin nasıl getirildiğini değil, yalnızca depo sözleşmesini bilir.

// feature/profile/ProfileViewModel.kt
@HiltViewModel
class ProfileViewModel @Inject constructor(
    private val userRepository: UserRepository // from :core:data
) : ViewModel() {
    val uiState: StateFlow<ProfileUiState> =
        userRepository.observeUser()
            .map { ProfileUiState.Success(it) }
            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), ProfileUiState.Loading)
}

Bir Core Modülünün Anatomisi

Bir core modülü yataydır: özellikler arasında kullanılan tek bir yetenek sağlar. Yaygın core modülleri şunlardır:

:core:model — her yerde paylaşılan basit veri sınıfları
:core:network — Retrofit/Ktor istemcileri
:core:database — Room kurulumu
:core:data — ağ ile veritabanını birleştiren depolar
:core:designsystem — tema ve yeniden kullanılabilir bileştiriciler

// core/model/User.kt
data class User(
    val id: String,
    val name: String,
    val avatarUrl: String
)

Tasarım Sistemi Modülü

:core:designsystem, en çok yeniden kullanılan modüllerden biridir. MaterialTheme, renk şemalarınızı, tipografinizi ve düğmeler ile kartlar gibi yeniden kullanılabilir bileştiricileri barındırır. Her özellik, kodu kopyalamadan aynı görünümü kullanır.

// core/designsystem/AppTheme.kt
@Composable
fun AppTheme(
    darkTheme: Boolean = isSystemInDarkTheme(),
    content: @Composable () -> Unit
) {
    val colors = if (darkTheme) DarkColors else LightColors
    MaterialTheme(
        colorScheme = colors,
        typography = AppTypography,
        content = content
    )
}

Veri Modülü Depoların Sahibidir

:core:data modülü, özelliklerin bağımlı olduğu depo arayüzlerini dışa açarken uygulamayı gizler. Genellikle :core:network ve :core:database modüllerine bağımlıdır ve bunları tek bir gerçeklik kaynağında birleştirir.

// core/data/UserRepository.kt
interface UserRepository {
    fun observeUser(): Flow<User>
    suspend fun refresh()
}

// core/data/OfflineFirstUserRepository.kt
internal class OfflineFirstUserRepository @Inject constructor(
    private val api: UserApi,        // :core:network
    private val dao: UserDao         // :core:database
) : UserRepository {
    override fun observeUser(): Flow<User> = dao.observe().map { it.toUser() }
    override suspend fun refresh() { dao.upsert(api.fetch().toEntity()) }
}

Modeli ve tasarım sistemini hafif tutun

En alt düzeydeki çekirdek modüller mümkün olduğunca az bağımlılığa sahip olmalıdır. :core:model ideal olarak hiçbir Android bağımlılığı içermemeli — yalnızca düz Kotlin veri sınıflarından oluşmalıdır. Bu, modülün her yerde kullanılabilmesini ve hızlı derlenmesini sağlar.

:core:model Retrofit veya Room'a bağımlı hâle gelirse, veri sınıflarınızı kullanan her modül bu ağır kütüphaneleri de beraberinde getirir.

// core/model/build.gradle.kts
plugins {
    id("myapp.jvm.library") // pure Kotlin, no Android
}
// No Retrofit, no Room, no Compose here — just data classes

İnce :app Modülü

:app modülü birleştirici görevi görür. İçinde çok az mantık bulunmalıdır: Application sınıfı, tek MainActivity, üst düzey NavHost ve bağımlılık ekleme bağlantıları. Gerçek ekranların tamamı özellik modüllerinde yer alır.

İnce bir uygulama modülü, değişikliklerin çoğunun özelliklerde gerçekleşmesi anlamına gelir; bu nedenle uygulama modülünün yeniden derlenmesi nadir olur.

// app/MainActivity.kt
@AndroidEntryPoint
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            AppTheme {            // from :core:designsystem
                AppNavHost()      // routes into :feature:* screens
            }
        }
    }
}

İyi Sınırlar Belirleme

Neyin modül olacağına nasıl karar verirsiniz? İşe yarayan bazı pratik ölçütler şunlardır:

Özellik = kullanıcının adını söyleyebileceği bir ekran veya akış (Ana Sayfa, Profil, Ödeme).
Çekirdek modülü = 2 veya daha fazla özellik tarafından yeniden kullanılan bir yetenek.
İki özellik aynı koda ihtiyaç duyuyorsa bu kodu aşağıya, bir çekirdek modülüne taşıyın.
Bir modül birbiriyle ilgisiz çok fazla iş yapıyorsa onu bölün.

İsteğe bağlı: api ve impl Ayrımı

Büyük uygulamalarda bazen bir özellik, herkese açık :feature:profile:api (arayüzler, gezinme rotaları) ve özel :feature:profile:impl (ekranlar, görünüm modelleri) olarak ikiye ayrılır. Diğer özellikler yalnızca küçük api modülüne bağımlı olur, uygulamaya değil.

Bu ileri düzey bir yaklaşımdır; çoğu uygulama için özellik başına tek bir modül yeterlidir. Yine de çok büyük kod tabanları için bu yaklaşımın var olduğunu bilmeniz yeterlidir.

// Other features see only the contract, not the screens
// feature/home depends on :feature:profile:api
interface ProfileEntry {
    val route: String
    fun NavGraphBuilder.register(navController: NavController)
}

Grafiği Bir Araya Getirme

Örneğimizde katmanların nasıl bağlandığı aşağıda gösterilmiştir. Bağımlılıkların yalnızca aşağıya doğru yöneldiğine dikkat edin: app -> feature -> data -> network/database -> model.

// :app           -> :feature:home, :feature:profile
// :feature:home  -> :core:data, :core:designsystem
// :feature:profile -> :core:data, :core:designsystem
// :core:data     -> :core:network, :core:database, :core:model
// :core:network  -> :core:model
// :core:database -> :core:model
// :core:model    -> (nothing)

Hızlı Kontrol

:feature:home ve :feature:profile modüllerinizin her ikisinin de kullanıcı verilerini alıp önbelleğe alması gerekiyor. Bu depo kodu nerede bulunmalıdır?

Özet: Özellik ve Çekirdek Modülleri

Kodu iki katmana ayırmayı öğrendiniz:

Özellik modülleri, dikey kesitlerdir (ekran + ViewModel + kullanıcı arayüzü durumu).
Çekirdek modülleri, yatay yeteneklerdir (model, ağ, veritabanı, veri, tasarım sistemi).
:app modülü ince kalır ve yalnızca özellikleri bir araya getirir.
Paylaşılan kod çekirdeğe aşağıya taşınır; :core:model Android'den bağımsız ve hafif kalır.

Sonraki bölümde bu modüller arasındaki bağımlılıkları yönetecek ve grafiği temiz tutacaksınız.

Sıkça Sorulan Sorular

“Özellik ve Çekirdek Modüller” dersi ücretsiz mi?

Evet — “Özellik ve Çekirdek Modüller” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Android Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Android Academy kursu toplamda 4 dersten oluşur.

“Özellik ve Çekirdek Modüller” dersinde ne öğreneceğim?

Modül sınırlarını çizin. Android Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Android Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Android Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“Özellik ve Çekirdek Modüller” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Android Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Android Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Android Academy Sayfasına Dön