Offload display refresh rate retrieval off main thread to prevent ANR (#5326)

GitOrigin-RevId: fe056dab2772fc942ff9e1db23cd5a4e81e70c0a

Author: pengdev

CHANGELOG.md

@@ -4,6 +4,9 @@ Mapbox welcomes participation and contributions from everyone.
 
 # main
 
+## Bug fixes 🐞
+* Fix potential ANR (Application Not Responding) issue when retrieving display refresh rate during map initialization by offloading the system call to a background thread with proper timeout and fallback handling.
+
 
 # 11.14.0
 ## Bug fixes 🐞

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

@@ -40,6 +40,12 @@ import com.mapbox.maps.renderer.OnFpsChangedListener
 import com.mapbox.maps.renderer.RenderThreadStatsRecorder
 import com.mapbox.maps.renderer.RendererSetupErrorListener
 import com.mapbox.maps.renderer.widget.Widget
+import kotlinx.coroutines.CoroutineName
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.plus
 import java.util.concurrent.CopyOnWriteArraySet
 
 @RestrictTo(RestrictTo.Scope.LIBRARY)
@@ -56,6 +62,15 @@ internal class MapController : MapPluginProviderDelegate, MapControllable {
   private val cameraChangedCoalescedCallback: CameraChangedCoalescedCallback
   private val cancelableSubscriberSet = CopyOnWriteArraySet<Cancelable>()
 
+  /**
+   * Lifecycle-aware coroutine scope that follows the MapView/MapSurface lifecycle.
+   * This scope is created when the MapController is constructed and cancelled when destroyed.
+   * Can be used for any background operations that should be tied to the map lifecycle.
+   */
+  internal val lifecycleScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) + CoroutineName(
+    "MapControllerLifecycleScope"
+  )
+
   @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
   internal var lifecycleState: LifecycleState = LifecycleState.STATE_STOPPED
   private var style: Style? = null
@@ -207,6 +222,10 @@ internal class MapController : MapPluginProviderDelegate, MapControllable {
       return
     }
     lifecycleState = LifecycleState.STATE_DESTROYED
+
+    // Cancel the lifecycle coroutine scope to prevent memory leaks
+    lifecycleScope.cancel()
+
     pluginRegistry.onDestroy()
     nativeObserver.onDestroy()
     renderer.onDestroy()

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

@@ -11,6 +11,7 @@ import com.mapbox.maps.plugin.MapPlugin
 import com.mapbox.maps.plugin.delegates.MapPluginProviderDelegate
 import com.mapbox.maps.renderer.*
 import com.mapbox.maps.renderer.widget.Widget
+import kotlinx.coroutines.launch
 
 /**
  * A [MapSurface] provides an embeddable map interface.
@@ -86,11 +87,22 @@ class MapSurface : MapPluginProviderDelegate, MapControllable {
    */
   fun surfaceCreated() {
     renderer.surfaceCreated()
-    // display should not be null at this point but to be sure we will fallback to DEFAULT_FPS
-    @Suppress("DEPRECATION")
-    val screenRefreshRate = (context.getSystemService(Context.WINDOW_SERVICE) as WindowManager?)
-      ?.defaultDisplay?.refreshRate?.toInt() ?: MapView.DEFAULT_FPS
-    mapController.setScreenRefreshRate(screenRefreshRate)
+    // Set default refresh rate immediately to ensure map controller has a valid value
+    mapController.setScreenRefreshRate(MapView.DEFAULT_FPS)
+    // Retrieve screen refresh rate off the main thread to prevent ANR
+    mapController.lifecycleScope.launch {
+      safeSystemCallWithCallback(
+        fallback = MapView.DEFAULT_FPS,
+        logTag = TAG,
+        operation = {
+          @Suppress("DEPRECATION")
+          (context.getSystemService(Context.WINDOW_SERVICE) as WindowManager?)
+            ?.defaultDisplay?.refreshRate?.toInt() ?: MapView.DEFAULT_FPS
+        }
+      ) { screenRefreshRate ->
+        mapController.setScreenRefreshRate(screenRefreshRate)
+      }
+    }
   }
 
   /**
@@ -293,4 +305,8 @@ class MapSurface : MapPluginProviderDelegate, MapControllable {
    * @return created plugin instance or null if no plugin is found for given id.
    */
   override fun <T : MapPlugin> getPlugin(id: String): T? = mapController.getPlugin(id)
+
+  private companion object {
+    private const val TAG = "MapSurface"
+  }
 }

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

