I'm trying to get a display scaling feature to work with JetPack Compose. I have a ViewModel that exposes a shared preferences value as a flow, but it's definitely incorrect, as you can see below:

@HiltViewModel
class MyViewModel @Inject constructor(
    @ApplicationContext private val context: Context
) : ViewModel() {
    private val _densityFactor: MutableStateFlow<Float> = MutableStateFlow(1.0f)
    val densityFactor: StateFlow<Float>
        get() = _densityFactor.asStateFlow()

    private fun getDensityFactorFromSharedPrefs(): Float {
        val sharedPreference = context.getSharedPreferences(
            "MY_PREFS",
            Context.MODE_PRIVATE
        )
        return sharedPreference.getFloat("density", 1.0f)
    }

    // This is what I look at and go, "this is really bad."
    private fun densityFactorFlow(): Flow<Float> = flow {
        while (true) {
            emit(getDensityFactorFromSharedPrefs())
        }
    }

    init {
        viewModelScope.launch(Dispatchers.IO) {
            densityFactorFlow().collectLatest {
                _densityFactor.emit(it)
            }
        }
    }
}

Here's my Composable:

@Composable
fun MyPageRoot(
    modifier: Modifier = Modifier,
    viewModel: MyViewModel = hiltViewModel()
) {
    val densityFactor by viewModel.densityFactor.collectAsState(initial = 1.0f)

    CompositionLocalProvider(
        LocalDensity provides Density(
            density = LocalDensity.current.density * densityFactor
        )
    ) {
        // Content
    }
}

And here's a slider that I want to slide with my finger to set the display scaling (the slider is outside the content from the MyPageRoot and will not change size on screen while the user is using the slider).

@Composable
fun ScreenDensitySetting(
    modifier: Modifier = Modifier,
    viewModel: SliderViewModel = hiltViewModel()
) {
    var sliderValue by remember { mutableStateOf(viewModel.getDensityFactorFromSharedPrefs()) }

    Text(
        text = "Zoom"
    )
    Slider(
        value = sliderValue,
        onValueChange = { sliderValue = it },
        onValueChangeFinished = { viewModel.setDisplayDensity(sliderValue) },
        enabled = true,
        valueRange = 0.5f..2.0f,
        steps = 5,
        colors = SliderDefaults.colors(
            thumbColor = MaterialTheme.colors.secondary,
            activeTrackColor = MaterialTheme.colors.secondary
        )
    )
}

The slider composable has its own viewmodel

@HiltViewModel
class PersonalizationMenuViewModel @Inject constructor(
    @ApplicationContext private val context: Context
) : ViewModel() {
    fun getDensityFactorFromSharedPrefs(): Float {
        val sharedPreference = context.getSharedPreferences(
            "MY_PREFS",
            Context.MODE_PRIVATE
        )
        return sharedPreference.getFloat("density", 1.0f)
    }

    fun setDisplayDensity(density: Float) {
        viewModelScope.launch {
            val sharedPreference = context.getSharedPreferences(
                "MEAL_ASSEMBLY_PREFS",
                Context.MODE_PRIVATE
            )
            val editor = sharedPreference.edit()
            editor.putFloat("density", density)
            editor.apply()
        }
    }
}

I know that I need to move all the shared prefs code into a single class. But how would I write the flow such that it pulled from shared prefs when the value changed? I feel like I need a listener of some sort, but very new to Android development.

CodePudding user response：

Your comment is right, that's really bad. :) You should create a OnSharedPreferenceChangeListener so it reacts to changes instead of locking up the CPU to constantly check it preemptively.

There's callbackFlow for converting listeners into Flows. You can use it like this:

fun SharedPreferences.getFloatFlowForKey(keyForFloat: String) = callbackFlow<Float> {
    val listener = SharedPreferences.OnSharedPreferenceChangeListener { _, key ->
        if (keyForFloat == key) {
            trySend(getFloat(key, 0f))
        }
    }
    registerOnSharedPreferenceChangeListener(listener)
    if (contains(key)) {
        send(getFloat(key, 0f)) // if you want to emit an initial pre-existing value
    }
    awaitClose { unregisterOnSharedPreferenceChangeListener(listener) }
}.buffer(Channel.UNLIMITED) // so trySend never fails

Then your ViewModel becomes:

@HiltViewModel
class MyViewModel @Inject constructor(
    @ApplicationContext private val context: Context
) : ViewModel() {

    private val sharedPreference = context.getSharedPreferences(
        "MY_PREFS",
        Context.MODE_PRIVATE
    )

    val densityFactor: StateFlow<Float> = sharedPreferences
        .getFloatFlowForKey("density")
        .stateIn(viewModelScope, SharingStarted.Eagerly, 1.0f)
}