fix: Address IllegalStateException on main thread during map initialization

Fixes a crash where `IllegalStateException: Method addObserver must be called on the main thread`
was thrown during Google Maps initialization on certain Android devices after
upgrading the library. This addresses the issue reported in #789.

Author: dkhawk

maps-app/src/main/AndroidManifest.xml

@@ -20,6 +20,7 @@
   <uses-permission android:name="android.permission.INTERNET" />
 
   <application
+      android:name=".MapsComposeApplication"
       android:allowBackup="true"
       android:icon="@mipmap/ic_launcher"
       android:label="@string/app_name"

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

@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-
 package com.google.maps.android.compose
 
 import android.location.Location

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

@@ -0,0 +1,38 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.maps.android.compose
+
+import android.app.Application
+import com.google.maps.android.compose.internal.DefaultGoogleMapsInitializer
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+
+class MapsComposeApplication : Application() {
+    @OptIn(DelicateCoroutinesApi::class)
+    override fun onCreate() {
+        super.onCreate()
+        // Note: that this is not a singleton, but it should still effectively load the SDK once
+
+        GlobalScope.launch(Dispatchers.Main) {
+            DefaultGoogleMapsInitializer().initialize(
+                context = this@MapsComposeApplication,
+                forceInitialization = false
+            )
+        }
+    }
+
+}

maps-app/src/test/java/com/google/maps/android/compose/internal/GoogleMapsInitializerTest.kt

@@ -23,11 +23,13 @@ import io.mockk.every
 import io.mockk.mockk
 import io.mockk.mockkStatic
 import io.mockk.verify
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.test.TestDispatcher
 import kotlinx.coroutines.test.UnconfinedTestDispatcher
 import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
 import org.junit.Assert.assertEquals
 import org.junit.Before
 import org.junit.Test
@@ -51,6 +53,7 @@ class GoogleMapsInitializerTest {
         every { MapsApiSettings.addInternalUsageAttributionId(any(), any()) } returns Unit
 
         testDispatcher = UnconfinedTestDispatcher()
+        Dispatchers.setMain(testDispatcher)
         googleMapsInitializer = DefaultGoogleMapsInitializer(testDispatcher)
     }
 

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

@@ -15,6 +15,7 @@
 package com.google.maps.android.compose.internal
 
 import android.content.Context
+import android.os.StrictMode
 import androidx.compose.runtime.ProvidableCompositionLocal
 import androidx.compose.runtime.State
 import androidx.compose.runtime.compositionLocalOf
@@ -25,6 +26,7 @@ import com.google.android.gms.maps.MapsApiSettings
 import com.google.maps.android.compose.meta.AttributionId
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
@@ -115,7 +117,8 @@ public interface GoogleMapsInitializer {
  * @param ioDispatcher The dispatcher to use for IO operations.
  */
 public class DefaultGoogleMapsInitializer(
-    private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO
+    private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO,
+    private val mainDispatcher: CoroutineDispatcher = Dispatchers.Main,
 ) : GoogleMapsInitializer {
     private val _state = mutableStateOf(InitializationState.UNINITIALIZED)
     override val state: State<InitializationState> = _state
@@ -142,12 +145,24 @@ public class DefaultGoogleMapsInitializer(
                 _state.value = InitializationState.INITIALIZING
             }
 
-            withContext(ioDispatcher) {
-                if (MapsInitializer.initialize(context) == ConnectionResult.SUCCESS) {
-                    MapsApiSettings.addInternalUsageAttributionId(context, attributionId)
-                    _state.value = InitializationState.SUCCESS
-                } else {
-                    _state.value = InitializationState.FAILURE
+            withContext(mainDispatcher) {
+                val scope = this
+
+                val policy = StrictMode.getThreadPolicy()
+                try {
+                    StrictMode.allowThreadDiskReads()
+                    val result = MapsInitializer.initialize(context, null) {
+                        scope.launch(ioDispatcher) {
+                            MapsApiSettings.addInternalUsageAttributionId(context, attributionId)
+                            _state.value = InitializationState.SUCCESS
+                        }
+                    }
+
+                    if (result != ConnectionResult.SUCCESS) {
+                        _state.value = InitializationState.FAILURE
+                    }
+                } finally {
+                    StrictMode.setThreadPolicy(policy)
                 }
             }
         } catch (e: com.google.android.gms.common.GooglePlayServicesMissingManifestValueException) {