fix: add proper exception handling for background event source

Author: suthar26

android-client-sdk/src/main/java/com/devcycle/sdk/android/api/DevCycleClient.kt

@@ -48,7 +48,7 @@ class DevCycleClient private constructor(
     private val coroutineContext: CoroutineContext = Dispatchers.Default
 ) {
     private var config: BucketedUserConfig? = null
-    private var backgroundEventSource: BackgroundEventSource? = null
+    private var backgroundEventSource: SafeBackgroundEventSource? = null
     private val defaultIntervalInMs: Long = 10000
     private val flushInMs: Long = options?.flushEventsIntervalMs ?: defaultIntervalInMs
 
@@ -172,7 +172,8 @@ class DevCycleClient private constructor(
                 .readTimeout(EVENT_SOURCE_RETRY_DELAY_MIN, TimeUnit.MINUTES)
         )
 
-        backgroundEventSource = BackgroundEventSource.Builder(handler, builder).build()
+        val delegate = BackgroundEventSource.Builder(handler, builder).build()
+        backgroundEventSource = SafeBackgroundEventSource(delegate)
         backgroundEventSource?.start()
     }
 

android-client-sdk/src/main/java/com/devcycle/sdk/android/eventsource/SafeBackgroundEventSource.kt

@@ -0,0 +1,56 @@
+package com.devcycle.sdk.android.eventsource
+
+import com.devcycle.sdk.android.util.DevCycleLogger
+import com.launchdarkly.eventsource.EventSource
+import com.launchdarkly.eventsource.ReadyState
+import com.launchdarkly.eventsource.background.BackgroundEventSource
+import java.util.concurrent.RejectedExecutionException
+
+/**
+ * A safe wrapper around BackgroundEventSource that handles RejectedExecutionException
+ * during shutdown operations gracefully to prevent app crashes.
+ * 
+ * This wrapper is necessary because when EventSource is closed, its internal executor
+ * is shut down. If there are any pending tasks or race conditions during shutdown,
+ * they would throw RejectedExecutionException which could crash the application.
+ */
+class SafeBackgroundEventSource(
+    private val delegate: BackgroundEventSource
+) {
+    /**
+     * Access the underlying EventSource for state checks
+     */
+    val eventSource: EventSource
+        get() = delegate.eventSource
+
+    /**
+     * Start the background event source
+     */
+    fun start() {
+        try {
+            delegate.start()
+        } catch (e: RejectedExecutionException) {
+            DevCycleLogger.d("EventSource start rejected (executor may be shut down): ${e.message}")
+        } catch (e: Exception) {
+            DevCycleLogger.w("Unexpected error starting EventSource: ${e.message}")
+            throw e
+        }
+    }
+
+    /**
+     * Close the background event source safely, catching any RejectedExecutionException
+     * that may occur during shutdown due to race conditions with internal executor threads.
+     */
+    fun close() {
+        try {
+            delegate.close()
+        } catch (e: RejectedExecutionException) {
+            // This is expected during shutdown when tasks are submitted to an already-terminated executor
+            DevCycleLogger.d("EventSource close rejected during shutdown (expected): ${e.message}")
+        } catch (e: Exception) {
+            // Log unexpected exceptions but don't propagate them to prevent crashes
+            DevCycleLogger.w("Unexpected error closing EventSource: ${e.message}")
+        }
+    }
+}
+