Possible memory leak when GoogleMap component is disposed but Activity is not destroyed

It seems like there could be a possible memory leak when the GoogleMap is disposed without the activity being destroyed. When it is disposed, the lifecycle observer is removed and onDestroy seems to not be called on the map. Does that seem accurate or is onDestroy being called somewhere else as well?

Steps to reproduce:

1. Modify the onCreate method in MapSampleActivity to conditionally add the map to the composition a. See sample code below
2. launch the sample application
3. optionally place a breakpoint in the onDispose block of MapLifecycle in GoogleMap.kt
4. optionally place a breakpoint at the start of the when inside the lifecycleObserver extension function in GoogleMap.kt
5. optionally Attach the debugger
6. press the “Hide map” button at the bottom of the screen
7. Notice that onDispose is called but onDestroy was not called for the MapView since the activity is still alive
8. Backing out of the app at this point destroys the activity but does not result in any calls to onDestroy for the MapView as far as I can tell

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            var isMapLoaded by remember { mutableStateOf(false) }

            var shouldShowMap by remember { mutableStateOf(true) }

            Box(Modifier.fillMaxSize()) {
                if (shouldShowMap) {
                    GoogleMapView(
                        modifier = Modifier.matchParentSize(),
                        onMapLoaded = {
                            isMapLoaded = true
                        }
                    )
                }
                if (!isMapLoaded) {
                    AnimatedVisibility(
                        modifier = Modifier
                            .matchParentSize(),
                        visible = !isMapLoaded,
                        enter = EnterTransition.None,
                        exit = fadeOut()
                    ) {
                        CircularProgressIndicator(
                            modifier = Modifier
                                .background(MaterialTheme.colors.background)
                                .wrapContentSize()
                        )
                    }
                }
                Button(
                    onClick = { shouldShowMap = false },
                    modifier = Modifier.align(Alignment.BottomCenter)
                        .padding(bottom = 16.dp)
                ) {
                    Text(text = "Hide map")
                }
            }
        }
    }

[mcasper3]

I have confirmed that is the case for the sample app. I am seeing a memory leak in my app but I will need to do more digging to see what the cause of that is. My current theory is that it has something to do without housing the map component inside an AbstractComposeView, but I’ll know more when I have a chance to dig into it more

[polivmi1]

@arriolac I am getting a leak if the map component is cleared and then the activity is destroyed.

Previously when implementing it through AndroidView, to get rid of the ma[ps leak, I had to use:

DisposableEffect(lifecycle) {
        lifecycle.addObserver(lifecycleObserver)
        onDispose {
            lifecycle.removeObserver(lifecycleObserver)
            mapView.onDestroy()
            mapView.removeAllViews()
        }
    }

And

remember(mapView) {
        LifecycleEventObserver { _, event ->
            when (event) {
                Lifecycle.Event.ON_CREATE -> mapView.onCreate(Bundle())
                Lifecycle.Event.ON_START -> mapView.onStart()
                Lifecycle.Event.ON_RESUME -> mapView.onResume()
                Lifecycle.Event.ON_PAUSE -> mapView.onPause()
                Lifecycle.Event.ON_STOP -> mapView.onStop()
                Lifecycle.Event.ON_DESTROY -> {
                    //handled in onDispose
                }
                else -> throw IllegalStateException()
            }
        }
    }

OnDestroy might not be called and this way you would always dispose of the view in onDispose, which will always be called. Would you be able to add this?

`1 APPLICATION LEAKS

References underlined with "~~~" are likely causes.
Learn more at https://squ.re/leaks.

56446 bytes retained by leaking objects
Signature: 34a030bd011ab1ccd655bbeac3fbc8465c53ce5f
┬───
│ GC Root: Thread object
│
├─ com.google.maps.api.android.lib6.gmm6.vector.n instance
│    Leaking: UNKNOWN
│    Retaining 3.5 MB in 26933 objects
│    Thread name: 'RenderDrive'
│    ↓ n.e
│        ~
├─ com.google.maps.api.android.lib6.gmm6.vector.p instance
│    Leaking: UNKNOWN
│    Retaining 3.5 MB in 26930 objects
│    ↓ p.f
│        ~
├─ com.google.maps.api.android.lib6.gmm6.api.ac instance
│    Leaking: UNKNOWN
│    Retaining 3.5 MB in 26929 objects
│    View not part of a window view hierarchy
│    View.mAttachInfo is null (view detached)
│    View.mWindowAttachCount = 1
│    mContext instance of ExampleApplication
│    ↓ ac.N
│         ~
├─ com.google.maps.api.android.lib6.impl.ax instance
│    Leaking: UNKNOWN
│    Retaining 20 B in 1 objects
│    a instance of ExampleApplication
│    b instance of ExampleActivity with mDestroyed = true
│    ↓ ax.b
│         ~
╰→ ExampleActivity instance`