Modern Android uygulamalarında durum yönetimi, olay işleme ve API yanıtlarını ele almak karmaşık bir hal alabiliyor. Bu zorluklar, geliştirme sürecini uzatabilir ve uygulamanın kararlılığını riske atabilir. Peki, bu kaosu ortadan kaldıracak, kodunuzu daha okunabilir, güvenli ve sürdürülebilir hale getirecek sihirli bir çözüm olsa nasıl olurdu? Cevap: Kotlin’in güçlü sealed class özelliği!
Android uygulama geliştirirken, kullanıcı arayüzünüzün (UI) farklı durumları yönetmesi, tek seferlik olayları doğru şekilde işlemesi ve ağ isteklerinden gelen çeşitli yanıtları tutarlı bir şekilde ele alması gerektiğini sıkça görürüz. Örneğin, bir veri yüklenirken “Yükleniyor…”, hata oluştuğunda “Bir hata oluştu!” ve başarılı olduğunda verinin kendisinin gösterilmesi gerekir. Ya da bir butona basıldığında sadece bir kez gösterilmesi gereken bir “Snackbar” mesajı veya başka bir ekrana navigasyon gibi olayları nasıl ele almalıyız?
Bu senaryolar, uygun bir yapılandırma olmadan hızla bir “callback cehennemi”ne veya “Boolean bayraklar” labirentine dönüşebilir. Geliştiriciler olarak, bu tür sorunları çözmek için sürekli daha iyi yollar arıyoruz. İşte tam bu noktada Kotlin’in sealed class özelliği devreye giriyor. Bu makalede, sealed class‘ların temel mantığından başlayarak, Android projelerinizde hemen kullanabileceğiniz üç pratik ve üretim hazır “tarif” sunacağız. Bu tarifler, UI durumu yönetimi, tek seferlik olay işleme ve API yanıtlarını ele almada size yeni bir bakış açısı kazandıracak. Hazırsanız, bu lezzetli kod tariflerini birlikte keşfedelim!
Sealed Class Nedir ve Neden Android Geliştirmede Vazgeçilmezdir?
sealed class‘lar, Kotlin’in en güçlü özelliklerinden biridir ve tür güvenliği ile ifade gücünü bir araya getirir. Temel olarak, bir sealed class (veya sealed interface), belirli bir sınıf hiyerarşisi içindeki tüm alt sınıflarının derleme zamanında bilindiğini garanti eden kısıtlanmış bir hiyerarşi oluşturmanıza olanak tanır. Bu, özellikle bir durum veya olayın belirli ve sınırlı sayıda olası değeri olduğunda çok kullanışlıdır.
Bir enum class‘ı düşünün: enum class Status { LOADING, SUCCESS, ERROR }. Bu yapı, durumların sadece belirli sabit değerlerden ibaret olduğu senaryolar için harikadır. Ancak, ya durumlarımıza veri de eklemek istersek? Örneğin, SUCCESS durumunda yüklenen veriyi, ERROR durumunda ise hata mesajını taşımak istersek enum class yetersiz kalır. İşte sealed class burada fark yaratır. sealed class‘ın her bir alt sınıfı, kendi özel verilerini ve davranışlarını içerebilirken, yine de ana sealed class‘ın kısıtlı hiyerarşisinin bir parçası olmaya devam eder. Bu sayede, uygulamanızın farklı durumlarını veya olaylarını temsil eden nesneleri kolayca oluşturabilir, bunları tek bir çatı altında toplayabilir ve derleme zamanında kapsamlı kontrol sağlayabilirsiniz.
Peki, sealed class‘ları bu kadar vazgeçilmez kılan nedir? En önemli avantajlarından biri, Kotlin’in when ifadesiyle mükemmel entegrasyonudur. Bir sealed class‘ın tüm olası alt sınıflarını when ifadesinde ele aldığınızda, Kotlin derleyicisi bu durumu algılar ve başka bir else dalına ihtiyaç duymadan “exhaustiveness” (tüm durumların ele alındığı) kontrolünü yapar. Bu, gelecekte yeni bir alt sınıf eklediğinizde, when ifadesini kullanan tüm yerlerde bir derleme hatası alacağınız anlamına gelir. Bu hata, eksik durum yönetimini proaktif olarak tespit etmenizi sağlar ve böylece çalışma zamanı hatalarını büyük ölçüde azaltır. Örneğin, bir UI durumunu yönetirken, Loading, Success ve Error durumlarına ek olarak yeni bir Empty durumu eklediğinizde, bu yeni durumu ele almayan tüm when blokları derleme hatası verecek ve sizi bu durumu ele almaya zorlayacaktır. Bu, özellikle büyük ve karmaşık uygulamalarda kodun sürdürülebilirliğini ve güvenliğini artıran kritik bir özelliktir. abstract class veya interface kullandığınızda bu tür bir derleme zamanı kontrolüne sahip olamazsınız, çünkü derleyici tüm olası uygulamaları bilemez.
Basit bir örnekle sealed class‘ın gücünü görelim:
sealed class Shape {
data class Circle(val radius: Double) : Shape()
data class Rectangle(val width: Double, val height: Double) : Shape()
object Triangle : Shape() // Üçgenin özel bir verisi olmadığını varsayalım
}
fun calculateArea(shape: Shape): Double {
return when (shape) {
is Shape.Circle -> Math.PI * shape.radius * shape.radius
is Shape.Rectangle -> shape.width * shape.height
is Shape.Triangle -> 10.0 // Varsayımsal sabit alan
// Yeni bir Shape türü eklediğinizde, burası derleme hatası verecektir!
}
}
Yukarıdaki örnekte, Shape bir sealed class'tır. Circle, Rectangle ve Triangle onun alt sınıflarıdır. calculateArea fonksiyonunda, when ifadesi Shape'in tüm olası alt sınıflarını kapsadığı için, Kotlin derleyicisi bu kodun güvenli olduğunu ve başka bir duruma ihtiyaç duymadığını bilir. Bu sayede, durumlar arasındaki geçişleri ve veri akışını çok daha yönetilebilir hale getiririz.
sealed class'lar varsayılan olarak abstract'tır, bu nedenle kendileri doğrudan örneklenemezler. Alt sınıfları ise herhangi bir türden olabilir: data class, class, object veya hatta başka bir sealed class.
Android Uygulamalarında Ekran Durumlarını Sealed Class ile Nasıl Yöneteceğiz?
Herhangi bir modern Android uygulamasında, kullanıcı arayüzü sürekli olarak farklı durumlar arasında geçiş yapar: veri yükleniyor olabilir, başarıyla yüklenebilir, bir hata oluşabilir veya belki de gösterilecek hiç veri yoktur. Bu durumları tutarlı ve güvenli bir şekilde yönetmek, uygulamanın kullanıcı deneyimi ve kararlılığı için kritik öneme sahiptir. Geleneksel yaklaşımlar genellikle bir dizi Boolean bayrak veya karmaşık mantık içerir, bu da kodun okunabilirliğini azaltır ve hatalara açık hale getirir. İşte sealed class'ların parladığı ilk alan, UI durum yönetimi.
Vaka Analizi: Bir Veri Yükleme Ekranı
Hayal edin ki, bir film listesi uygulamasında ana ekranın film verilerini bir API'den çekmesi gerekiyor. Bu ekranın dört temel durumu olabilir:
- Loading (Yükleniyor): Veriler henüz API'den gelmedi ve bir yüklenme göstergesi (örneğin,
ProgressBar) gösterilmeli. - Success (Başarılı): Veriler başarıyla çekildi ve film listesi gösterilmeli.
- Error (Hata): Ağ hatası, sunucu hatası gibi bir sorun oluştu ve bir hata mesajı gösterilmeli.
- Empty (Boş): Veriler başarıyla çekildi ancak liste boş (örneğin, API'den hiç film gelmedi). Bu özel bir başarı durumu olabilir, ancak kullanıcıya "Hiç film bulunamadı" gibi bir mesaj göstermek isteyebiliriz.
Bu durumları sealed class ile temsil etmek, hem güvenli hem de okunabilir bir çözüm sunar.
Tarif 1: UI Durum Yönetimi için Sealed Class
İlk adım olarak, uygulamanızın ekran durumlarını temsil edecek bir sealed class tanımlayalım. Bu sınıf, her bir durumu ve ilgili veriyi içerecek:
// data class ve object'ler aynı sealed class'ın alt sınıfları olabilir
sealed class MovieListUiState {
object Loading : MovieListUiState()
data class Success(val movies: List) : MovieListUiState()
data class Error(val message: String) : MovieListUiState()
object Empty : MovieListUiState() // Yeni eklenen durum
}
data class Movie(val id: String, val title: String, val imageUrl: String) // Varsayımsal Movie sınıfı
Şimdi, bu MovieListUiState'i bir ViewModel içinde nasıl kullanacağımızı görelim. ViewModel, UI durumunu yönetmek ve bunu MutableStateFlow aracılığıyla UI'a bildirmek için ideal bir yerdir:
// ViewModel Katmanı
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.launch
class MovieListViewModel(private val movieRepository: MovieRepository) : ViewModel() {
private val _uiState = MutableStateFlow(MovieListUiState.Loading)
val uiState: StateFlow = _uiState
init {
fetchMovies()
}
fun fetchMovies() {
viewModelScope.launch {
_uiState.value = MovieListUiState.Loading // Yükleme durumunu başlat
try {
val movies = movieRepository.getMovies()
if (movies.isEmpty()) {
_uiState.value = MovieListUiState.Empty
} else {
_uiState.value = MovieListUiState.Success(movies)
}
} catch (e: Exception) {
_uiState.value = MovieListUiState.Error("Filmler yüklenirken bir hata oluştu: ${e.localizedMessage}")
}
}
}
}
// Varsayımsal Repository Katmanı
class MovieRepository {
suspend fun getMovies(): List {
kotlinx.coroutines.delay(2000) // Ağ gecikmesi simülasyonu
return if (Math.random() > 0.3) { // %70 başarılı, %30 hata
if (Math.random() > 0.8) emptyList() // %20 boş liste
else listOf(
Movie("1", "Inception", "url1"),
Movie("2", "The Matrix", "url2"),
Movie("3", "Interstellar", "url3")
)
} else {
throw IOException("Ağ bağlantısı hatası!")
}
}
}
Son olarak, bu durumu kullanıcı arayüzünüzde (örneğin, bir Composable fonksiyonunda veya bir Fragment/Activity'de) nasıl tüketeceğimizi görelim. Kotlin'in when ifadesi, sealed class'lar ile mükemmel bir uyum içindedir ve tüm olası durumları ele aldığınızdan emin olmanızı sağlar:
// UI Katmanı (Jetpack Compose örneği)
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.CircularProgressIndicator
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import java.io.IOException
@Composable
fun MovieListScreen(viewModel: MovieListViewModel = viewModel()) {
val uiState by viewModel.uiState.collectAsState()
Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
when (uiState) {
is MovieListUiState.Loading -> {
CircularProgressIndicator()
Text("Filmler yükleniyor...", modifier = Modifier.padding(top = 80.dp))
}
is MovieListUiState.Success -> {
val movies = (uiState as MovieListUiState.Success).movies
LazyColumn(modifier = Modifier.fillMaxSize()) {
items(movies) { movie ->
Text(movie.title, modifier = Modifier.padding(16.dp))
}
}
}
is MovieListUiState.Error -> {
val errorMessage = (uiState as MovieListUiState.Error).message
Column(horizontalAlignment = Alignment.CenterHorizontally) {
Text("Hata: $errorMessage", color = androidx.compose.ui.graphics.Color.Red)
androidx.compose.material.Button(onClick = { viewModel.fetchMovies() }) {
Text("Tekrar Dene")
}
}
}
is MovieListUiState.Empty -> { // Yeni durumu ele alıyoruz
Text("Hiç film bulunamadı.", modifier = Modifier.padding(16.dp))
androidx.compose.material.Button(onClick = { viewModel.fetchMovies() }) {
Text("Yenile")
}
}
}
}
}
Bu "yemek tarifi" ile, uygulamanızın UI durumlarını yönetmek için temiz, tip güvenli ve kapsamlı bir yaklaşım elde etmiş olursunuz. Yeni bir durum eklediğinizde, derleyici sizi UI'da bu durumu ele almaya zorlayarak potansiyel hataların önüne geçer. Bu yöntem, uygulamanızın büyüklüğü ve karmaşıklığı ne olursa olsun tutarlı bir durum yönetim deseni sağlamanıza yardımcı olur. Böylece, hem geliştirici deneyiminiz iyileşir hem de son kullanıcıya sunulan uygulamanın kalitesi artar.
Snackbar Gösterme veya Navigasyon Gibi Tek Seferlik Olaylar İçin Sealed Class Nasıl Kullanılır?
UI durum yönetimi kadar önemli olan bir diğer konu da, kullanıcı arayüzünde sadece bir kez gerçekleşmesi gereken "tek seferlik olayların" yönetilmesidir. Örneğin, bir butona basıldığında bir Snackbar mesajı göstermek, başka bir ekrana gitmek (navigasyon), bir bildirim göstermek veya bir kullanıcıya uyarı penceresi sunmak gibi eylemler tek seferlik olaylardır. Bu tür olayları doğrudan StateFlow veya LiveData gibi gözlemlenebilir durum tutucularla yönetmeye çalışmak, genellikle istenmeyen sonuçlara yol açar. Çünkü StateFlow değer tutucudur ve UI her yeniden oluşturulduğunda veya konfigürasyon değişikliğinde (ekran döndürme gibi) en son değeri tekrar yayabilir, bu da aynı olayın tekrar tekrar tetiklenmesine neden olabilir (örneğin, Snackbar'ın sürekli gösterilmesi).
Vaka Analizi: Kullanıcı Kayıt Sonrası Geri Bildirim
Bir kullanıcı kayıt formunu doldurdu ve "Kayıt Ol" butonuna bastı. Sunucuya bir istek gönderildi ve işlem başarılı oldu. Bu durumda, kullanıcıya "Kayıt işlemi başarıyla tamamlandı!" mesajını bir Snackbar ile göstermek ve ardından ana ekrana yönlendirmek istiyoruz. Eğer bu olaylar StateFlow içinde basitçe bir string mesaj olarak tutulursa, ekran döndürüldüğünde Snackbar tekrar görünebilir ve kullanıcı tekrar ana ekrana yönlendirilebilir ki bu istenmeyen bir durumdur.
Tarif 2: Tek Seferlik Olay Yönetimi için Sealed Class
Bu problemi çözmek için, tek seferlik olayları temsil eden bir sealed class kullanabiliriz. Ancak, bu sealed class'ı doğrudan bir StateFlow içinde tutmak yerine, olayların yalnızca bir kez tüketilmesini sağlamak için ek bir mekanizma, örneğin bir Channel veya Google'ın önerdiği gibi bir Event sarmalayıcı sınıfı ile birleştirmemiz gerekir.
Öncelikle, olayları tanımlayan sealed class'ımızı oluşturalım:
// Olayları temsil eden Sealed Class
sealed class UserRegistrationEvent {
data class ShowSnackbar(val message: String) : UserRegistrationEvent()
data class NavigateToHome(val userId: String) : UserRegistrationEvent()
object ShowLoadingDialog : UserRegistrationEvent()
object HideLoadingDialog : UserRegistrationEvent()
}
Şimdi, bu olayları ViewModel'dan UI'a güvenli bir şekilde aktaracak bir mekanizmaya ihtiyacımız var. Genellikle Kotlin Coroutines Channel veya tek seferlik olayları sarmalayan bir generic Event sınıfı tercih edilir. Burada Channel kullanımına odaklanalım, çünkü daha modern ve reaktif bir yaklaşım sunar:
// ViewModel Katmanı
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.receiveAsFlow
import kotlinx.coroutines.launch
class UserRegistrationViewModel(private val authRepository: AuthRepository) : ViewModel() {
// Olayları UI'a tek seferlik göndermek için Channel
private val _events = Channel()
val events = _events.receiveAsFlow() // UI, bu Flow'u dinleyecek
fun registerUser(username: String, email: String, password: String) {
viewModelScope.launch {
_events.send(UserRegistrationEvent.ShowLoadingDialog) // Yükleme diyaloğunu göster
try {
val userId = authRepository.register(username, email, password)
_events.send(UserRegistrationEvent.ShowSnackbar("Kayıt başarıyla tamamlandı!"))
_events.send(UserRegistrationEvent.NavigateToHome(userId))
} catch (e: Exception) {
_events.send(UserRegistrationEvent.ShowSnackbar("Kayıt hatası: ${e.localizedMessage}"))
} finally {
_events.send(UserRegistrationEvent.HideLoadingDialog) // Yükleme diyaloğunu gizle
}
}
}
}
// Varsayımsal Authentication Repository
class AuthRepository {
suspend fun register(username: String, email: String, password: String): String {
kotlinx.coroutines.delay(1500) // Ağ gecikmesi simülasyonu
if (username == "test" && password == "123") {
throw IllegalArgumentException("Bu kullanıcı adı zaten mevcut!")
}
return "user_${System.currentTimeMillis()}" // Başarılı kayıt, userId döndür
}
}
Şimdi bu olayları UI katmanında nasıl tüketeceğimizi görelim. Channel'dan gelen olayları bir LaunchedEffect içinde dinlemek, Compose'da tek seferlik olayları işlemenin güvenli bir yoludur. Android View sisteminde ise Lifecycle.RepeatOnLifecycle bloğu içinde dinlemek tercih edilir:
// UI Katmanı (Jetpack Compose örneği)
import androidx.compose.material.Scaffold
import androidx.compose.material.rememberScaffoldState
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.ui.platform.LocalContext
import androidx.lifecycle.viewmodel.compose.viewModel
import androidx.navigation.NavController
import androidx.compose.material.SnackbarDuration
@Composable
fun UserRegistrationScreen(
viewModel: UserRegistrationViewModel = viewModel(),
navController: NavController
) {
val scaffoldState = rememberScaffoldState()
val context = LocalContext.current
// ViewModel'dan gelen olayları dinle
LaunchedEffect(Unit) {
viewModel.events.collect { event ->
when (event) {
is UserRegistrationEvent.ShowSnackbar -> {
scaffoldState.snackbarHostState.showSnackbar(event.message, duration = SnackbarDuration.Short)
}
is UserRegistrationEvent.NavigateToHome -> {
navController.navigate("home/${event.userId}") {
popUpTo("registration") { inclusive = true } // Kayıt ekranını back stack'ten temizle
}
}
is UserRegistrationEvent.ShowLoadingDialog -> {
// Yükleme diyaloğunu göster (örneğin, bir Dialog Composable)
// Gerçek uygulamada, bu bir StateFlow ile daha iyi yönetilebilir.
// Bu örnekte basitleştirildi.
}
is UserRegistrationEvent.HideLoadingDialog -> {
// Yükleme diyaloğunu gizle
}
}
}
}
Scaffold(scaffoldState = scaffoldState) { paddingValues ->
// Kayıt formu UI'ı buraya gelecek
// Örnek olarak basit bir buton ekleyelim
androidx.compose.material.Button(
onClick = { viewModel.registerUser("ali", "ali@example.com", "password123") },
modifier = androidx.compose.ui.Modifier.padding(paddingValues).fillMaxWidth().wrapContentHeight()
) {
Text("Kayıt Ol")
}
}
}
Bu yaklaşımla, tek seferlik olaylarınızı güvenli, okunabilir ve tekrar oynatma riski olmadan yönetebilirsiniz. sealed class, olayların türlerini açıkça tanımlamanıza olanak tanırken, Channel ise bu olayların sadece bir kez tüketilmesini garanti eder. Bu "tarif", uygulamanızın etkileşimli öğelerini ve geri bildirim mekanizmalarını çok daha sağlam hale getirecektir. Ayrıca, yeni bir olay türü eklediğinizde, when ifadesi sizi otomatik olarak bu yeni durumu ele almaya zorlayarak hata yapma olasılığınızı minimuma indirir.
Channel kullanırken, Channel'ın ömrünü UI'ın ömrüne bağlamak için LaunchedEffect(Unit) veya Lifecycle.RepeatOnLifecycle kullanmak önemlidir. Aksi takdirde, gözlemleme işlemi UI'dan daha uzun sürebilir veya istenmeyen şekilde sonlanabilir.
Ağ İsteklerinden Gelen Cevapları Daha Robust Bir Şekilde Nasıl İşleriz?
Modern Android uygulamaları, verileri genellikle ağ üzerinden bir sunucudan çeker. Bu ağ istekleri, birçok farklı sonuca yol açabilir: başarılı bir yanıt (veri ile veya verisiz), çeşitli hata türleri (ağ hatası, sunucu hatası, yetkilendirme hatası, veri dönüşüm hatası vb.). Bu farklı senaryoları tutarlı, güvenli ve kolayca yönetilebilir bir şekilde ele almak, uygulamanın sağlamlığı ve kullanıcı deneyimi için hayati öneme sahiptir. Geleneksel olarak, bu durumlar genellikle try-catch blokları, HTTP durum kodlarının manuel kontrolü veya callback arayüzleri ile yönetilir, ancak bu yaklaşımlar genellikle kod tekrarına ve karışıklığa neden olabilir. İşte sealed class'lar, API yanıtlarını modellemek ve işlemek için güçlü bir soyutlama katmanı sağlar.
Vaka Analizi: Bir E-ticaret Uygulamasında Ürün Listesi Çekme
Bir e-ticaret uygulamasında, kullanıcı bir kategori seçtiğinde ilgili ürün listesini bir API'den çekmemiz gerekiyor. Bu işlem sırasında aşağıdaki durumlarla karşılaşabiliriz:
- Loading (Yükleniyor): Ürün verileri henüz API'den gelmedi.
- Success (Başarılı): Ürünler başarıyla çekildi. Liste boş da olabilir.
- Error (Hata): Farklı türde hatalar oluşabilir:
- Network Error (Ağ Hatası): İnternet bağlantısı yok veya sunucuya erişilemiyor.
- Server Error (Sunucu Hatası): Sunucu tarafında bir sorun (HTTP 5xx).
- Client Error (İstemci Hatası): Geçersiz istek (HTTP 4xx, örneğin yetkilendirme hatası 401).
- Unknown Error (Bilinmeyen Hata): Beklenmedik bir durum oluştu.
Bu zengin hata senaryolarını tek bir sealed class altında toplamak, kodumuzu hem daha okunaklı hem de daha güvenli hale getirir.
Tarif 3: Gelişmiş API Yanıtı İşleme için Sealed Class
Bu tarif için, API yanıtlarımızı temsil edecek genel bir sealed class Result tanımlayacağız. Bu, herhangi bir türdeki (T) veriyi taşıyabilir ve farklı hata türlerini içerebilir.
// API yanıtlarını temsil eden Sealed Class
sealed class Result { // 'out' anahtar kelimesi kovaryans için kullanılır
object Loading : Result()
data class Success(val data: T) : Result()
data class Error(val exception: Throwable) : Result()
}
// Hata tiplerini daha detaylandırmak için başka bir sealed class kullanabiliriz
sealed class CustomError : Throwable() {
data class NetworkError(override val message: String = "Ağ bağlantısı hatası!") : CustomError()
data class ServerError(val code: Int, override val message: String) : CustomError()
data class ClientError(val code: Int, override val message: String) : CustomError()
data class UnknownError(override val message: String = "Bilinmeyen bir hata oluştu.") : CustomError()
}
data class Product(val id: String, val name: String, val price: Double, val imageUrl: String) // Varsayımsal Product sınıfı
Şimdi, bu Result sınıfını bir Repository katmanında nasıl kullanacağımıza bakalım. Repository, API çağrılarını yapar ve sonucu bir Result nesnesi olarak döndürür. Bu sayede, ağ işleminin tüm olası çıktıları tek bir türde paketlenmiş olur.
// Repository Katmanı
import java.io.IOException
import retrofit2.HttpException
class ProductRepository(private val apiService: ProductApiService) {
suspend fun getProducts(categoryId: String): Result> {
return try {
val response = apiService.getProductsByCategory(categoryId)
if (response.isSuccessful && response.body() != null) {
Result.Success(response.body()!!)
} else {
val errorBody = response.errorBody()?.string()
val errorMessage = errorBody ?: "Sunucu hatası: ${response.code()}"
Result.Error(CustomError.ServerError(response.code(), errorMessage))
}
} catch (e: IOException) {
Result.Error(CustomError.NetworkError())
} catch (e: HttpException) {
when (e.code()) {
in 400..499 -> Result.Error(CustomError.ClientError(e.code(), e.message()))
in 500..599 -> Result.Error(CustomError.ServerError(e.code(), e.message()))
else -> Result.Error(CustomError.UnknownError(e.message()))
}
} catch (e: Exception) {
Result.Error(CustomError.UnknownError(e.localizedMessage ?: "Bilinmeyen hata"))
}
}
}
// Varsayımsal Retrofit API Servisi
interface ProductApiService {
@GET("products/{categoryId}")
suspend fun getProductsByCategory(@Path("categoryId") categoryId: String): Response>
}
Son olarak, ViewModel bu Result'ı tüketir ve bunu UI katmanının anlayacağı bir UiState'e dönüştürür. Bu, sorumluluk ayrımını korumanın ve UI katmanını API'nin detaylarından izole etmenin iyi bir yoludur:
// ViewModel Katmanı
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.launch
class ProductListViewModel(private val productRepository: ProductRepository) : ViewModel() {
private val _uiState = MutableStateFlow(ProductListUiState.Loading)
val uiState: StateFlow = _uiState
init {
fetchProducts("electronics") // Başlangıçta bir kategori için ürünleri çek
}
fun fetchProducts(categoryId: String) {
viewModelScope.launch {
_uiState.value = ProductListUiState.Loading
when (val result = productRepository.getProducts(categoryId)) {
is Result.Loading -> _uiState.value = ProductListUiState.Loading // Normalde repository'den gelmez, UI için tutulur
is Result.Success -> {
if (result.data.isEmpty()) {
_uiState.value = ProductListUiState.Empty
} else {
_uiState.value = ProductListUiState.Success(result.data)
}
}
is Result.Error -> {
val errorMessage = when (val error = result.exception) {
is CustomError.NetworkError -> "İnternet bağlantınızı kontrol edin."
is CustomError.ServerError -> "Sunucu hatası: ${error.code} - ${error.message}"
is CustomError.ClientError -> "İstek hatası: ${error.code} - ${error.message}"
is CustomError.UnknownError -> "Beklenmeyen bir hata oluştu: ${error.message}"
else -> "Genel bir hata oluştu."
}
_uiState.value = ProductListUiState.Error(errorMessage)
}
}
}
}
}
// UI Katmanı için özel bir Sealed Class (yukarıdaki MovieListUiState'e benzer)
sealed class ProductListUiState {
object Loading : ProductListUiState()
data class Success(val products: List) : ProductListUiState()
data class Error(val message: String) : ProductListUiState()
object Empty : ProductListUiState()
}
Bu "yemek tarifi", API yanıtlarını işlemek için güçlü, tip güvenli ve modüler bir yaklaşım sunar. Result sealed class'ı sayesinde, olası tüm yanıt durumlarını (başarılı veri, farklı hata türleri) tek bir soyutlama altında toplarız. Bu, hem Repository hem de ViewModel katmanlarında kodun okunabilirliğini artırır hem de her bir durumun özel olarak ele alınmasını sağlar. Yeni bir hata türü veya yanıt senaryosu eklediğinizde, when ifadeleri sizi bu yeni durumu ele almaya zorlayarak uygulamanızın daha sağlam ve hatasız olmasını garantiler. Böylece, uygulamanızın ağ işlemlerini çok daha güvenilir ve yönetilebilir bir şekilde tasarlayabilirsiniz.
Sealed Class'ları Daha Verimli ve Güvenli Kullanmak İçin Püf Noktaları Nelerdir?
sealed class'ların gücünü ve esnekliğini gördük. Ancak, bu harika aracı daha da verimli ve güvenli kullanmak için dikkat etmemiz gereken bazı püf noktaları ve ileri düzey konular bulunmaktadır. Bu ipuçları, özellikle büyük ölçekli ve uzun ömürlü projelerde kod kalitenizi artırmanıza yardımcı olacaktır.
İçi İçe Sealed Class'lar (Nested Sealed Classes)
Bazen, bir sealed class'ın alt sınıfları bile kendi içinde daha fazla durumu veya varyantı içerebilir. Bu tür senaryolarda, içi içe sealed class'lar kullanmak hiyerarşiyi daha okunabilir ve modüler hale getirebilir. Örneğin, bir önceki "API Yanıtı İşleme" tarifindeki CustomError sınıfı aslında bir sealed class olarak tanımlanmıştır ve Result.Error sınıfı içindeki exception parametresini daha spesifik hale getirmemizi sağlar. Bu, hata yönetiminde detay seviyesini artırır ve UI'da hata türüne göre farklı mesajlar veya eylemler göstermemize olanak tanır.
// Örnek: Bir mesajlaşma uygulamasında mesaj türleri
sealed class Message {
data class TextMessage(val content: String, val timestamp: Long) : Message()
sealed class MediaMessage : Message() {
data class Image(val imageUrl: String, val caption: String?) : MediaMessage()
data class Video(val videoUrl: String, val duration: Long) : MediaMessage()
}
data class SystemMessage(val event: String) : Message()
}
fun displayMessage(message: Message) {
when (message) {
is Message.TextMessage -> println("Metin: ${message.content}")
is Message.MediaMessage.Image -> println("Resim: ${message.imageUrl}")
is Message.MediaMessage.Video -> println("Video: ${message.videoUrl}")
is Message.SystemMessage -> println("Sistem: ${message.event}")
}
}
Bu yapı, karmaşık veri modellerini temiz bir şekilde düzenlemek için idealdir.
Sealed Interface mi, Sealed Class mı? Ne Zaman Hangisini Tercih Etmeliyiz?
Kotlin 1.5 itibarıyla sealed interface'ler de tanıtıldı. Temel fark şudur:
sealed class: Kalıtım hiyerarşisi oluşturur. Alt sınıflar hemsealed class'ın kendisinden miras alabilir hem de kendi içinde veri taşıyabilir. Genellikle durumları veya olayları somut bir şekilde temsil etmek için kullanılır.sealed interface: Yalnızca arayüzlerin (interface) kısıtlı bir hiyerarşisini oluşturur. Alt sınıflar, hemsealed interface'i uygulayabilir hem de başka sınıflardan miras alabilirler (çoklu kalıtım faydası). Eğer temelsealedyapısının bir davranış sözleşmesi (interface) olmasını ve farklı hiyerarşilerdeki sınıfların bu sözleşmeyi uygulamasını istiyorsanızsealed interfacetercih edin.
Örnek olarak, eğer bir sealed class'ın tüm alt sınıflarının belirli bir metodu uygulaması gerekiyorsa ve bu alt sınıflar farklı temel sınıflardan türeyebiliyorsa, sealed interface daha uygun olabilir. Ancak çoğu durum yönetimi senaryosunda sealed class yeterli ve daha yaygın bir kullanımdır.
Serialization ile Sealed Class Kullanımı
Uygulamanızın durumunu kaydetmek (örneğin, bir Bundle içine veya DataStore'a) veya ağ üzerinden göndermek istediğinizde sealed class'ları serialize etmeniz gerekebilir. Kotlin Serialization kütüphanesi (kotlinx.serialization) sealed class'lar için yerleşik desteğe sahiptir. Her bir alt sınıf için bir @Serializable ve ana sealed class için @Serializable ve @Subclass anotasyonlarını kullanmanız yeterlidir. Parcelable ile kullanırken ise her alt sınıfın ayrı ayrı Parcelable arayüzünü uygulaması gerekir.
// build.gradle.kts (module level)
// plugins { id("org.jetbrains.kotlin.plugin.serialization") version "1.X.X" }
// dependencies { implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.X.X") }
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
@Serializable
sealed class DataEvent {
@Serializable
data class DataLoaded(val items: List) : DataEvent()
@Serializable
object LoadingData : DataEvent()
@Serializable
data class ErrorLoading(val code: Int, val message: String) : DataEvent()
}
fun main() {
val event: DataEvent = DataEvent.DataLoaded(listOf("Item A", "Item B"))
val jsonString = Json.encodeToString(DataEvent.serializer(), event)
println(jsonString) // {"type":"DataLoaded","items":["Item A","Item B"]}
val decodedEvent = Json.decodeFromString(DataEvent.serializer(), jsonString)
println(decodedEvent) // DataLoaded(items=[Item A, Item B])
}
Bu, karmaşık durum objelerini kolayca kaydetmenize ve geri yüklemenize olanak tanır.
Testing Stratejileri
sealed class'lar, test edilebilirliği büyük ölçüde artırır. Bir ViewModel'ın veya iş mantığı sınıfının bir sealed class döndürdüğü durumlarda, her bir olası durumu (Loading, Success, Error, vb.) ayrı ayrı test edebilirsiniz. when ifadesinin kapsamlı yapısı sayesinde, her durumun doğru şekilde ele alındığını doğrulamak çok daha kolaydır. Testlerinizde her alt sınıf örneğini oluşturup ilgili fonksiyona geçirerek beklenen çıktıyı kontrol edebilirsiniz.
Object Kullanımı
Eğer bir sealed class alt sınıfının hiçbir durum verisi taşımayan tekil bir örnek olması gerekiyorsa (örneğin, Loading veya Empty durumları gibi), object deklarasyonu kullanın. Bu, hafıza optimizasyonu sağlar ve gereksiz nesne oluşturmaktan kaçınır. Örneğin, MovieListUiState.Loading ve MovieListUiState.Empty durumları için object kullanmıştık. Bu, okunabilirliği artırır ve kodun amacını daha net bir şekilde ifade eder.
Bu ileri düzey ipuçları ve püf noktaları, sealed class'ların gücünü tam olarak kullanmanıza ve Android uygulamalarınızı daha sağlam, bakımı kolay ve geliştirici dostu hale getirmenize yardımcı olacaktır. Unutmayın, doğru aracı doğru yerde kullanmak, kaliteli yazılım geliştirmenin anahtarıdır.
Sealed Class'ların Android Geliştirmedeki Gücünü Keşfettik
Bu makalede, Kotlin'in sealed class özelliğinin Android uygulama geliştirmedeki paha biçilmez rolünü derinlemesine inceledik. Gördük ki, sealed class'lar, uygulamanızın farklı durumlarını, tek seferlik olaylarını ve API yanıtlarını yönetmek için son derece etkili, tip güvenli ve okunabilir bir yol sunuyor. Geleneksel yaklaşımların getirdiği karmaşıklık, hata riski ve sürdürülebilirlik sorunlarına karşı, sealed class'lar modern ve güçlü bir alternatif olarak öne çıkıyor.
UI durum yönetimi tarifimizle, bir ekranın olası tüm durumlarını (yükleme, başarılı, hata, boş) tek bir sealed class altında toplayarak, UI'ın bu durumları tutarlı bir şekilde göstermesini sağladık. Tek seferlik olay yönetimi tarifimiz, Snackbar mesajları veya navigasyon gibi eylemlerin yalnızca bir kez tetiklenmesini garanti etmek için sealed class'ları Channel ile birleştirmeyi öğretti. Son olarak, gelişmiş API yanıtı işleme tarifimiz, ağ isteklerinden gelen çeşitli başarı ve hata senaryolarını (ağ hatası, sunucu hatası, istemci hatası) sealed class Result ve içi içe sealed class'lar aracılığıyla nasıl daha sağlam bir şekilde ele alacağımızı gösterdi.
sealed class'ların sunduğu en büyük avantajlardan biri, Kotlin derleyicisinin when ifadesiyle yaptığı "exhaustive check" yeteneğidir. Bu sayede, yeni bir durum veya olay eklediğinizde, ilgili when bloklarını güncellemediğiniz takdirde derleme hatası alarak potansiyel çalışma zamanı hatalarını daha kod yazma aşamasında tespit edersiniz. Bu proaktif hata tespiti, uygulamanızın kararlılığını artırır ve geliştirme sürecindeki "debugging" yükünü azaltır.
Özetle, sealed class'lar Android geliştiricileri için sadece bir dil özelliği olmaktan öte, kod kalitesini, okunabilirliğini ve sürdürülebilirliğini artıran temel bir araç setidir. Bu "yemek kitabı"ndaki tarifleri kendi projelerinizde uygulayarak, daha sağlam, daha az hatalı ve geliştirilmesi daha keyifli uygulamalar oluşturabilirsiniz. Kotlin'in bu güçlü özelliğini kullanarak, karmaşık problemleri zarif çözümlerle aşmanın keyfini çıkarın!
Sealed Class'lar ile İlgili Merak Edilenler
İşte sealed class'lar hakkında sıkça sorulan bazı sorular ve cevapları:
-
Q1:
enumilesealed classarasındaki temel fark nedir?A1:
enum class'lar sabit ve önceden tanımlanmış değerler kümesini temsil eder ve her bir enum sabiti tekil bir objedir. Kendi içinde ek veri taşıyamazlar.sealed class'lar ise kısıtlı bir sınıf hiyerarşisi tanımlar ve her alt sınıf kendi içinde veri taşıyabilir. Ayrıca, alt sınıflardata class,objectveya sıradanclassolabilir, bu da onlara daha fazla esneklik kazandırır.sealed class'lar durum ve olay yönetimi gibi daha karmaşık senaryolar için idealdir,enum'lar ise basit, sabit değer kümeleri için. -
Q2:
sealed interfacene zamansealed classyerine tercih edilmeli?A2:
sealed interface, alt sınıflarının birden fazla temel sınıftan miras alabileceği veya başka arayüzleri uygulayabileceği durumlarda tercih edilmelidir.sealed class'lar tek bir temel sınıftan miras alma kısıtlamasına sahiptir. Eğer temel soyutlamanız bir davranış sözleşmesi (interface) olacaksa ve bu davranışı uygulayan farklı türdeki sınıfları kısıtlı bir hiyerarşide toplamak istiyorsanızsealed interfacekullanışlıdır. Çoğu durum veya olay yönetimi senaryosundasealed classyeterli olacaktır. -
Q3:
sealed class'lar performans üzerinde olumsuz bir etki yaratır mı?A3: Hayır,
sealed class'ların kendileri performans üzerinde kayda değer bir olumsuz etki yaratmaz. Derleyici,sealed class'ları vewhenifadelerini optimize eder. Aslında,sealed class'lar sayesinde elde edilen tip güvenliği ve derleme zamanı kontrolleri, çalışma zamanı hatalarını azaltarak ve daha temiz kod yazımını teşvik ederek genel uygulama performansına ve kararlılığına olumlu katkı sağlayabilir. -
Q4:
sealed class'ları serialization (örneğin Parcelable) ile nasıl kullanabiliriz?A4:
sealed class'ları serialization için kullanmak mümkündür.kotlinx.serializationkütüphanesi,@Serializableve@Subclassanotasyonları ilesealed class'ların serialization'ını doğal olarak destekler. Parcelable ile kullanırken, her alt sınıfın ayrı ayrıParcelablearayüzünü uygulaması ve gerekliCREATORobjesini sağlaması gerekir. Bu, genellikle her alt sınıfı bağımsız birParcelableolarak ele almayı gerektirir. -
Q5:
sealed class'lar yerine normal abstract class veya interface kullansak ne olur?A5: Normal
abstract classveyainterfacekullanmak, Kotlin derleyicisininwhenifadelerinde "exhaustive check" yapmasını engeller. Yani,abstract class'ı uygulayan veyainterface'i implemente eden tüm alt sınıfları birwhenifadesinde ele alsanız bile, derleyici size bunu garanti etmez ve genellikle birelsedalı eklemenizi ister. Bu, yeni bir alt sınıf eklediğinizde mevcutwhenbloklarını güncellemediğiniz takdirde çalışma zamanı hatalarına yol açabilecek potansiyel bir eksikliği maskeler.sealed class'lar bu riski ortadan kaldırarak daha güvenli ve sürdürülebilir kod yazımını teşvik eder.