标签: android-jetpack-datastore

是否可以只从 a 读取/写入原始类型DataStore？例如，我只想阅读一个Int. 我不想让任何东西Flow包裹在它周围。只是简单Int。

我正在检查数据存储和共享首选项的执行时间，我发现数据存储比共享首选项花费更多时间。

这是我的代码

suspend fun saveUser(user: User, context: Context) {
            val userString =
                Json.encodeToString(User.serializer(), user)
            val time1 = System.nanoTime()
            context.dataStore.edit { preferences ->
                preferences[PreferencesKeys.USER] = userString
            }
            val time2 = System.nanoTime()
            with(userPref.edit()) {
                putString(HOME_USER_KEY, userString)
                apply()
            }
            val time3 = System.nanoTime()
            println("Time taken")
            println("Datastore : ${time2 - time1}")
            println("Shared Preferences : ${time3 - time2}")
        }

和输出

I/System.out: Time taken
I/System.out: Datastore : 208257769
I/System.out: Shared Preferences : 14458539

I/System.out: Time taken
I/System.out: Datastore : 2892692
I/System.out: Shared Preferences : 246462

I/System.out: …

在 jetpack 数据存储中，您必须设置 gradle 插件任务以从.proto文件中生成类：

// build.gradle
protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc:3.10.0"
    }

    // Generates the java Protobuf-lite code for the Protobufs in this project. See
    // https://github.com/google/protobuf-gradle-plugin#customizing-protobuf-compilation
    // for more information.
    generateProtoTasks {
        all().each { task ->
            task.builtins {
                java {
                    option 'lite'
                }
            }
        }
    }
}

在我的项目中，我将Kotlin dsl用于我的 gradle 项目。尝试将其转换为 kotlin dsl 后，option属性未知，我找不到它的替代品 kotlin kts

// build.gradle
protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc:3.10.0"
    }

    // Generates …

我一直在使用喷气背包数据存储一段时间，但后来我遇到了问题。我想在应用程序被销毁时清除数据存储中的数据。我使用喷气背包数据存储仅以表格形式保存数据

我搜索过 sharedPreferences 有一个 clear() 函数，Jetpack Datastore 是否有类似的函数？我该如何使用它？

我在数据存储文档中找到了明确的功能， 但没有说明如何使用它

我试图提供一个通用的，DataStore<Preferences>以便可以在多个地方使用相同的首选项文件，但我收到了有用的错误消息：

找不到符号：DaggerMyApplication_HiltComponents_SingletonC.builder()

@Module
@InstallIn(ApplicationComponent::class)
object DataStoreModule {
    
    @Provides
    fun provideDataStore(@ApplicationContext context: Context): DataStore<Preferences> = context.createDataStore("settings")
}

但是，我可以执行以下操作并在@Inject构造函数中使用它。

@Singleton
class DataStoreProvider @Inject constructor(@ApplicationContext context: Context) {

    val dataStore: DataStore<Preferences> = context.createDataStore("settings")
}

我认为扩展程序createDataStore正在做一些 Hilt 不喜欢的事情，但即使问题无法解决，我也希望能解释一下正在发生的事情。

我尝试让用户选择是否使用 UI 模式“浅色”、“深色”或“系统”设置。我想将选择保存为数据存储。

用户选择的下拉菜单未从数据存储加载值。加载屏幕时，它始终显示 stateIn() 的初始值。

设置管理器：

val Context.dataStoreUiSettings: DataStore<Preferences> by preferencesDataStore(name = DATA_STORE_UI_NAME)

object PreferencesKeys {
    val UI_MODE: Preferences.Key<Int> = intPreferencesKey("ui_mode")
}

class SettingsManager @Inject constructor(private val context: Context) { //private val dataStore: DataStore<Preferences>
    private val TAG: String = "UserPreferencesRepo"

