Cancelled animation corrupts CameraPositionState and prevents drag gesture

[jeffphp]

android-maps-compose 4.3.0

When an animation occurs and is cancelled (and in other circumstances that I did not manage to reproduce), the CameraPositionState gets corrupted and a drag gesture on the map doesn't work anymore as intended. Here is a code to reproduce the bug (click several times on the button and try to move the map, zoom is not affected somehow).

Environment details

1. android-maps-compose 4.3.0
2. doesn't seem to occur on the simulator, please use a real device.

Steps to reproduce

1. Click several times on the button that animates the card, causing cancellation exceptions (caught and displayed)
2. Try to move the map, it doesn't move as intended (zoom is not affected somehow)

Code example

class RecompositionActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            val cameraPositionState = rememberCameraPositionState {
                position = defaultCameraPosition
            }
            Box(Modifier.fillMaxSize()) {
                MapsComposeSampleTheme {
                    GoogleMapView(
                        modifier = Modifier.matchParentSize(),
                        cameraPositionState = cameraPositionState
                    )
                }
            }
        }
    }


    @Composable
    fun GoogleMapView(
        modifier: Modifier = Modifier,
        cameraPositionState: CameraPositionState = rememberCameraPositionState(),
        content: @Composable () -> Unit = {},
    ) {
        var location by remember { mutableStateOf(singapore) }

        var zoom by remember { mutableStateOf(5f) }

        val context = LocalContext.current
        val singaporeState = MarkerState(position = location)


        val mapProperties = remember {
            MapProperties(
                isBuildingEnabled = false,
                isIndoorEnabled = false,
                isMyLocationEnabled = false,
                isTrafficEnabled = false,
                mapType = MapType.SATELLITE,
            )
        }

        val mapOptions = remember {
            GoogleMapOptions()
                .ambientEnabled(false)
                .mapToolbarEnabled(false)
                .compassEnabled(false)
        }

        val uiSettings = remember {
            MapUiSettings(
                compassEnabled = false,
                indoorLevelPickerEnabled = false,
                mapToolbarEnabled = false,
                myLocationButtonEnabled = false,
                rotationGesturesEnabled = false,
                scrollGesturesEnabledDuringRotateOrZoom = false,
                tiltGesturesEnabled = false,
                zoomControlsEnabled = false,
            )
        }


        val mapVisible by remember { mutableStateOf(true) }
        if (mapVisible) {

            LaunchedEffect(zoom) {
                try {
                    cameraPositionState.animate(
                        update = CameraUpdateFactory.newCameraPosition(
                            CameraPosition(
                                cameraPositionState.position.target,
                                zoom,
                                0f,
                                0f
                            ),

                            ), durationMs = 1000
                    )
                } catch(e: CancellationException) {
                    Toast.makeText(context, e.message, Toast.LENGTH_SHORT).show()
                } catch(e: Exception) {
                    Toast.makeText(context, e.message, Toast.LENGTH_SHORT).show()
                }
            }


            // Detect when the map starts moving and print the reason
            LaunchedEffect(cameraPositionState.isMoving) {
                if (cameraPositionState.isMoving) {
                    Log.d(TAG, "Map camera started moving due to ${cameraPositionState.cameraMoveStartedReason.name}")
                }
            }

            GoogleMap(
                modifier = modifier.fillMaxSize(),
                cameraPositionState = cameraPositionState,
                googleMapOptionsFactory = {mapOptions},
                onMapLoaded = {},
                properties = mapProperties,
                uiSettings = uiSettings,
                onPOIClick = {
                    Log.d(TAG, "POI clicked: ${it.name}")
                }
            ) {
                val markerClick: (Marker) -> Boolean = {
                    Log.d(TAG, "${it.title} was clicked")
                    cameraPositionState.projection?.let { projection ->
                        Log.d(TAG, "The current projection is: $projection")
                    }
                    false
                }

                Marker(
                    state = singaporeState,
                    title = "Marker in Singapore",
                    onClick = markerClick
                )

                content()
            }
            Column {

                Button(onClick = {
                    val randomValue = Random.nextInt(3)

                    location = when (randomValue) {
                        0 -> singapore
                        1 -> singapore2
                        2 -> singapore3
                        else -> singapore
                    }
                    zoom = when (randomValue) {
                        0 -> 3f
                        1 -> 6f
                        2 -> 15f
                        else -> 16f
                    }
                }) {
                    Text("Change Location & Zoom")
                }
            }
        }
    }
}

Thanks by advance!

[wangela]

If you would like to upvote the priority of this issue, please comment below or react on the original post above with 👍 so we can see what is popular when we triage.

@jeffphp Thank you for opening this issue. 🙏
Please check out these other resources that might help you get to a resolution in the meantime:

• Check the issue tracker - bugs and feature requests for Google Maps Platform APIs and SDKs
• Open a support case - Get 1:1 support in Cloud Console.
• Discord - chat with other developers
• StackOverflow - use the google-maps tag

This is an automated message, feel free to ignore.

[jeffphp]

A workaround fixing some problems consists in catching CancellationException and throw it again when it happens, then there won't be a discrepancy between cameraPositionState and drag gesture listener :

LaunchedEffect(****) {
        try {
            cameraPositionState.animate(
                update = CameraUpdateFactory.newCameraPosition(
                    CameraPosition(viewModel.mapPosition, viewModel.mapZoom, 0f, 0f)
                ),
                durationMs = 100
            )
        } catch(e: CancellationException) {
            throw e      
        } catch (e: Exception) {
            // ***        
        }
    }
}

[kikoso]

Hi @jeffphp ,

This does not seem to happen on my device, but did you try to call the animate function within a Coroutine scope?

coroutineScope.launch {
                        cameraPositionState.animate(CameraUpdateFactory.zoomOut())
                    }

From the documentation of LaunchEffect:

This function should not be used to (re-)launch ongoing tasks in response to callback events by way of storing callback data in MutableState passed to key. Instead, see rememberCoroutineScope to obtain a CoroutineScope that may be used to launch ongoing jobs scoped to the composition in response to event callbacks.