Android Preferences DataStore Flow Doesn't Emit Same Value

user_3466808 0
Viewed 787

Just testing Preferences DataStore and found out that the provided Flow output won't emit same value, my setup as followed:

DataStore Util Class:

object DataStore {
    private val Context.settings by preferencesDataStore("settings") 

    suspend fun saveBoolean(context: Context, keyResId: Int, value: Boolean) {
        val key = booleanPreferencesKey(context.getString(keyResId))

        context.settings.edit {
            it[key] = value
        }
    }

    fun getBooleanFlow(context: Context, keyResId: Int, defaultValueResId: Int): Flow<Boolean> {
        val key = booleanPreferencesKey(context.getString(keyResId))
        val defaultValue = context.resources.getBoolean(defaultValueResId)

        return context.settings.data.map {
            it[key] ?: defaultValue
        }
    }
}

ViewModel Class:

class FirstViewModel(application: Application) : AndroidViewModel(application) {
    private val uiScope = viewModelScope

    val isUpdateAvailable = DataStore.getBooleanFlow(
        getApplication(), R.string.is_update_available_key, R.bool.is_update_available_default
    )

    fun updateIsUpdateAvailable() = uiScope.launch {
        DataStore.saveBoolean(getApplication(), R.string.is_update_available_key, true)  //<- always set to true
    }
}

Fragment Class:

class FirstFragment : Fragment() {
    private lateinit var binding: FragmentFirstBinding
    private lateinit var viewModel: FirstViewModel

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
        binding = DataBindingUtil.inflate(inflater, R.layout.fragment_first, container, false)
        viewModel = ViewModelProvider(this).get(FirstViewModel::class.java)

        lifecycleScope.launch {
            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
                viewModel.isUpdateAvailable.collect {
                    Log.v("xxx", "isUpdateAvailable: $it")
                }
            }
        }

        binding.saveButton.setOnClickListener {
            viewModel.updateIsUpdateAvailable()
        }

        return binding.root
    }
}

Since I'm saving true each time, and the Log just shows once, which means the Flow doesn't emit same value. Am I correct? Is this intentional behavior?

android-jetpack-datastore kotlin-flow android-preferences sharedpreferences android
2 Answers

Right, context.settings.data flow doesn't emit the same value. I haven't found any docs confirming that, but digging into the sources of DataStore library shows that if the current value is equal to the new value, then emitting doesn't happen. The source code of a function that updates the value:

private val downstreamFlow = MutableStateFlow(...)


private suspend fun transformAndWrite(
    transform: suspend (t: T) -> T,
    callerContext: CoroutineContext
): T {
    
    val curDataAndHash = downstreamFlow.value as Data<T>
    curDataAndHash.checkHashCode()

    val curData = curDataAndHash.value
    val newData = withContext(callerContext) { transform(curData) }

    curDataAndHash.checkHashCode()

    // here comparison is happening
    return if (curData == newData) {
        curData
    } else {
        // if curData and newData are not equal save and emit newData
        writeData(newData)
        downstreamFlow.value = Data(newData, newData.hashCode())
        newData
    }
}
user_17316260

I made a workaround for this.

  1. You store the previous value of the properties in a variable
private val dataStore = context.dataStore  
private var previousConfig: AppConfig = AppConfig.default() //Any default/emptyvalue

     val preferencesFlow = dataStore.data
        .catch { exception ->
            Log.e(TAG, "Error reading preferences", exception)
            emit(emptyPreferences())
        }
        .map { preferences ->
            val result = preferences[CONFIG]?.let {
                moshiAdapter.fromJson(it) ?: AppConfig.default()
            } ?: AppConfig.default()
            previousConfig = result //here you update your previous value
            return@map result
        }
  1. Each time you want to update data, you first compare the new value with the previous one.
  2. And if data is the same, before pushing your actual new data, you push some fake data which is guaranteed not same as the new data. This can be also achieved by introducing some extra variable in your configuration data class. This variable will serve exlusively to make equal() return false when comparing data class instances. Then you can push your new data (see code below).
suspend fun updateConfig(appConfig: AppConfig) {
        if (appConfig == previousConfig) {
            dataStore
                .edit { preferences -> // pushing fake data
                    preferences[PreferencesKeys.CONFIG] = moshiAdapter
.toJson(appConfig.copy(equalityIndicator++))
                }
        }
        dataStore
            .edit { preferences -> //now pushing the real valid new data
                preferences[PreferencesKeys.CONFIG] = moshiAdapter.toJson(appConfig)
            }
    }

It's an ugly workaround but it works. I hope Google will offer us some better way sometime.

user_117648860
Related