    // Configuration.UI_MODE_NIGHT_UNDEFINED, Configuration.UI_MODE_NIGHT_YES, Configuration.UI_MODE_NIGHT_NO
    suspend fun setUiMode(uiMode: Int) {
        context.dataStoreUiSettings.edit { preferences ->
            preferences[UI_MODE] = uiMode
        }
    }
    fun getUiMode(key: Preferences.Key<Int>, default: Int): Flow<Int> {
        return context.dataStoreUiSettings.data
            .catch { exception ->
                if (exception is IOException) {
                    Timber.i("Error reading preferences: …

我读过有关 Jetpack 的新库（现在处于 alpha 版本） - Jetpack Datastore。

从文档中可以清楚地看出，这是一种Shared Preferences' killer

Jetpack DataStore 是一种数据存储解决方案，允许您使用协议缓冲区存储键值对或类型化对象

DataStore 使用 Kotlin 协程和 Flow 以异步、一致和事务方式存储数据

如果您当前使用 SharedPreferences 来存储数据，请考虑迁移到 DataStore

如果我没有遗漏任何内容，您将无法在 Java 中使用这个库。我对吗？我个人使用 Kotlin，但对我来说，这是 AndroidX 库的一个特殊先例。

我尝试使用数据存储首选项 alpha07 存储和获取数据，一切正常，我在数据存储中遇到了一些内存泄漏问题

使用 Datastore 防止内存泄漏的最佳做法是什么？

这是我的示例代码：

// Preferences DataStore
    implementation "androidx.datastore:datastore-preferences:1.0.0-alpha07"
// Leakcanary find memory leak
    debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.6'

用户管理器.kt

import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.*
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map

class UserManager(val dataStore: DataStore<Preferences>) {

    //Create some keys
    companion object {
        val USER_AGE_KEY = intPreferencesKey("USER_AGE")
        val USER_FIRST_NAME_KEY = stringPreferencesKey("USER_FIRST_NAME")
        val USER_LAST_NAME_KEY = stringPreferencesKey("USER_LAST_NAME")
        val USER_GENDER_KEY = booleanPreferencesKey("USER_GENDER")
    }

    //Store user data
    suspend fun storeUser(age: Int, fname: String, lname: String, isMale: Boolean) {
        dataStore.edit {
            it[USER_AGE_KEY] = age
            it[USER_FIRST_NAME_KEY] = fname
            it[USER_LAST_NAME_KEY] = …

我试图让自己熟悉DataStore，所以在我当前的项目中，我尝试使用它。

在我的依赖中。我已经添加 ：

    implementation "androidx.datastore:datastore-preferences:1.0.0-alpha06"

然后我创建了这个类来处理数据存储：

class BasicDataStore(context: Context) :
    PrefsDataStore(
        context,
        PREF_FILE_BASIC
    ),
    BasicImpl {
    override val serviceRunning: Flow<Boolean>
        get() = dataStore.data.map { preferences ->
            preferences[SERVICE_RUNNING_KEY] ?: false
        }
    override suspend fun setServiceRunningToStore(serviceRunning: Boolean) {
        dataStore.edit { preferences ->
            preferences[SERVICE_RUNNING_KEY] = serviceRunning
        }
    }
    companion object {
        private const val PREF_FILE_BASIC = "basic_preference"
        private val SERVICE_RUNNING_KEY = booleanPreferencesKey("service_running")
    }
}
@Singleton
interface BasicImpl {
    val serviceRunning: Flow<Boolean>
    suspend fun setServiceRunningToStore(serviceRunning: Boolean)
}

在我的视图模型中，我尝试使用该值，如下所示：

class MainViewModel(application: Application) : …

staticCompositionLocalOf我正在尝试根据Medium 上的这篇文章在 Jetpack Compose 中使用。这是我的 ProvidableCompositionLocal

val lightColors = lightColors(
    primary = LightColor.BackgroundWhite,
    primaryVariant = LightColor.ToolbarWhite,
    secondary = LightColor.FabBlue,
    secondaryVariant = LightColor.BackgroundWhite,
    surface = LightColor.SurfaceWhite,
    onPrimary = LightColor.TextBlack,
    onSecondary = LightColor.TextBlack,
    onSurface = LightColor.TextBlack
)

val darkColors = darkColors(
    primary = DarkColor.BackgroundBlue,
    primaryVariant = DarkColor.ToolbarBlue,
    secondary = DarkColor.FabGrey,
    secondaryVariant = DarkColor.BackgroundBlue,
    surface = DarkColor.SurfaceBlue,
    onPrimary = Color.White,
    onSecondary = Color.White,
    onSurface = Color.White
)

private val DarkColorPalette =
    Colors(
        material = darkColors,
        toolbar = DarkColor.ToolbarBlue,
        background = …