Приведи пример реализации разных состояний с помощью Sealed Class

Пример реализации разных состояний с помощью Sealed Class в Kotlin

Sealed Class (запечатанный класс) в Kotlin — это идеальный инструмент для представления ограниченных иерархий классов, особенно для моделирования различных состояний в приложении. Его ключевые особенности: все подклассы должны быть объявлены внутри того же файла или модуля, что делает их набор ограниченным и известным на этапе компиляции. Это позволяет безопасно обрабатывать все возможные варианты в операторах when, не требуя ветки else.

Практический пример: состояние загрузки данных

Рассмотрим типичный сценарий в Android приложении: загрузка данных из сети или локального источника. Мы можем определить состояния процесса загрузки с помощью sealed class.

// Определение sealed class для состояний загрузки
sealed class LoadState {
    // Начальное состояние, данные еще не загружались
    object Idle : LoadState()

    // Состояние активной загрузки, можно добавить прогресс
    data class Loading(val progress: Int? = null) : LoadState()

    // Состояние успешной загрузки с результатом
    data class Success<T>(val data: T) : LoadState()

    // Состояние ошибки с сообщением или исключением
    data class Error(val message: String, val exception: Throwable? = null) : LoadState()
}

Использование состояний в ViewModel и UI

В ViewModel мы можем объявить состояние как наблюдаемое свойство и обновлять его по мере изменения процесса.

class DataViewModel : ViewModel() {
    private val _loadState = MutableStateFlow<LoadState>(LoadState.Idle)
    val loadState: StateFlow<LoadState> = _loadState.asStateFlow()

    fun loadData() {
        _loadState.value = LoadState.Loading()
        
        // Запускаем асинхронную операцию (например, сетевой запрос)
        viewModelScope.launch {
            try {
                val result = repository.fetchData()
                _loadState.value = LoadState.Success(result)
            } catch (e: Exception) {
                _loadState.value = LoadState.Error("Ошибка загрузки", e)
            }
        }
    }
}

В UI компоненте (Activity, Fragment или Composable) мы можем наблюдать состояние и соответствующим образом обновлять интерфейс. Оператор when обеспечивает exhaustive checking (полную проверку всех случаев).

// Пример в Jetpack Compose
@Composable
fun DataScreen(viewModel: DataViewModel) {
    val state by viewModel.loadState.collectAsStateWithLifecycle()

    Column {
        when (state) {
            LoadState.Idle -> {
                Text("Готов к загрузке")
                Button(onClick = { viewModel.loadData() }) {
                    Text("Загрузить данные")
                }
            }
            is LoadState.Loading -> {
                CircularProgressIndicator()
                if (state.progress != null) {
                    Text("Прогресс: ${state.progress}%")
                }
            }
            is LoadState.Success<*> -> {
                // Обработка успешного результата
                val data = state.data
                if (data is List<*>) {
                    LazyColumn {
                        items(data.size) { index ->
                            Text("Элемент $index: ${data[index]}")
                        }
                    }
                }
            }
            is LoadState.Error -> {
                Text("Ошибка: ${state.message}", color = Color.Red)
                Button(onClick = { viewModel.loadData() }) {
                    Text("Повторить")
                }
            }
        }
    }
}

Преимущества использования Sealed Class для состояний

• Полная безопасность типов: Компилятор проверяет, что все случаи обработаны в when. Если добавить новый подкласс в sealed class, компилятор сразу отметит места, где его нужно учесть.
• Четкая организация кода: Все возможные состояния собраны в одном месте, что улучшает читаемость и понимание логики приложения.
• Легкость расширения: Добавление нового состояния (например, Empty для пустых данных) требует лишь добавления нового подкласса и обновления обработчиков.
• Идеальная совместимость с реактивными потоками: Состояния легко передавать через StateFlow, LiveData или Observable, обеспечивая декларативное управление UI.

Дополнительные возможности

Sealed class можно комбинировать с другими функциями Kotlin:

// Использование sealed interface для межмодульных иерархий (в Kotlin 1.5+)
sealed interface ApiResult {
    class Success(val data: String) : ApiResult
    class HttpError(val code: Int) : ApiResult
    class NetworkError(val exception: IOException) : ApiResult
}

// Расширение функций для удобства
fun LoadState.isLoading() = this is LoadState.Loading
fun LoadState.isError() = this is LoadState.Error

Таким образом, Sealed Class становится центральным элементом архитектуры, позволяющим четко моделировать состояние приложения, уменьшать количество ошибок и создавать легко поддерживаемый код. Это особенно важно в сложных Android приложениях, где управление состоянием напрямую влияет на пользовательский опыт.