IssueTracker

Thank you for posting.

We'll need some more details to troubleshoot this issue - please provide the following, in particular steps to reproduce the issue:

1. Put together a simplified reproduction case (http://sscce.org/) and add it to a git hosting provider (e.g. github, bitbucket, etc)? The easiest way to do this might be to fork the Google Maps Android API Samples Repository and modify one of the existing demo activities: https://github.com/googlemaps/android-samples

2. List steps to reproduce the problem

• Maps SDK client library version (used to build your app):
• Maps renderer (Latest or Legacy):
• Devices you have verified this issue on:
  • Google Play Services version on the device:
  • Android version:
  • Manufacturer and model:
• Was this working correctly on a previous version of Google Play Services? (If yes, which client library and SDK version?)

4. Attach the following:

• screenshots
• sample code
• an APK if possible.

5. If the problem exhibits itself in a released version of your app on the Play Store, optionally link us to the app, and explain how to reproduce the issue in your app.

Thank you for the updates in this issue.

We have escalated this issue to our specialist for further evaluation. Rest assured that we'll get back for the updates.

Thank you for the report.

Based on the stack traces, we can confirm one scenario that reproduces the crash: an app calls GoogleMap#snapshot when it is in the background. Please check if your app also encounters the crash in this situation.

The Legacy renderer doesn't crash in this scenario. However, we notice that it does not produce a snapshot if the method is called while the app is in the background, and produces one as soon as the app comes to the foreground.

We are investigating the best way to resolve this issue in the Latest renderer. In the mean time, one possible workaround is to modify your app to detect if it is in the foreground before taking a snapshot, for example by calling ProcessLifecycleOwner.get().lifecycle.currentState.isAtLeast(Lifecycle.State.RESUMED).

#10: I think that is possible, although so far I find the snapshot process does not take that long.

We see an app that regularly (e.g. every X seconds) takes a snapshot. It crashes when it is put on the background. Is your app implementing something like this?

No, we captured the snapshot when the app is foreground only as per implementation. May be minimise the app results put on the background and crashed at the same time while or after captured the snapshot.

#13:

Also, the fragment with the map can be invisible during the snapshot call (being on another tab). Could that cause an issue?

Quickly looking at our code, I think that is possible. I'll try to reproduce that to confirm.

We greatly appreciate your patience.

We believe this issue is now fixed, hence marking it as such.

Thanks for working with us!

To clarify the status of this issue, we have submitted a fix to our codebase, and it will be released in a future version of Google Play services. We will update here once we have an estimate release date.

Hello everyone. We would like to provide an update on this.

To recap, this crash happens when GoogleMap#snapshot is called when a map is not visible. This could happen when an app is in the background, or if a fragment showing a map is in the background (that is, the fragment is not visible) while the host app or activity is in the foreground.

The Latest renderer does not support taking a snapshot while the map is not visible. This is to avoid non-deterministic behavior. The change we comitted to our codebase is to throw an IllegalStateException instead of NullPointerException to inform better what happens. This change is estimated to roll out via Google Play services at the beginning of April 2024.

We will update the SDK's documentation regarding this change.

To our developers: Please make sure your app only calls GoogleMap#snapshot when a map is visible, and handles IllegalStateException in case it occurs.

For comparison, the Legacy renderer doesn't immediately throw NullPointerException when a snapshot is taken while the map is not visible. However, we have seen crashes at other places in the SDK that are likely caused by this.

There was some delay in deploying the change. The deployment is currently in progress and we'll update here when it is complete.

#21: The change is deployed as an update in Google Play services, and not as a new client library version. See https://developers.google.com/android/guides/overview for more details on client library and Google Play services.

#22: do you have a sample app that reproduces the issue? (the crash happens even though you have added a try-catch block)

#24: Hmm, that try-catch block looks so simple, I don't know why it wouldn't catch the exception. If I understand correctly, you can reproduce the crash in your app consistently. So I would suggest you to debug your app around the snapshot call to see what goes wrong.

I can confirm that the try-catch function around the map.snapshot does not really help since it does not catch the IllegalStateException thrown. I can also note that the error is not a NPE anymore as written in the description of this issue but rather: java.lang.IllegalStateException: Can't take a snapshot while executing in the background. So the changes in the play services have been gone through I assume (?). I also need to mention that this error is not happening consistently -at least not in our app, but rather with a frequency of 1/50. I am attaching the relevant piece of code.

#26: Yes, the change to make the exception java.lang.IllegalStateException was fully rolled out via Google Play services in the beginning of May.

Trying to narrow down the problem: are there people here experiencing try/catch not catching the exception when not using Maps Compose library and MapEffect?

🐞When using googleMap.snapshot {} to capture a screenshot of the map, the app crashes if the map tiles are not fully loaded. This occurs especially on slow internet connections or when loading heavy maps.

📌 Steps to Reproduce

1. Open a Google Map in an Android app.
2. Ensure the map loads but the tiles are still being fetched (e.g., slow internet or high-resolution maps).
3. Call googleMap.snapshot {} before the tiles have finished rendering.
4. App crashes with the following exception:

🚨 Root Cause

• googleMap.snapshot {} requires the map tiles to be fully rendered before taking a snapshot.
• If tiles are still loading, the snapshot API crashes.
• Google Maps SDK does not provide a method to check if tiles have finished rendering before calling snapshot {}.

🔥 Workaround: Ensure Map Tiles Are Fully Loaded To avoid this crash, we must wait until the map is fully rendered before taking a snapshot.

✅ Fix: Use setOnMapLoadedCallback() This ensures that the snapshot is taken only after the map has finished loading.

fun takeSnapshot() { if (googleMap == null) { Log.e("MapSnapshot", "Cannot take snapshot, map is null.") return }

googleMap?.setOnMapLoadedCallback {
    googleMap?.snapshot { snap ->
        if (snap != null) {
            Log.d("MapSnapshot", "Snapshot taken successfully")
            // Process the snapshot
        } else {
            Log.e("MapSnapshot", "Failed to take snapshot")
        }
    }
}

}

🎯 Why This Fix Works ✅ Waits for all tiles to load before calling snapshot() ✅ Prevents crashes due to incomplete rendering ✅ Handles slow internet scenarios gracefully