fix(android): Run the telephony callback on its own thread

The provider submitted the display info update to the SDK executor it
got at construction. That reference goes stale twice over. The options
hold a no-op executor until `SentryOptions.activate` replaces it, and
`AndroidOptionsInitializer` builds this provider from the options
configuration callback, which `Sentry.init` runs before `activate`. A
second `SentryAndroid.init` then shuts the previous executor down while
the provider keeps the dead one. Either way the submitted work never
runs, and from API 31 on the listener is the only source of the value.

Pass `Runnable::run` instead. The callback maps the display info to a
generation and stores it, so the binder thread the framework calls it
on is the right place for it. The executor, its field and the
`RejectedExecutionException` guard all go away.

Author: alwx

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

@@ -96,8 +96,7 @@ public AndroidConnectionStatusProvider(
     this.handler = handler;
     this.connectionStatusObservers = new ArrayList<>();
     this.cellularNetworkTechnologyProvider =
-        new CellularNetworkTechnologyProvider(
-            this.context, options.getLogger(), buildInfoProvider, options.getExecutorService());
+        new CellularNetworkTechnologyProvider(this.context, options.getLogger(), buildInfoProvider);
 
     capabilities[0] = NetworkCapabilities.NET_CAPABILITY_INTERNET;
     if (buildInfoProvider.getSdkInfoVersion() >= Build.VERSION_CODES.M) {

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

@@ -10,12 +10,9 @@
 import androidx.annotation.NonNull;
 import androidx.annotation.RequiresApi;
 import io.sentry.ILogger;
-import io.sentry.ISentryExecutorService;
 import io.sentry.SentryLevel;
 import io.sentry.android.core.BuildInfoProvider;
 import io.sentry.android.core.ContextUtils;
-import java.util.concurrent.Executor;
-import java.util.concurrent.RejectedExecutionException;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -45,13 +42,6 @@ public final class CellularNetworkTechnologyProvider {
   /** Guards the registration of the display info listener. */
   private final @NotNull Object registrationLock = new Object();
 
-  /**
-   * The executor the telephony framework calls. The framework calls it on a thread of its own, so a
-   * rejection must not escape: the SDK's executor rejects work once it is shut down, which can
-   * happen before the listener is unregistered.
-   */
-  private final @NotNull Executor executor;
-
   /**
    * Set from {@link TelephonyCallback.DisplayInfoListener} on API 31 and above. Declared as {@link
    * Object} so that loading this class on older devices never has to resolve a type that does not
@@ -64,22 +54,10 @@ public final class CellularNetworkTechnologyProvider {
   public CellularNetworkTechnologyProvider(
       final @NotNull Context context,
       final @NotNull ILogger logger,
-      final @NotNull BuildInfoProvider buildInfoProvider,
-      final @NotNull ISentryExecutorService executorService) {
+      final @NotNull BuildInfoProvider buildInfoProvider) {
     this.context = ContextUtils.getApplicationContext(context);
     this.logger = logger;
     this.buildInfoProvider = buildInfoProvider;
-    this.executor =
-        runnable -> {
-          try {
-            executorService.submit(runnable);
-          } catch (RejectedExecutionException e) {
-            logger.log(
-                SentryLevel.DEBUG,
-                "Dropping a cellular network technology update, the executor rejected it.",
-                e);
-          }
-        };
   }
 
   /**
@@ -114,7 +92,12 @@ public void register() {
       }
       try {
         final @NotNull DisplayInfoCallback callback = new DisplayInfoCallback(this);
-        telephonyManager.registerTelephonyCallback(executor, callback);
+        // The callback maps the display info to a generation and stores it, so it runs on the
+        // binder thread the telephony framework calls it on. An executor of the SDK would add a
+        // reference that goes stale: the options hold a no-op executor until
+        // SentryOptions.activate replaces it, and a second SentryAndroid.init shuts the previous
+        // one down.
+        telephonyManager.registerTelephonyCallback(Runnable::run, callback);
         displayInfoCallback = callback;
         logger.log(SentryLevel.DEBUG, "Started listening for cellular network technology changes.");
       } catch (SecurityException | IllegalStateException | UnsupportedOperationException e) {

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

@@ -11,7 +11,6 @@ import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.google.common.truth.Truth.assertThat
 import io.sentry.ILogger
 import io.sentry.android.core.BuildInfoProvider
-import io.sentry.test.ImmediateExecutorService
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
 import kotlin.test.BeforeTest
@@ -36,9 +35,6 @@ class CellularNetworkTechnologyProviderTest {
     val buildInfo = mock<BuildInfoProvider>()
     val telephonyManager = mock<TelephonyManager>()
 
-    /** Runs the display info callback inline, so tests don't have to wait for another thread. */
-    val executorService = ImmediateExecutorService()
-
     fun getSut(
       sdkVersion: Int = Build.VERSION_CODES.S,
       hasPermission: Boolean = false,
@@ -49,7 +45,7 @@ class CellularNetworkTechnologyProviderTest {
         .thenReturn(if (hasTelephonyManager) telephonyManager else null)
       whenever(context.checkPermission(any(), any(), any()))
         .thenReturn(if (hasPermission) PERMISSION_GRANTED else PERMISSION_DENIED)
-      return CellularNetworkTechnologyProvider(context, logger, buildInfo, executorService)
+      return CellularNetworkTechnologyProvider(context, logger, buildInfo)
     }
 
     fun displayInfo(networkType: Int, overrideNetworkType: Int): TelephonyDisplayInfo {
@@ -65,8 +61,8 @@ class CellularNetworkTechnologyProviderTest {
     ): TelephonyCallback.DisplayInfoListener {
       provider.register()
       val captor = argumentCaptor<TelephonyCallback>()
-      // The provider wraps the executor service, so the executor it hands to the telephony
-      // manager is not an object this test holds.
+      // The provider runs the callback on the thread the framework calls, so the executor it
+      // hands over only calls `run`.
       verify(telephonyManager).registerTelephonyCallback(any(), captor.capture())
       return captor.firstValue as TelephonyCallback.DisplayInfoListener
     }