Avoid IPC calls on main during map creation. (#2961)

Author: jush

CHANGELOG.md

@@ -3,7 +3,8 @@
 Mapbox welcomes participation and contributions from everyone.
 
 # main
-
+## Features ✨ and improvements 🏁
+* Small performance improvements in the map initialization call chain by avoiding IPC calls on main.
 
 # 11.10.0 February 13, 2025
 ## Features ✨ and improvements 🏁

maps-sdk/src/main/java/com/mapbox/maps/MapProvider.kt

@@ -1,8 +1,6 @@
 package com.mapbox.maps
 
 import android.content.Context
-import android.os.Handler
-import android.os.Looper
 import com.mapbox.annotation.module.MapboxModuleType
 import com.mapbox.common.EventsServerOptions
 import com.mapbox.common.EventsService
@@ -15,11 +13,23 @@ import com.mapbox.maps.geofencing.MapGeofencingConsent
 import com.mapbox.maps.module.MapTelemetry
 import com.mapbox.maps.plugin.MapDelegateProviderImpl
 import com.mapbox.maps.plugin.MapPluginRegistry
+import kotlinx.coroutines.CoroutineName
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.MainCoroutineDispatcher
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
 
 internal object MapProvider {
 
   private lateinit var mapTelemetry: MapTelemetry
 
+  /**
+   * [CoroutineScope] that runs on Main dispatcher by default (NOTE that it is not using [MainCoroutineDispatcher.immediate]).
+   */
+  private val mainScope =
+    CoroutineScope(CoroutineName(MapController.TAG) + SupervisorJob() + Dispatchers.Main)
+
   fun getNativeMapWrapper(
     mapInitOptions: MapInitOptions,
     mapClient: MapClient,
@@ -54,7 +64,8 @@ internal object MapProvider {
         paramsProvider(context, MapboxModuleType.MapTelemetry)
       }
     }
-    Handler(Looper.getMainLooper()).post {
+    // Schedule the turnstile event on the Main dispatcher to avoid blocking this call chain.
+    mainScope.launch {
       mapTelemetry.onAppUserTurnstileEvent()
     }
     return mapTelemetry

module-telemetry/build.gradle.kts

@@ -26,6 +26,7 @@ mapboxLibrary {
 dependencies {
   implementation(project(":sdk-base"))
   implementation(libs.mapbox.base)
+  implementation(libs.coroutines)
   compileOnly(libs.mapbox.annotations)
   kapt(libs.mapbox.annotationsProcessor)
   implementation(libs.kotlin)

module-telemetry/src/androidTest/java/com/mapbox/maps/module/telemetry/MapTelemetryEventsServiceTest.kt

@@ -17,6 +17,7 @@ import com.mapbox.common.EventsServiceObserver
 import com.mapbox.common.SdkInformation
 import com.mapbox.common.TelemetryService
 import com.mapbox.common.TelemetryUtils
+import kotlinx.coroutines.Dispatchers
 import org.junit.Assert
 import org.junit.Before
 import org.junit.BeforeClass
@@ -39,7 +40,7 @@ class MapTelemetryEventsServiceTest {
 
     val telemetryService = TelemetryService.getOrCreate()
     val context = InstrumentationRegistry.getInstrumentation().context
-    telemetry = MapTelemetryImpl(context, eventsService, telemetryService, options)
+    telemetry = MapTelemetryImpl(context, eventsService, telemetryService, options, Dispatchers.Unconfined)
   }
 
   @Test

module-telemetry/src/main/java/com/mapbox/maps/module/telemetry/MapTelemetryImpl.kt

@@ -8,11 +8,28 @@ import com.google.gson.Gson
 import com.mapbox.annotation.module.MapboxModule
 import com.mapbox.annotation.module.MapboxModuleType
 import com.mapbox.bindgen.Value
-import com.mapbox.common.*
+import com.mapbox.common.Event
+import com.mapbox.common.EventPriority
+import com.mapbox.common.EventsServerOptions
+import com.mapbox.common.EventsService
+import com.mapbox.common.EventsServiceInterface
+import com.mapbox.common.SdkInformation
+import com.mapbox.common.TelemetryCollectionState
+import com.mapbox.common.TelemetryService
+import com.mapbox.common.TelemetryUtils
+import com.mapbox.common.TurnstileEvent
+import com.mapbox.common.UserSKUIdentifier
 import com.mapbox.maps.base.BuildConfig
 import com.mapbox.maps.logE
+import com.mapbox.maps.logW
 import com.mapbox.maps.module.MapTelemetry
-import java.util.*
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineName
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import java.util.UUID
 
 /**
  * Concrete implementation of map telemetry.
@@ -27,7 +44,12 @@ class MapTelemetryImpl : MapTelemetry {
   private val eventsServiceOptions: EventsServerOptions
 
   /**
-   * Creates a map telemetry instance using application context and access token
+   * [CoroutineScope] that runs on IO dispatcher by default.
+   */
+  private val bgScope: CoroutineScope
+
+  /**
+   * Creates a map telemetry instance using application context
    *
    * @param appContext the application context
    */
@@ -44,6 +66,7 @@ class MapTelemetryImpl : MapTelemetry {
     )
     this.eventsService = EventsService.getOrCreate(eventsServiceOptions)
     this.telemetryService = TelemetryService.getOrCreate()
+    bgScope = CoroutineScope(CoroutineName(TAG) + SupervisorJob() + Dispatchers.IO)
   }
 
   /**
@@ -58,12 +81,14 @@ class MapTelemetryImpl : MapTelemetry {
     appContext: Context,
     eventsService: EventsServiceInterface,
     telemetryService: TelemetryService,
-    eventsServerOptions: EventsServerOptions
+    eventsServerOptions: EventsServerOptions,
+    defaultCoroutineDispatcher: CoroutineDispatcher,
   ) {
     this.appContext = appContext
     this.eventsService = eventsService
     this.telemetryService = telemetryService
     this.eventsServiceOptions = eventsServerOptions
+    bgScope = CoroutineScope(CoroutineName(TAG) + SupervisorJob() + defaultCoroutineDispatcher)
   }
 
   /**
@@ -77,8 +102,18 @@ class MapTelemetryImpl : MapTelemetry {
     }
 
     if (shouldSendEvents()) {
-      val mapLoadEvent = MapEventFactory.buildMapLoadEvent(PhoneState(appContext))
-      sendEvent(Gson().toJson(mapLoadEvent))
+      sendMapLoadEvent()
+    }
+  }
+
+  private fun sendMapLoadEvent() {
+    bgScope.launch {
+      try {
+        val mapLoadEvent = MapEventFactory.buildMapLoadEvent(PhoneState(appContext))
+        sendEvent(Gson().toJson(mapLoadEvent))
+      } catch (e: Throwable) {
+        logW(TAG, "sendMapLoadEvent error: $e")
+      }
     }
   }
 

module-telemetry/src/test/java/com/mapbox/maps/module/telemetry/MapTelemetryTest.kt

@@ -5,7 +5,9 @@ import android.telephony.TelephonyManager
 import android.view.Display
 import android.view.WindowManager
 import com.mapbox.common.*
+import com.mapbox.maps.base.BuildConfig
 import io.mockk.*
+import kotlinx.coroutines.Dispatchers
 import org.junit.After
 import org.junit.Assert.*
 import org.junit.Before
@@ -68,43 +70,54 @@ class MapTelemetryTest {
 
   @Before
   fun setUp() {
-    mockkStatic(EventsService::class)
-    mockkStatic(TelemetryService::class)
     mockkStatic(TelemetryUtils::class)
     every { TelemetryUtils.getEventsCollectionState() } returns true
     every { TelemetryUtils.setEventsCollectionState(any(), any()) } returns Unit
     every { TelemetryUtils.getClientServerEventsCollectionState() } returns TelemetryCollectionState.ENABLED
 
-    every { EventsService.getOrCreate(any()) } returns eventsService
     every { eventsService.sendEvent(any(), any()) } returns Unit
     every { eventsService.sendTurnstileEvent(any(), any()) } returns Unit
 
-    every { TelemetryService.getOrCreate() } returns telemetryService
-
     every { context.getSystemService(Context.TELEPHONY_SERVICE) } returns telephonyManager
     every { telephonyManager.networkType } returns TelephonyManager.NETWORK_TYPE_GPRS
     every { telephonyManager.networkOperatorName } returns "foobar"
 
     every { context.getSystemService(Context.WINDOW_SERVICE) } returns windowManager
     every { windowManager.defaultDisplay } returns display
 
-    telemetry = MapTelemetryImpl(context)
+    telemetry = MapTelemetryImpl(
+      context, eventsService, telemetryService,
+        EventsServerOptions(
+        SdkInformation(
+          BuildConfig.MAPBOX_SDK_IDENTIFIER,
+          BuildConfig.MAPBOX_SDK_VERSION,
+          null
+        ),
+        null
+      ),
+        Dispatchers.Unconfined
+    )
   }
 
   @After
   fun cleanUp() {
-    unmockkStatic(EventsService::class)
-    unmockkStatic(TelemetryService::class)
     unmockkStatic(TelemetryUtils::class)
     unmockkAll()
   }
 
   @Test
-  fun testConstructorInitialisation() {
+  fun testDefaultConstructorInitialisation() {
+    mockkStatic(EventsService::class)
+    mockkStatic(TelemetryService::class)
+    every { EventsService.getOrCreate(any()) } returns eventsService
+    every { TelemetryService.getOrCreate() } returns telemetryService
+    MapTelemetryImpl(context)
     // validate the event service is initialised
     verify { EventsService.getOrCreate(any()) }
     // validate the telemetry service is initialised
     verify { TelemetryService.getOrCreate() }
+    unmockkStatic(EventsService::class)
+    unmockkStatic(TelemetryService::class)
   }
 
   @Test