refactor: Make GoogleMapsInitializer suspendable

This change refactors the `GoogleMapsInitializer` to use suspend functions for initialization and reset operations, improving its testability and adherence to structured concurrency.

Key changes:
- Converted `GoogleMapsInitializer.initialize()` and `GoogleMapsInitializer.reset()` to `suspend` functions.
- Removed the internal `CoroutineScope` and job management from `GoogleMapsInitializer`.
- Updated unit and instrumentation tests to use `runTest` from `kotlinx-coroutines-test`, removing the need for `Thread.sleep()`.
- Added the `kotlinx-coroutines-test` dependency to the `maps-app` module.

Author: dkhawk

maps-app/build.gradle.kts

@@ -87,6 +87,7 @@ dependencies {
     testImplementation(libs.robolectric)
     testImplementation(libs.androidx.test.core)
     testImplementation(libs.truth)
+    testImplementation(libs.kotlinx.coroutines.test)
 
     screenshotTestImplementation(libs.androidx.compose.ui.tooling)
 

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

@@ -1,17 +1,3 @@
-// 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.content.Context
@@ -20,29 +6,29 @@ import androidx.test.platform.app.InstrumentationRegistry
 import com.google.common.truth.Truth.assertThat
 import com.google.maps.android.compose.internal.GoogleMapsInitializer
 import com.google.maps.android.compose.internal.InitializationState
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
 import org.junit.After
 import org.junit.Test
 import org.junit.runner.RunWith
 
+@OptIn(ExperimentalCoroutinesApi::class)
 @RunWith(AndroidJUnit4::class)
 class GoogleMapsInitializerTest {
 
     @After
-    fun tearDown() {
+    fun tearDown() = runTest {
         GoogleMapsInitializer.reset()
     }
 
     @Test
-    fun testInitializationSuccess() {
+    fun testInitializationSuccess() = runTest {
         // In an instrumentation test environment, Google Play services are available.
         // Therefore, we expect the initialization to succeed.
         val context: Context = InstrumentationRegistry.getInstrumentation().targetContext
 
         GoogleMapsInitializer.initialize(context)
 
-        // Wait for the initialization to complete
-        Thread.sleep(1000)
-
         assertThat(GoogleMapsInitializer.state.value).isEqualTo(InitializationState.SUCCESS)
     }
 }

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

@@ -1,48 +1,35 @@
-// 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.content.Context
 import androidx.test.core.app.ApplicationProvider
 import com.google.common.truth.Truth.assertThat
 import com.google.maps.android.compose.internal.GoogleMapsInitializer
 import com.google.maps.android.compose.internal.InitializationState
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
 import org.junit.After
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
 
+@OptIn(ExperimentalCoroutinesApi::class)
 @RunWith(RobolectricTestRunner::class)
 class GoogleMapsInitializerTest {
 
     @After
-    fun tearDown() {
+    fun tearDown() = runTest {
         GoogleMapsInitializer.reset()
     }
 
     @Test
-    fun testInitializationFailure() {
+    fun testInitializationFailure() = runTest {
         // In a unit test environment, Google Play services are not available.
         // Therefore, we expect the initialization to fail.
         val context: Context = ApplicationProvider.getApplicationContext()
 
         GoogleMapsInitializer.initialize(context)
 
-        // Wait for the initialization to complete
-        Thread.sleep(1000)
-
+        // The initialization is now synchronous within the test scope, so we don't need to wait.
         assertThat(GoogleMapsInitializer.state.value).isEqualTo(InitializationState.FAILURE)
     }
 }

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

@@ -23,10 +23,11 @@ import com.google.android.gms.maps.MapsApiSettings
 import com.google.maps.android.compose.meta.AttributionId
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
 
 /**
  * Enum representing the initialization state of the Google Maps SDK.
@@ -72,7 +73,6 @@ public object GoogleMapsInitializer {
     private val _state = mutableStateOf(InitializationState.UNINITIALIZED)
     public val state: State<InitializationState> = _state
 
-    private var initializationJob: Job? = null
     private val mutex = Mutex()
 
     /**
@@ -93,24 +93,28 @@ public object GoogleMapsInitializer {
      *
      * @param context The context to use for initialization.
      */
-    public fun initialize(context: Context) {
-        CoroutineScope(Dispatchers.IO).launch {
+    public suspend fun initialize(context: Context) {
+        if (_state.value != InitializationState.UNINITIALIZED) {
+            return
+        }
+        coroutineScope {
             mutex.withLock {
+                // Re-check state to prevent re-initialization even when calling this function in parallel
                 if (_state.value != InitializationState.UNINITIALIZED) {
                     return@withLock
                 }
-
                 _state.value = InitializationState.INITIALIZING
-                initializationJob = launch {
-                    try {
-                        if (MapsInitializer.initialize(context) == ConnectionResult.SUCCESS) {
-                            MapsApiSettings.addInternalUsageAttributionId(context, attributionId)
-                            _state.value = InitializationState.SUCCESS
-                        }
-                    } catch (e: Exception) {
-                        // In tests where the map is mocked, this can fail.
-                        _state.value = InitializationState.FAILURE
+            }
+
+            launch(Dispatchers.IO) {
+                try {
+                    if (MapsInitializer.initialize(context) == ConnectionResult.SUCCESS) {
+                        MapsApiSettings.addInternalUsageAttributionId(context, attributionId)
+                        _state.value = InitializationState.SUCCESS
                     }
+                } catch (e: Exception) {
+                    // In tests where the map is mocked, this can fail.
+                    _state.value = InitializationState.FAILURE
                 }
             }
         }
@@ -123,13 +127,9 @@ public object GoogleMapsInitializer {
      * This is useful in test environments where you might need to re-initialize the SDK
      * multiple times.
      */
-    public fun reset() {
-        CoroutineScope(Dispatchers.IO).launch {
-            mutex.withLock {
-                initializationJob?.cancel()
-                initializationJob = null
-                _state.value = InitializationState.UNINITIALIZED
-            }
+    public suspend fun reset() {
+        mutex.withLock {
+            _state.value = InitializationState.UNINITIALIZED
         }
     }
 }