fix: avoid zero-size crash in rememberComposeBitmapDescriptor when used inside Clustering (#963)

* fix: avoid zero-size crash in rememberComposeBitmapDescriptor when used inside Clustering

rememberComposeBitmapDescriptor hosted its throwaway rendering
ComposeView on LocalView.current, which can itself be mid-attach with
no Android layout pass performed on it yet -- notably when this is
called from content composed inside Clustering's clusterItemContent,
whose InvalidatingComposeView is still being attached to its own
parent at that point. That caused measure() to return a 0x0 size and
throw IllegalStateException.

Host the throwaway view on the window's root view instead, which is
already laid out by the time any marker/cluster content is composed.
setParentCompositionContext keeps the composition correctly scoped to
the caller regardless of which Android View it's physically parented
under, so this is safe.

Fixes #694

* refactor(maps-compose): improve Canvas lifecycle and view cleanup in rememberComposeBitmapDescriptor

- Replace the file-level static fakeCanvas singleton with a locally scoped canvasOfHolding to prevent global memory retention and eliminate any risk of cross-call Canvas state/matrix contamination.
- Wrap the measurement, layout, and bitmap drawing phases in a try/finally block to guarantee that the throwaway ComposeView is always detached from the root view hierarchy even if measurement throws an IllegalStateException or rendering fails.
- Rename the Canvas instance to reflect its production role as an unbacked draw target rather than a test double.

---------

Co-authored-by: Dale Hawkins <107309+dkhawk@users.noreply.github.com>

Author: kikoso

maps-app/src/androidTest/java/com/google/maps/android/compose/GoogleMapViewClusteringTests.kt

@@ -167,4 +167,39 @@ class GoogleMapViewClusteringTests {
             assertThat(marker.rotation).isEqualTo(180f)
         }
     }
+
+    @OptIn(MapsComposeExperimentalApi::class)
+    @Test
+    fun testClusterItemContentUsingRememberComposeBitmapDescriptorDoesNotCrash() {
+        val clusterManagerHolder = arrayOfNulls<ClusterManager<MyItem>>(1)
+        val items = listOf(MyItem(startingPosition, "Item", "Snippet", 0f))
+
+        // Regression test for https://github.com/googlemaps/android-maps-compose/issues/694:
+        // rememberComposeBitmapDescriptor used to throw "measured to have a width or height of
+        // zero" when called from content composed inside Clustering's clusterItemContent,
+        // because its parent (InvalidatingComposeView) hadn't been through an Android layout
+        // pass yet at that point.
+        val marker = initMapAndGetMarker(clusterManagerHolder) {
+            Clustering(
+                items = items,
+                clusterItemContent = {
+                    rememberComposeBitmapDescriptor {
+                        Surface(modifier = Modifier.size(20.dp)) {
+                            Text("X")
+                        }
+                    }
+                    Surface(modifier = Modifier.size(20.dp)) {
+                        Text("X")
+                    }
+                },
+                onClusterManager = { cm ->
+                    clusterManagerHolder[0] = cm
+                }
+            )
+        }
+
+        composeTestRule.runOnUiThread {
+            assertThat(marker.isVisible).isTrue()
+        }
+    }
 }

maps-compose/src/main/java/com/google/maps/android/compose/RememberComposeBitmapDescriptor.kt

@@ -16,6 +16,7 @@
 
 package com.google.maps.android.compose
 
+import android.graphics.Canvas
 import android.view.View
 import android.view.ViewGroup
 import androidx.compose.runtime.Composable
@@ -53,8 +54,18 @@ private fun renderComposableToBitmapDescriptor(
     compositionContext: CompositionContext,
     content: @Composable () -> Unit,
 ): BitmapDescriptor {
+    // Host the throwaway rendering ComposeView on the window's root view rather than on `parent`
+    // directly. `parent` (LocalView.current) can itself be mid-attach with no Android layout pass
+    // performed on it yet -- e.g. when this is called from content composed inside a Clustering
+    // item, which is first composed while its own hosting view is still being attached to its
+    // parent. `setParentCompositionContext` keeps this composition correctly scoped to the
+    // surrounding composition regardless of which Android View it's physically parented under, so
+    // it's safe to use a different, already-laid-out ViewGroup as the Android host.
+    val host = parent.rootView as? ViewGroup ?: parent
+    val canvasOfHolding = Canvas()
+
     val composeView =
-        ComposeView(parent.context)
+        ComposeView(host.context)
             .apply {
                 layoutParams = ViewGroup.LayoutParams(
                     ViewGroup.LayoutParams.WRAP_CONTENT,
@@ -63,23 +74,31 @@ private fun renderComposableToBitmapDescriptor(
                 setParentCompositionContext(compositionContext)
                 setContent(content)
             }
-            .also(parent::addView)
+            .also(host::addView)
 
-    composeView.measure(measureSpec, measureSpec)
+    try {
+        // AndroidComposeView triggers LayoutNode's layout phase in the View draw phase, so trigger a
+        // draw to an empty canvas to force that.
+        composeView.draw(canvasOfHolding)
 
-    if (composeView.measuredWidth == 0 || composeView.measuredHeight == 0) {
-        throw IllegalStateException("The ComposeView was measured to have a width or height of " +
-                "zero. Make sure that the content has a non-zero size.")
-    }
+        composeView.measure(measureSpec, measureSpec)
 
-    composeView.layout(0, 0, composeView.measuredWidth, composeView.measuredHeight)
+        if (composeView.measuredWidth == 0 || composeView.measuredHeight == 0) {
+            throw IllegalStateException(
+                "The ComposeView was measured to have a width or height of zero. " +
+                    "Make sure that the content has a non-zero size."
+            )
+        }
 
-    val bitmap =
-        createBitmap(composeView.measuredWidth, composeView.measuredHeight)
+        composeView.layout(0, 0, composeView.measuredWidth, composeView.measuredHeight)
 
-    bitmap.applyCanvas { composeView.draw(this) }
+        val bitmap =
+            createBitmap(composeView.measuredWidth, composeView.measuredHeight)
 
-    parent.removeView(composeView)
+        bitmap.applyCanvas { composeView.draw(this) }
 
-    return BitmapDescriptorFactory.fromBitmap(bitmap)
+        return BitmapDescriptorFactory.fromBitmap(bitmap)
+    } finally {
+        host.removeView(composeView)
+    }
 }