android-maps-compose: Memory leak

I have mentioned this in https://github.com/googlemaps/android-maps-compose/issues/26 , but it is already closed, so I am opening a new issue. 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 maps 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()
            }
        }
    }

The reason is that Lifecycle.Event.ON_DESTROY might not be called, and this way you would always dispose of the map view in onDispose, which will always be called. Would you be able to add this? I did fork and update it and the big memory leak disappeared.

`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`

About this issue

  • Original URL
  • State: closed
  • Created 2 years ago
  • Reactions: 7
  • Comments: 16 (16 by maintainers)

Commits related to this issue

Most upvoted comments

@arriolac I have added a sample here https://github.com/polivmi1/android-maps-compose It contains 2 screens using compose navigation. Steps to reproduce the problem:

  1. Open in profiler and memory
  2. open basic map
  3. click on marker
  4. click on BACK button
  5. repeat steps 3 and 4 multiple times seeing that memory is never cleaned
  6. minimize the app to free the leaked objects

I am also attaching screenshots of the step 5 and 6: Screenshot 2022-06-26 at 17 33 45 Screenshot 2022-06-26 at 17 34 19

Please let me know if you need more information. It should be clear from this, but you can also add the lifecycle logs and try with the fix I mentioned in the first comment.

Thanks for looking into it!

Ok I’ve confirmed that it is the intended behavior that the previous destination is not getting the DESTROYED event when navigating away from it. Your proposed workaround https://github.com/googlemaps/android-maps-compose/issues/138#issue-1263112472 should be put in place to resolve this @polivmi1. Would you like to make this contribution to the library?

I can confirm the memory leak and your proposed workaround does indeed fix the issue, however, I think the underlying lifecycle for the NavBackStackEntry should be receiving the ON_DESTROY event. Will raise this to the navigation compose team to see where the fix should be applied.

@arriolac this is a pretty standard project, where there is a map, marker and clicking the marker goes to other screen, clicking back button goes back. Using compose navigation. Unfortunately, I can’t share the big project where the leak is big, because it is private. I can add you these logs and create it in the sample to validate based on the lifecycle + you could add leakcanary and see the difference between this (will depend on the app data size, because it leaks it all) and the small google internal leak. I can create it if you need it, but first I wanted to sent you logs from such an app lifecycle, so you can see that in this case ON_DESTROY is never called and memory keeps leaking (the previous screen is on backstack until the back button is pressed and it is re-created):

(it would be called when we get back to the screen and everything would be cleared, but onDispose removes the listener when moving to screen B)

open screen A with map
2022-06-10 06:53:21.977 2289-2289/ D/AAA: ON_CREATE
2022-06-10 06:53:22.146 2289-2289/ D/AAA: ON_START
2022-06-10 06:53:22.146 2289-2289/ D/AAA: ON_RESUME
navigate to screen B
2022-06-10 06:53:48.368 2289-2289/ D/AAA: ON_PAUSE
2022-06-10 06:53:48.368 2289-2289/ D/AAA: ON_STOP
screen B create,start,resume
2022-06-10 06:53:49.245 2289-2289/ D/AAA: MapLifecycle: onDispose
press back to screen A (this will create a new mapview and if the old one wasn't disposed in onDispose, it leaks data)
2022-06-10 06:53:53.243 2289-2289/ D/AAA: ON_CREATE
2022-06-10 06:53:53.265 2289-2289/ D/AAA: ON_START
2022-06-10 06:53:54.004 2289-2289/ D/AAA: ON_RESUME