@@ -26,6 +26,7 @@ import com.mapbox.maps.renderer.egl.EGLCore
 import com.mapbox.maps.renderer.widget.Widget
 import com.mapbox.maps.viewannotation.ViewAnnotationManager
 import com.mapbox.maps.viewannotation.ViewAnnotationManagerImpl
+import kotlinx.coroutines.launch
 import java.nio.IntBuffer
 import kotlin.math.hypot
 
@@ -228,9 +229,21 @@ open class MapView : FrameLayout, MapPluginProviderDelegate, MapControllable {
    * @see android.app.Fragment.onStart
    */
   override fun onStart() {
-    // display should not be null at this point but to be sure we will fallback to DEFAULT_FPS
-    val screenRefreshRate = display?.refreshRate?.toInt() ?: DEFAULT_FPS
-    mapController.setScreenRefreshRate(screenRefreshRate)
+    // Set default refresh rate immediately to ensure map controller has a valid value
+    mapController.setScreenRefreshRate(DEFAULT_FPS)
+    // Retrieve screen refresh rate off the main thread to prevent ANR
+    mapController.lifecycleScope.launch {
+      safeSystemCallWithCallback(
+        fallback = DEFAULT_FPS,
+        logTag = TAG,
+        operation = {
+          display?.refreshRate?.toInt() ?: DEFAULT_FPS
+        }
+      ) { screenRefreshRate ->
+        mapController.setScreenRefreshRate(screenRefreshRate)
+      }
+    }
+
     mapController.onStart()
     if (debugOptionsControllerDelegate.isInitialized()) {
       debugOptionsController.started = true
@@ -554,6 +567,8 @@ open class MapView : FrameLayout, MapPluginProviderDelegate, MapControllable {
     @JvmSynthetic
     internal const val DEFAULT_FPS = 60
 
+    private const val TAG = "MapView"
+
     /**
      * Static method to check if [MapView] could properly render on this device.
      * This method may take some time on slow devices.

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

@@ -4,7 +4,11 @@ import android.content.Context
 import android.util.TypedValue
 import com.mapbox.bindgen.Expected
 import com.mapbox.common.Cancelable
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
 import java.lang.ref.WeakReference
 import kotlin.coroutines.Continuation
 
@@ -33,4 +37,66 @@ internal fun <T : Number> T.toDP(context: Context): T {
   return TypedValue.applyDimension(
       TypedValue.COMPLEX_UNIT_DIP, this.toFloat(), context.resources.displayMetrics
   ) as T
+}
+
+/**
+ * Executes a potentially blocking system call off the main thread with timeout and error handling.
+ * This utility helps prevent ANRs caused by blocking IPC calls to system services.
+ *
+ * Uses [Dispatchers.Default] as system calls are CPU-bound operations involving IPC to system services.
+ *
+ * @param timeoutMs Timeout in milliseconds for the operation (default: 5000ms)
+ * @param fallback Fallback value to return if the operation fails or times out
+ * @param logTag Tag for logging errors (default: "SystemCall")
+ * @param dispatcher The dispatcher to use for the operation (default: Dispatchers.Default)
+ * @param operation The blocking operation to execute
+ * @return The result of the operation or the fallback value
+ */
+internal suspend fun <T> safeSystemCall(
+  timeoutMs: Long = 5000L,
+  fallback: T,
+  logTag: String = "SystemCall",
+  dispatcher: CoroutineDispatcher = Dispatchers.Default,
+  operation: suspend () -> T
+): T {
+  return try {
+    withTimeoutOrNull(timeoutMs) {
+      withContext(dispatcher) {
+        operation()
+      }
+    } ?: run {
+      logW(logTag, "System call timed out after ${timeoutMs}ms, using fallback")
+      fallback
+    }
+  } catch (e: Exception) {
+    logE(logTag, "System call failed: ${e.message}, using fallback")
+    fallback
+  }
+}
+
+/**
+ * Executes a potentially blocking system call off the main thread and posts the result back to the main thread.
+ * This is useful for updating UI components after retrieving system information.
+ *
+ * @param timeoutMs Timeout in milliseconds for the operation (default: 5000ms)
+ * @param fallback Fallback value to return if the operation fails or times out
+ * @param logTag Tag for logging errors (default: "SystemCall")
+ * @param dispatcher The dispatcher to use for the operation (default: Dispatchers.Default)
+ * @param mainDispatcher The dispatcher to use for the callback (default: Dispatchers.Main)
+ * @param operation The blocking operation to execute
+ * @param onResult Callback to handle the result on the main thread
+ */
+internal suspend fun <T> safeSystemCallWithCallback(
+  timeoutMs: Long = 5000L,
+  fallback: T,
+  logTag: String = "SystemCall",
+  dispatcher: CoroutineDispatcher = Dispatchers.Default,
+  mainDispatcher: CoroutineDispatcher = Dispatchers.Main,
+  operation: suspend () -> T,
+  onResult: (T) -> Unit
+) {
+  val result = safeSystemCall(timeoutMs, fallback, logTag, dispatcher, operation)
+  withContext(mainDispatcher) {
+    onResult(result)
+  }
 }

maps-sdk/src/test/java/com/mapbox/maps/MapSurfaceTest.kt

@@ -15,11 +15,20 @@ import com.mapbox.verifyOnce
 import io.mockk.*
 import junit.framework.Assert.assertEquals
 import junit.framework.Assert.assertNull
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.TestCoroutineScheduler
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
+import org.junit.After
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
 
+@OptIn(ExperimentalCoroutinesApi::class)
 @RunWith(RobolectricTestRunner::class)
 class MapSurfaceTest {
 
@@ -30,14 +39,28 @@ class MapSurfaceTest {
   private lateinit var mapboxSurfaceRenderer: MapboxSurfaceRenderer
   private lateinit var surface: Surface
 
+  private val testScheduler = TestCoroutineScheduler()
+  private val testDispatcher = UnconfinedTestDispatcher(testScheduler)
+  private val mainTestDispatcher = UnconfinedTestDispatcher(testScheduler, "MainTestDispatcher")
+  private val testScope = CoroutineScope(testDispatcher)
+
   @Before
   fun setUp() {
+    Dispatchers.setMain(mainTestDispatcher)
+    mockkStatic("com.mapbox.maps.MapboxLogger")
+    every { logI(any(), any()) } just Runs
+    every { logW(any(), any()) } just Runs
+    every { logE(any(), any()) } just Runs
+
     context = mockk(relaxUnitFun = true)
     mapInitOptions = mockk(relaxUnitFun = true)
     mapController = mockk(relaxUnitFun = true)
     mapboxSurfaceRenderer = mockk(relaxUnitFun = true)
     surface = mockk(relaxed = true)
 
+    // Use test scope for lifecycleScope
+    every { mapController.lifecycleScope } returns testScope
+
     mapSurface = MapSurface(
       context,
       surface,
@@ -47,6 +70,12 @@ class MapSurfaceTest {
     )
   }
 
+  @After
+  fun cleanUp() {
+    Dispatchers.resetMain()
+    unmockkStatic("com.mapbox.maps.MapboxLogger")
+  }
+
   @Test
   fun testGetSurface() {
     assertEquals(surface, mapSurface.surface)
@@ -57,20 +86,31 @@ class MapSurfaceTest {
     val display: Display = mockk()
     val windowManager: WindowManager = mockk()
     val refreshRate = 100f
+    @Suppress("DEPRECATION")
     every { windowManager.defaultDisplay } returns display
     every { display.refreshRate } returns refreshRate
     every { context.getSystemService(Context.WINDOW_SERVICE) } returns windowManager
+
     mapSurface.surfaceCreated()
+
     verifyOnce { mapboxSurfaceRenderer.surfaceCreated() }
-    verifyOnce { mapController.setScreenRefreshRate(refreshRate.toInt()) }
+    // Verify the immediate default setting is called
+    verifySequence {
+      mapController.setScreenRefreshRate(MapView.DEFAULT_FPS)
+      mapController.lifecycleScope
+      mapController.setScreenRefreshRate(refreshRate.toInt())
+    }
   }
 
   @Test
   fun testSurfaceCreatedWithNoWindowManager() {
     every { context.getSystemService(Context.WINDOW_SERVICE) } returns null
+
     mapSurface.surfaceCreated()
+
     verifyOnce { mapboxSurfaceRenderer.surfaceCreated() }
-    verifyOnce { mapController.setScreenRefreshRate(MapView.DEFAULT_FPS) }
+    // Verify the immediate default setting is called
+    verify { mapController.setScreenRefreshRate(MapView.DEFAULT_FPS) }
   }
 
   @Test

maps-sdk/src/test/java/com/mapbox/maps/MapViewTest.kt

@@ -9,6 +9,13 @@ import com.mapbox.maps.renderer.OnFpsChangedListener
 import com.mapbox.maps.renderer.RendererSetupErrorListener
 import com.mapbox.verifyNo
 import io.mockk.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.TestCoroutineScheduler
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
 import org.junit.After
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
@@ -17,38 +24,53 @@ import org.junit.Test
 import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
 
+@OptIn(ExperimentalCoroutinesApi::class)
 @RunWith(RobolectricTestRunner::class)
 class MapViewTest {
 
   private lateinit var mapController: MapController
   private lateinit var mapboxMap: MapboxMap
   private lateinit var mapView: MapView
 
+  private val testScheduler = TestCoroutineScheduler()
+  private val testDispatcher = UnconfinedTestDispatcher(testScheduler)
+  private val mainTestDispatcher = UnconfinedTestDispatcher(testScheduler, "MainTestDispatcher")
+  private val testScope = CoroutineScope(testDispatcher)
+
   @Before
   fun setUp() {
+    Dispatchers.setMain(mainTestDispatcher)
     mockkConstructor(DebugOptionsController::class)
     every { anyConstructed<DebugOptionsController>().options = any() } just Runs
     mapController = mockk(relaxUnitFun = true)
     mapboxMap = mockk(relaxUnitFun = true)
     every { mapController.mapboxMap } returns mapboxMap
+    // Use test scope for lifecycleScope
+    every { mapController.lifecycleScope } returns testScope
+
     mapView = MapView(
       mockk(relaxed = true),
       mockk(relaxed = true),
       mapController,
     )
     mockkStatic("com.mapbox.maps.MapboxLogger")
     every { logI(any(), any()) } just Runs
+    every { logW(any(), any()) } just Runs
+    every { logE(any(), any()) } just Runs
   }
 
   @After
   fun cleanUp() {
+    Dispatchers.resetMain()
     unmockkStatic("com.mapbox.maps.MapboxLogger")
   }
 
   @Test
   fun start() {
     mapView.onStart()
+
     verify { mapController.onStart() }
+    verify { mapController.setScreenRefreshRate(MapView.DEFAULT_FPS) }
   }
 
   @Test