cache is now updated directly if not on the main thread

while cache is updated, if no cache data exists, connection status is unknown and type is null

Author: stefanosiano

sentry-android-core/src/main/java/io/sentry/android/core/internal/util/AndroidConnectionStatusProvider.java

@@ -147,6 +147,12 @@ private boolean isNetworkEffectivelyConnected(
           : ConnectionStatus.DISCONNECTED;
     }
 
+    // If cache is being updated, and there's no cached data, return UNKNOWN status until cache is
+    // updated
+    if (isUpdatingCache.get()) {
+      return ConnectionStatus.UNKNOWN;
+    }
+
     // Fallback to legacy method when NetworkCapabilities not available
     final ConnectivityManager connectivityManager =
         getConnectivityManager(context, options.getLogger());
@@ -164,6 +170,12 @@ private boolean isNetworkEffectivelyConnected(
       return getConnectionType(capabilities);
     }
 
+    // If cache is being updated, and there's no cached data, return UNKNOWN status until cache is
+    // updated
+    if (isUpdatingCache.get()) {
+      return null;
+    }
+
     // Fallback to legacy method when NetworkCapabilities not available
     return getConnectionType(context, options.getLogger(), buildInfoProvider);
   }
@@ -402,24 +414,24 @@ private void updateCache() {
   @RequiresApi(api = Build.VERSION_CODES.M)
   private void updateCacheFromConnectivityManager() {
     final ConnectivityManager connectivityManager =
-      getConnectivityManager(context, options.getLogger());
+        getConnectivityManager(context, options.getLogger());
     if (connectivityManager != null) {
       final @Nullable NetworkCapabilities capabilities =
-        getNetworkCapabilities(connectivityManager);
+          getNetworkCapabilities(connectivityManager);
 
       try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
         cachedNetworkCapabilities = capabilities;
         lastCacheUpdateTime = timeProvider.getCurrentTimeMillis();
 
         if (capabilities != null) {
           options
-            .getLogger()
-            .log(
-              SentryLevel.DEBUG,
-              "Cache updated - Status: "
-                + getConnectionStatusFromCache()
-                + ", Type: "
-                + getConnectionTypeFromCache());
+              .getLogger()
+              .log(
+                  SentryLevel.DEBUG,
+                  "Cache updated - Status: "
+                      + getConnectionStatusFromCache()
+                      + ", Type: "
+                      + getConnectionTypeFromCache());
         }
       }
     }

sentry-android-core/src/test/java/io/sentry/android/core/internal/util/AndroidConnectionStatusProviderTest.kt

@@ -25,8 +25,10 @@ import io.sentry.android.core.AppState
 import io.sentry.android.core.BuildInfoProvider
 import io.sentry.android.core.ContextUtils
 import io.sentry.android.core.SystemEventsBreadcrumbsIntegration
+import io.sentry.test.DeferredExecutorService
 import io.sentry.test.ImmediateExecutorService
 import io.sentry.transport.ICurrentDateProvider
+import io.sentry.util.thread.IThreadChecker
 import kotlin.test.AfterTest
 import kotlin.test.BeforeTest
 import kotlin.test.Test
@@ -38,6 +40,7 @@ import kotlin.test.assertTrue
 import org.junit.runner.RunWith
 import org.mockito.MockedStatic
 import org.mockito.Mockito.mockStatic
+import org.mockito.Mockito.never
 import org.mockito.kotlin.any
 import org.mockito.kotlin.anyOrNull
 import org.mockito.kotlin.argThat
@@ -205,6 +208,41 @@ class AndroidConnectionStatusProviderTest {
     providerWithNullConnectivity.close()
   }
 
+  @Test
+  fun `When cache is updating, return UNKNOWN for connectionStatus on main thread`() {
+    whenever(networkInfo.isConnected).thenReturn(true)
+    // When we are on the main thread
+    val mockThreadChecker = mock<IThreadChecker>()
+    options.threadChecker = mockThreadChecker
+    whenever(mockThreadChecker.isMainThread()).thenReturn(true)
+
+    // The update is done on the background
+    val executorService = DeferredExecutorService()
+    options.executorService = executorService
+
+    // Advance time beyond TTL (2 minutes)
+    currentTime += 2 * 60 * 1000L
+
+    // Connection status is unknown while we update the cache
+    assertEquals(
+      IConnectionStatusProvider.ConnectionStatus.UNKNOWN,
+      connectionStatusProvider.connectionStatus,
+    )
+
+    verify(connectivityManager, never()).activeNetworkInfo
+    verify(connectivityManager, never()).activeNetwork
+
+    // When background cache update is done
+    executorService.runAll()
+
+    // Connection status is updated
+    verify(connectivityManager).activeNetwork
+    assertEquals(
+      IConnectionStatusProvider.ConnectionStatus.CONNECTED,
+      connectionStatusProvider.connectionStatus,
+    )
+  }
+
   @Test
   fun `When there's no permission, return null for getConnectionType`() {
     whenever(contextMock.checkPermission(any(), any(), any())).thenReturn(PERMISSION_DENIED)
@@ -219,6 +257,35 @@ class AndroidConnectionStatusProviderTest {
     assertNull(connectionStatusProvider.connectionType)
   }
 
+  @Test
+  fun `When cache is updating, return null for getConnectionType on main thread`() {
+    whenever(networkInfo.isConnected).thenReturn(true)
+    // When we are on the main thread
+    val mockThreadChecker = mock<IThreadChecker>()
+    options.threadChecker = mockThreadChecker
+    whenever(mockThreadChecker.isMainThread()).thenReturn(true)
+
+    // The update is done on the background
+    val executorService = DeferredExecutorService()
+    options.executorService = executorService
+
+    // Advance time beyond TTL (2 minutes)
+    currentTime += 2 * 60 * 1000L
+
+    // Connection type is null while we update the cache
+    assertNull(connectionStatusProvider.connectionType)
+
+    verify(connectivityManager, never()).activeNetworkInfo
+    verify(connectivityManager, never()).activeNetwork
+
+    // When background cache update is done
+    executorService.runAll()
+
+    // Connection type is updated
+    verify(connectivityManager).activeNetwork
+    assertNotNull(connectionStatusProvider.connectionType)
+  }
+
   @Test
   fun `When network capabilities are not available, return null for getConnectionType`() {
     whenever(connectivityManager.getNetworkCapabilities(any())).thenReturn(null)