remove coroutines and Flow

Author: typotter

features/dd-sdk-android-flags/api/apiSurface

@@ -26,7 +26,6 @@ data class com.datadog.android.flags.FlagsConfiguration
 interface com.datadog.android.flags.FlagsStateListener
   fun onStateChanged(com.datadog.android.flags.model.FlagsClientState)
 interface com.datadog.android.flags.StateObservable
-  val flow: kotlinx.coroutines.flow.StateFlow<com.datadog.android.flags.model.FlagsClientState>
   fun getCurrentState(): com.datadog.android.flags.model.FlagsClientState
   fun addListener(FlagsStateListener)
   fun removeListener(FlagsStateListener)

features/dd-sdk-android-flags/api/dd-sdk-android-flags.api

@@ -63,7 +63,6 @@ public abstract interface class com/datadog/android/flags/FlagsStateListener {
 public abstract interface class com/datadog/android/flags/StateObservable {
 	public abstract fun addListener (Lcom/datadog/android/flags/FlagsStateListener;)V
 	public abstract fun getCurrentState ()Lcom/datadog/android/flags/model/FlagsClientState;
-	public abstract fun getFlow ()Lkotlinx/coroutines/flow/StateFlow;
 	public abstract fun removeListener (Lcom/datadog/android/flags/FlagsStateListener;)V
 }
 

features/dd-sdk-android-flags/build.gradle.kts

@@ -52,7 +52,6 @@ dependencies {
 
     implementation(libs.gson)
     implementation(libs.kotlin)
-    api(libs.coroutinesCore)
     implementation(libs.okHttp)
     implementation(libs.androidXAnnotation)
     implementation(libs.androidXCollection)

features/dd-sdk-android-flags/src/main/kotlin/com/datadog/android/flags/StateObservable.kt

@@ -7,32 +7,24 @@
 package com.datadog.android.flags
 
 import com.datadog.android.flags.model.FlagsClientState
-import kotlinx.coroutines.flow.StateFlow
 
 /**
  * Observable interface for tracking [FlagsClient] state changes.
  *
- * This interface provides three ways to observe state:
- * 1. **Synchronous getter**: [getCurrentState] for immediate state queries (Java-friendly)
- * 2. **Reactive Flow**: [flow] for coroutine-based reactive updates (Kotlin)
- * 3. **Callback pattern**: [addListener]/[removeListener] for traditional observers (Java-friendly)
+ * This interface provides two ways to observe state:
+ * 1. **Synchronous getter**: [getCurrentState] for immediate state queries
+ * 2. **Callback pattern**: [addListener]/[removeListener] for reactive observers
  *
  * ## Usage Examples
  *
  * ```kotlin
- * // Synchronous getter (Java-friendly, no Flow dependency)
+ * // Synchronous getter
  * val current = client.state.getCurrentState()
  * if (current is FlagsClientState.Ready) {
  *     // Proceed
  * }
  *
- * // Reactive Flow (Kotlin coroutines)
- * client.state.flow.value  // Current value
- * client.state.flow.collect { state ->  // Collect updates
- *     // Handle state change
- * }
- *
- * // Callback pattern (Java-friendly)
+ * // Callback pattern
  * client.state.addListener(object : FlagsStateListener {
  *     override fun onStateChanged(newState: FlagsClientState) {
  *         // Handle state change
@@ -41,19 +33,10 @@ import kotlinx.coroutines.flow.StateFlow
  * ```
  */
 interface StateObservable {
-    /**
-     * Reactive Flow of state changes.
-     *
-     * This [StateFlow] emits the current state immediately to new collectors,
-     * then emits all subsequent state changes. Suitable for Kotlin coroutines users.
-     */
-    val flow: StateFlow<FlagsClientState>
-
     /**
      * Returns the current state synchronously.
      *
-     * This method is safe to call from any thread and does not require coroutines.
-     * Suitable for Java users or quick state checks.
+     * This method is safe to call from any thread.
      *
      * @return The current [FlagsClientState].
      */
@@ -63,8 +46,7 @@ interface StateObservable {
      * Registers a listener to receive state change notifications.
      *
      * The listener will immediately receive the current state upon registration,
-     * then be notified of all future state changes. Suitable for Java users or
-     * when Flow is not available.
+     * then be notified of all future state changes.
      *
      * @param listener The [FlagsStateListener] to register.
      */

features/dd-sdk-android-flags/src/main/kotlin/com/datadog/android/flags/internal/FlagsStateManager.kt

@@ -12,9 +12,6 @@ import com.datadog.android.flags.FlagsStateListener
 import com.datadog.android.flags.StateObservable
 import com.datadog.android.flags.model.FlagsClientState
 import com.datadog.android.internal.utils.DDCoreSubscription
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
 import java.util.concurrent.ExecutorService
 
 /**
@@ -36,21 +33,20 @@ internal class FlagsStateManager(
     private val executorService: ExecutorService,
     private val internalLogger: InternalLogger
 ) : StateObservable {
-    /**
-     * The current state of the client as a mutable flow.
-     *
-     * Updates are coordinated through the executor service to ensure ordered delivery.
-     * MutableStateFlow itself is thread-safe.
-     */
-    private val _stateFlow = MutableStateFlow<FlagsClientState>(FlagsClientState.NotReady)
-
     /**
      * The current state of the client.
-     * Thread-safe: synchronized to ensure atomicity with flow updates.
+     * Thread-safe: uses volatile for visibility across threads.
      */
     @Volatile
     private var currentState: FlagsClientState = FlagsClientState.NotReady
 
+    /**
+     * Returns the current state synchronously.
+     *
+     * @return The current [FlagsClientState].
+     */
+    override fun getCurrentState(): FlagsClientState = currentState
+
     /**
      * Updates the state and notifies all listeners.
      *
@@ -64,21 +60,13 @@ internal class FlagsStateManager(
             operationName = UPDATE_STATE_OPERATION_NAME,
             internalLogger = internalLogger
         ) {
-            synchronized(this) {
-                currentState = newState
-                _stateFlow.value = newState
-            }
+            currentState = newState
             subscription.notifyListeners {
                 onStateChanged(newState)
             }
         }
     }
 
-    override val flow: StateFlow<FlagsClientState> = _stateFlow.asStateFlow()
-
-    @Synchronized
-    override fun getCurrentState(): FlagsClientState = currentState
-
     override fun addListener(listener: FlagsStateListener) {
         subscription.addListener(listener)
 

features/dd-sdk-android-flags/src/main/kotlin/com/datadog/android/flags/internal/NoOpFlagsClient.kt

@@ -14,9 +14,6 @@ import com.datadog.android.flags.model.ErrorCode
 import com.datadog.android.flags.model.EvaluationContext
 import com.datadog.android.flags.model.FlagsClientState
 import com.datadog.android.flags.model.ResolutionDetails
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
 import org.json.JSONObject
 
 /**
@@ -39,9 +36,7 @@ internal class NoOpFlagsClient(
 ) : FlagsClient {
 
     override val state: StateObservable = object : StateObservable {
-        private val _stateFlow = MutableStateFlow<FlagsClientState>(FlagsClientState.Ready)
-        override val flow: StateFlow<FlagsClientState> = _stateFlow.asStateFlow()
-        override fun getCurrentState(): FlagsClientState = FlagsClientState.Ready
+        override fun getCurrentState(): FlagsClientState = FlagsClientState.Error(null)
         override fun addListener(listener: FlagsStateListener) { /* no-op */ }
         override fun removeListener(listener: FlagsStateListener) { /* no-op */ }
     }

features/dd-sdk-android-flags/src/test/kotlin/com/datadog/android/flags/NoOpFlagsClientTest.kt

@@ -432,13 +432,12 @@ internal class NoOpFlagsClientTest {
     // region State Management
 
     @Test
-    fun `M return ready state W state_getCurrentState()`() {
+    fun `M return error state W state_getCurrentState()`() {
         // When
         val state = testedClient.state.getCurrentState()
 
         // Then
-        // NoOp client is always "ready" to return default values
-        assertThat(state).isEqualTo(FlagsClientState.Ready)
+        assertThat(state).isInstanceOf(FlagsClientState.Error::class.java)
     }
 
     @Test

features/dd-sdk-android-flags/transitiveDependencies

@@ -8,8 +8,7 @@ com.squareup.okio:okio-jvm:3.6.0                                :  351 Kb
 org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.9.10                  :  959 b 
 org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.9.10                  :  965 b 
 org.jetbrains.kotlin:kotlin-stdlib:2.0.21                       : 1706 Kb
-org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm:1.4.2         : 1635 Kb
 org.jetbrains:annotations:13.0                                  :   17 Kb
 
-Total transitive dependencies size                              :    5 Mb
+Total transitive dependencies size                              :    3 Mb