Any changes made in onHidden, doesn't re-trigger recomposition.

[ankitfromcodefy]

How to reproduce

Scenerio

• A graph should have persistent maker at a default position
• When the user drags the finger, the persistent marker should hide and the normal marker should be visible
• When the user release the finger, the persistent marker should be displayed again at the default position.

    val marker = rememberMarker2()
    var persistedMarker = rememberMarker2()

    var persistentMarkerIndex by remember {
        mutableIntStateOf(5)
    }

    var showPersistentMarker by remember {
        mutableStateOf(true)
    }

    CartesianChartHost(
        chart = rememberCartesianChart(
            rememberLineCartesianLayer(
                LineCartesianLayer.LineProvider.series(
                    chartColors.mapIndexed { index, color ->
                        LineCartesianLayer.rememberLine(
                            fill = remember {
                                LineCartesianLayer.LineFill.single(fill(color))
                            },
                            areaFill = remember(color) {
                                LineCartesianLayer.AreaFill.single(
                                    fill = fill(areaColors[index])
                                )
                            },
                            cap = StrokeCap.Round
                        )
                    }
                )
            ),
            marker = marker,
            markerVisibilityListener = object : CartesianMarkerVisibilityListener {

                override fun onHidden(marker: CartesianMarker) {
                    showPersistentMarker = true
                }

                override fun onShown(
                    marker: CartesianMarker,
                    targets: List<CartesianMarker.Target>
                ) {
                    showPersistentMarker = false
                }
            },
            persistentMarkers = remember(showPersistentMarker) {
                if (showPersistentMarker) {
                    { persistedMarker at persistentMarkerIndex }
                } else {
                    null
                }
            }
        ),
        modelProducer = modelProducer,
        modifier = modifier.padding(4.dp)
    )

Observed behavior

As soon as user release figure CartesianMarkerVisibilityListener callback onHidden is called which change the state. However, the graph doesn't recompose itself and the persistentMarkers doesn't reset.

i.e After the last state change, the view should recompose itself

Expected behavior

The state change in onShown method works as expected, however state change in onHidden doesn't trigger recomposition.

Solutions tries so far

1. I have even tried rememberExtraLambda(showPersistentMarker) instead of remember(showPersistentMarker). Same result
2. Instead of using a Boolean state, I tried to update the persistentMarkerIndex as well. Same result and behaviour.

Vico version(s)

3.0.0-alpha.28

Android version(s)

13

Additional information

No response

[ankitfromcodefy]

This explain this issue even better. Notice persistentMarkerIndex = 5 is never reflected

@Composable
fun LineGraphChart(modelProducer: CartesianChartModelProducer, modifier: Modifier) {

    val marker = rememberMarker2()
    var persistedMarker = rememberMarker2()

    var persistentMarkerIndex by remember {
        mutableIntStateOf(5)
    }
    
    // Create a remembered instance of the listener
    val markerVisibilityListener = remember {
        object : CartesianMarkerVisibilityListener {

            override fun onHidden(marker: CartesianMarker) {
                persistentMarkerIndex = 5
                super.onHidden(marker)
            }

            override fun onUpdated(marker: CartesianMarker, targets: List<CartesianMarker.Target>) {
                super.onUpdated(marker, targets)
                val x = targets.first().x.toInt()
                persistentMarkerIndex = x
            }

            override fun onShown(
                marker: CartesianMarker,
                targets: List<CartesianMarker.Target>
            ) {
                persistentMarkerIndex = -1
            }
        }
    }

    // Use `remember` for the `persistentMarkers` to recompute based on `persistentMarkerIndex`
    CartesianChartHost(
        chart = rememberCartesianChart(
            rememberLineCartesianLayer(
                LineCartesianLayer.LineProvider.series(
                    chartColors.mapIndexed { index, color ->
                        LineCartesianLayer.rememberLine(
                            fill = remember {
                                LineCartesianLayer.LineFill.single(fill(color))
                            },
                            areaFill = remember(color) {
                                LineCartesianLayer.AreaFill.single(
                                    fill = fill(areaColors[index])
                                )
                            },
                            cap = StrokeCap.Round
                        )
                    }
                )
            ),
            marker = marker,
            markerVisibilityListener = markerVisibilityListener,
            persistentMarkers = remember(persistentMarkerIndex) {
                { persistedMarker at persistentMarkerIndex }
            }
        ),
        modelProducer = modelProducer,
        modifier = modifier.padding(4.dp)
    )
    
}

[Gowsky]

Hello, @ankitfromcodefy. This isn't specific to markers — it generally relates to calling rememberCartesianChart and similar with changed arguments.

The CartesianChart instance is mutated, but it's the same instance, so there's no reason to expect a recomposition. Neither is there a way for us to make a recomposition occur. This is how Jetpack Compose works.

persistentMarkers is an ExtraStore lambda, and you can use extras to dynamically add or remove persistent markers. This ensures that the chart is redrawn to reflect the changes. Replacing the lambda to add or remove persistent markers (as in your code) is incorrect.

However, it's not entirely possible to achieve your desired behavior via extras. This means that the library doesn't support implementing such behavior at the moment. We will consider adding an API that makes this possible — I'm converting the issue to a discussion in "Ideas."

[ankitfromcodefy]

This is definitely a bug!! This exact behaviour is possible in 2.0.0-alpha.28. This behaviour is also possible in 1.15.0 . It is only in 2.0.0-beta1 this functionality stopped working.

[Gowsky]

What exactly makes you think that it is a bug? As I mentioned above, there is no reason to expect a recomposition and we have no control over the internal workings of Jetpack Compose. If it was possible previously, it could have been a side effect. This doesn’t mean that the occurrence of a recomposition should’ve been relied on or that such replacement was correct.

[Gowsky]

Hello again, @ankitfromcodefy. It turned out to be caused by the strong skipping mode enabled by default in Kotlin 2.0.20, and Vico 2.0.0-beta.2 fixes this.