feat: Update observeEvents() API (#89)

Signed-off-by: Fabrizio Demaria <[email protected]>

Author: fabriziodemaria

android/src/main/java/dev/openfeature/sdk/OpenFeatureAPI.kt

@@ -1,15 +1,21 @@
 package dev.openfeature.sdk
 
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+
 @Suppress("TooManyFunctions")
 object OpenFeatureAPI {
     private var provider: FeatureProvider? = null
     private var context: EvaluationContext? = null
+    private val providersFlow: MutableSharedFlow<FeatureProvider> = MutableSharedFlow(replay = 1)
+    internal val sharedProvidersFlow: SharedFlow<FeatureProvider> get() = providersFlow
 
     var hooks: List<Hook<*>> = listOf()
         private set
 
     fun setProvider(provider: FeatureProvider, initialContext: EvaluationContext? = null) {
         this@OpenFeatureAPI.provider = provider
+        providersFlow.tryEmit(provider)
         if (initialContext != null) context = initialContext
         try {
             provider.initialize(context)

android/src/main/java/dev/openfeature/sdk/async/Extensions.kt

@@ -9,8 +9,10 @@ import dev.openfeature.sdk.events.observe
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.onStart
 import kotlinx.coroutines.flow.take
 import kotlinx.coroutines.launch
@@ -42,6 +44,16 @@ internal fun FeatureProvider.observeProviderReady() = observe<OpenFeatureEvents.
         }
     }
 
+/*
+Observe events from currently configured Provider.
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+fun OpenFeatureAPI.observeEvents(): Flow<OpenFeatureEvents> {
+    return sharedProvidersFlow.flatMapLatest { provider ->
+        provider.observe()
+    }
+}
+
 internal fun FeatureProvider.observeProviderError() = observe<OpenFeatureEvents.ProviderError>()
     .onStart {
         val status = getProviderStatus()
@@ -50,10 +62,6 @@ internal fun FeatureProvider.observeProviderError() = observe<OpenFeatureEvents.
         }
     }
 
-inline fun <reified T : OpenFeatureEvents> OpenFeatureAPI.observeEvents(): Flow<T>? {
-    return getProvider()?.observe<T>()
-}
-
 suspend fun FeatureProvider.awaitReadyOrError(
     dispatcher: CoroutineDispatcher = Dispatchers.IO
 ) = suspendCancellableCoroutine { continuation ->

android/src/test/java/dev/openfeature/sdk/DeveloperExperienceTests.kt

@@ -1,15 +1,18 @@
 package dev.openfeature.sdk
 
+import dev.openfeature.sdk.async.observeEvents
 import dev.openfeature.sdk.async.setProviderAndWait
 import dev.openfeature.sdk.exceptions.ErrorCode
 import dev.openfeature.sdk.helpers.AlwaysBrokenProvider
+import dev.openfeature.sdk.helpers.DoSomethingProvider
 import dev.openfeature.sdk.helpers.GenericSpyHookMock
 import dev.openfeature.sdk.helpers.SlowProvider
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.advanceUntilIdle
 import kotlinx.coroutines.test.runTest
 import org.junit.Assert
 import org.junit.Test
@@ -86,4 +89,24 @@ class DeveloperExperienceTests {
         val booleanValue = OpenFeatureAPI.getClient().getBooleanValue("test", false)
         Assert.assertFalse(booleanValue)
     }
+
+    @Test
+    fun testObserveEvents() = runTest {
+        val dispatcher = StandardTestDispatcher(testScheduler)
+        var eventCount = 0
+        CoroutineScope(dispatcher).launch {
+            OpenFeatureAPI.observeEvents().collect {
+                eventCount++
+            }
+        }
+        CoroutineScope(dispatcher).launch {
+            OpenFeatureAPI.setProviderAndWait(
+                DoSomethingProvider(dispatcher = dispatcher),
+                dispatcher,
+                ImmutableContext()
+            )
+        }
+        advanceUntilIdle()
+        Assert.assertEquals(eventCount, 1)
+    }
 }

android/src/test/java/dev/openfeature/sdk/helpers/DoSomethingProvider.kt

@@ -6,16 +6,25 @@ import dev.openfeature.sdk.Hook
 import dev.openfeature.sdk.ProviderEvaluation
 import dev.openfeature.sdk.ProviderMetadata
 import dev.openfeature.sdk.Value
+import dev.openfeature.sdk.events.EventHandler
 import dev.openfeature.sdk.events.OpenFeatureEvents
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.launch
 
 class DoSomethingProvider(
     override val hooks: List<Hook<*>> = listOf(),
-    override val metadata: ProviderMetadata = DoSomethingProviderMetadata()
+    override val metadata: ProviderMetadata = DoSomethingProviderMetadata(),
+    private var dispatcher: CoroutineDispatcher = Dispatchers.IO
 ) : FeatureProvider {
+    private var eventHandler = EventHandler(dispatcher)
+
     override fun initialize(initialContext: EvaluationContext?) {
-        // no-op
+        CoroutineScope(dispatcher).launch {
+            eventHandler.publish(OpenFeatureEvents.ProviderReady)
+        }
     }
 
     override fun shutdown() {
@@ -69,7 +78,7 @@ class DoSomethingProvider(
         return ProviderEvaluation(Value.Null)
     }
 
-    override fun observe(): Flow<OpenFeatureEvents> = flowOf()
+    override fun observe(): Flow<OpenFeatureEvents> = eventHandler.observe()
 
     override fun getProviderStatus(): OpenFeatureEvents = OpenFeatureEvents.ProviderReady
 

android/src/test/java/dev/openfeature/sdk/helpers/SlowProvider.kt

@@ -13,7 +13,6 @@ import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.launch
 
 class SlowProvider(override val hooks: List<Hook<*>> = listOf(), private var dispatcher: CoroutineDispatcher) : FeatureProvider {
@@ -84,7 +83,7 @@ class SlowProvider(override val hooks: List<Hook<*>> = listOf(), private var dis
         return ProviderEvaluation(Value.Null)
     }
 
-    override fun observe(): Flow<OpenFeatureEvents> = flowOf()
+    override fun observe(): Flow<OpenFeatureEvents> = eventHandler.observe()
 
     override fun getProviderStatus(): OpenFeatureEvents = if (ready) {
         OpenFeatureEvents.ProviderReady