Какие знаешь способы интеграции DataStore в приложение?

Способы интеграции DataStore в Android-приложение

DataStore — это современная библиотека для хранения данных, пришедшая на смену SharedPreferences. Она предоставляет два основных типа: Preferences DataStore для хранения пар ключ-значение и Proto DataStore для хранения типизированных объектов. Вот основные способы интеграции DataStore в приложение:

1. Базовая настройка зависимостей

Прежде всего, необходимо добавить зависимости в build.gradle файл:

// В файле build.gradle уровня модуля (app)
dependencies {
    // Preferences DataStore
    implementation("androidx.datastore:datastore-preferences:1.0.0")
    
    // Proto DataStore (если используете)
    implementation("androidx.datastore:datastore:1.0.0")
    implementation("com.google.protobuf:protobuf-javalite:3.21.12")
    
    // Корутины (обязательно, так как DataStore асинхронна)
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
}

2. Создание экземпляра DataStore

Preferences DataStore:

import androidx.datastore.preferences.core.*
import androidx.datastore.preferences.preferencesDataStore

// На уровне Activity или Application
val Context.dataStore: DataStore<Preferences> by preferencesDataStore(
    name = "settings"
)

// Или с использованием предварительно определенных ключей
object PreferencesKeys {
    val USER_NAME = stringPreferencesKey("user_name")
    val IS_LOGGED_IN = booleanPreferencesKey("is_logged_in")
    val NOTIFICATIONS_ENABLED = booleanPreferencesKey("notifications_enabled")
}

Proto DataStore:

// Сначала определяем структуру данных в .proto файле
// user_prefs.proto:
// syntax = "proto3";
// option java_package = "com.example.app";
// message UserPreferences {
//   string username = 1;
//   bool is_logged_in = 2;
//   int32 login_count = 3;
// }

// Затем создаем сериализатор
import androidx.datastore.core.Serializer

object UserPreferencesSerializer : Serializer<UserPreferences> {
    override val defaultValue = UserPreferences.getDefaultInstance()
    
    override suspend fun readFrom(input: InputStream): UserPreferences {
        try {
            return UserPreferences.parseFrom(input)
        } catch (e: Exception) {
            throw CorruptionException("Cannot read proto", e)
        }
    }
    
    override suspend fun writeTo(t: UserPreferences, output: OutputStream) {
        t.writeTo(output)
    }
}

// Создаем экземпляр DataStore
val Context.userPreferencesDataStore: DataStore<UserPreferences> by dataStore(
    fileName = "user_prefs.pb",
    serializer = UserPreferencesSerializer
)

3. Паттерны внедрения зависимостей

С помощью Dagger/Hilt:

// Модуль в Hilt
@Module
@InstallIn(SingletonComponent::class)
object DataStoreModule {
    
    @Provides
    @Singleton
    fun providePreferencesDataStore(@ApplicationContext context: Context): DataStore<Preferences> {
        return context.dataStore
    }
    
    // Или для конкретного типа данных
    @Provides
    @Singleton
    fun provideUserPreferencesDataStore(@ApplicationContext context: Context): DataStore<UserPreferences> {
        return context.userPreferencesDataStore
    }
}

С помощью Koin:

val dataStoreModule = module {
    single { providePreferencesDataStore(get()) }
    single { provideUserPreferencesDataStore(get()) }
}

private fun providePreferencesDataStore(context: Context): DataStore<Preferences> {
    return context.dataStore
}

4. Репозиторийный слой (Repository Pattern)

Создание репозитория для инкапсуляции логики работы с DataStore:

class UserPreferencesRepository(
    private val dataStore: DataStore<UserPreferences>
) {
    // Чтение данных
    val userPreferencesFlow: Flow<UserPreferences> = dataStore.data
    
    // Обновление отдельного поля
    suspend fun updateUsername(username: String) {
        dataStore.updateData { currentPreferences ->
            currentPreferences.toBuilder()
                .setUsername(username)
                .build()
        }
    }
    
    // Чтение конкретного значения
    suspend fun getUsername(): String {
        return dataStore.data.first().username
    }
    
    // Очистка данных
    suspend fun clearData() {
        dataStore.updateData { UserPreferences.getDefaultInstance() }
    }
}

5. Использование в ViewModel

Интеграция DataStore с архитектурными компонентами:

class SettingsViewModel(
    private val userPreferencesRepository: UserPreferencesRepository
) : ViewModel() {
    
    // LiveData для UI
    val userName: LiveData<String> = userPreferencesRepository.userPreferencesFlow
        .map { it.username }
        .asLiveData(viewModelScope.coroutineContext)
    
    // Обновление данных
    fun saveUserName(name: String) {
        viewModelScope.launch {
            userPreferencesRepository.updateUsername(name)
        }
    }
    
    // Комплексные операции
    suspend fun performUserLogin(username: String) {
        userPreferencesRepository.updateUsername(username)
        // Дополнительная логика...
    }
}

6. Миграция с SharedPreferences

Для плавного перехода с SharedPreferences:

val Context.dataStore: DataStore<Preferences> by preferencesDataStore(
    name = "settings",
    migrations = listOf(SharedPreferencesMigration(context, "old_prefs_name"))
)

7. Обработка ошибок

DataStore требует правильной обработки ошибок:

suspend fun readDataSafely(): Result<String> = try {
    val preferences = dataStore.data.first()
    val value = preferences[PreferencesKeys.USER_NAME] ?: "default"
    Result.success(value)
} catch (ioException: IOException) {
    Result.failure(ioException)
} catch (corruptionException: CorruptionException) {
    // Обработка поврежденных данных
    Result.failure(corruptionException)
}

Ключевые преимущества такого подхода:

• Асинхронный API на корутинах избегает блокировки UI-потока
• Потоковая природа позволяет легко интегрировать с LiveData/StateFlow
• Типобезопасность (особенно для Proto DataStore)
• Поддержка миграции из SharedPreferences
• Интеграция с DI-фреймворками для улучшенной тестируемости

Важное замечание: DataStore не поддерживает синхронный доступ к данным, что является сознательным решением для предотвращения блокировок UI-потока. Все операции должны выполняться в корутинах или возвращать Flow.