WIP: states added

Signed-off-by: Nicklas Lundin <[email protected]>

Signed-off-by: Nicklas Lundin <[email protected]>

fix: mark as throws

Signed-off-by: Nicklas Lundin <[email protected]>

Signed-off-by: Nicklas Lundin <[email protected]>

Signed-off-by: Nicklas Lundin <[email protected]>

Signed-off-by: Nicklas Lundin <[email protected]>

fix: add extra buffer capacity for the status flow

Signed-off-by: Nicklas Lundin <[email protected]>

Author: nicklasl

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

@@ -1,22 +1,35 @@
 package dev.openfeature.sdk
 
-import dev.openfeature.sdk.events.EventObserver
-import dev.openfeature.sdk.events.ProviderStatus
+import dev.openfeature.sdk.exceptions.OpenFeatureError
+import kotlin.jvm.Throws
 
-interface FeatureProvider : EventObserver, ProviderStatus {
+interface FeatureProvider {
     val hooks: List<Hook<*>>
     val metadata: ProviderMetadata
 
-    // Called by OpenFeatureAPI whenever the new Provider is registered
-    // This function should never throw
-    fun initialize(initialContext: EvaluationContext?)
+    /**
+     * Called by OpenFeatureAPI whenever the new Provider is registered
+     * This function should block until ready and throw exceptions if it fails to initialize
+     * @param initialContext any initial context to be set before the provider is ready
+     */
+    @Throws(OpenFeatureError::class)
+    suspend fun initialize(initialContext: EvaluationContext?)
 
-    // Called when the lifecycle of the OpenFeatureClient is over
-    // to release resources/threads
+    /**
+     * Called when the lifecycle of the OpenFeatureClient is over to release resources/threads
+     */
     fun shutdown()
 
-    // Called by OpenFeatureAPI whenever a new EvaluationContext is set by the application
-    fun onContextSet(oldContext: EvaluationContext?, newContext: EvaluationContext)
+    /**
+     * Called by OpenFeatureAPI whenever a new EvaluationContext is set by the application
+     * Perform blocking work here until the provider is ready again or throws an exception
+     * @param oldContext The old EvaluationContext
+     * @param newContext The new EvaluationContext
+     * @throws OpenFeatureError if the provider cannot perform the task
+     */
+    @Throws(OpenFeatureError::class)
+    suspend fun onContextSet(oldContext: EvaluationContext?, newContext: EvaluationContext)
+
     fun getBooleanEvaluation(
         key: String,
         defaultValue: Boolean,

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

@@ -1,20 +1,16 @@
 package dev.openfeature.sdk
 
-import dev.openfeature.sdk.events.OpenFeatureEvents
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flowOf
-
 open class NoOpProvider(override val hooks: List<Hook<*>> = listOf()) : FeatureProvider {
     override val metadata: ProviderMetadata = NoOpProviderMetadata("No-op provider")
-    override fun initialize(initialContext: EvaluationContext?) {
+    override suspend fun initialize(initialContext: EvaluationContext?) {
         // no-op
     }
 
     override fun shutdown() {
         // no-op
     }
 
-    override fun onContextSet(
+    override suspend fun onContextSet(
         oldContext: EvaluationContext?,
         newContext: EvaluationContext
     ) {
@@ -61,9 +57,5 @@ open class NoOpProvider(override val hooks: List<Hook<*>> = listOf()) : FeatureP
         return ProviderEvaluation(defaultValue, "Passed in default", Reason.DEFAULT.toString())
     }
 
-    override fun observe(): Flow<OpenFeatureEvents> = flowOf()
-
-    override fun getProviderStatus(): OpenFeatureEvents = OpenFeatureEvents.ProviderReady
-
     data class NoOpProviderMetadata(override val name: String?) : ProviderMetadata
 }

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

@@ -1,44 +1,45 @@
 package dev.openfeature.sdk
 
-import dev.openfeature.sdk.events.OpenFeatureEvents
-import dev.openfeature.sdk.events.awaitReadyOrError
-import dev.openfeature.sdk.events.observe
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.flow.Flow
+import dev.openfeature.sdk.exceptions.OpenFeatureError
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.SharedFlow
-import kotlinx.coroutines.flow.flatMapLatest
 
 @Suppress("TooManyFunctions")
 object OpenFeatureAPI {
     private val NOOP_PROVIDER = NoOpProvider()
     private var provider: FeatureProvider = NOOP_PROVIDER
     private var context: EvaluationContext? = null
-    private val providersFlow: MutableSharedFlow<FeatureProvider> = MutableSharedFlow(replay = 1)
-    internal val sharedProvidersFlow: SharedFlow<FeatureProvider> get() = providersFlow
+
+    private val _statusFlow: MutableSharedFlow<OpenFeatureStatus> =
+        MutableSharedFlow<OpenFeatureStatus>(replay = 1, extraBufferCapacity = 5)
+            .apply {
+                tryEmit(OpenFeatureStatus.NotReady)
+            }
+    val statusFlow: SharedFlow<OpenFeatureStatus> get() = _statusFlow
 
     var hooks: List<Hook<*>> = listOf()
         private set
 
-    fun setProvider(provider: FeatureProvider, initialContext: EvaluationContext? = null) {
+    suspend fun setProvider(provider: FeatureProvider, initialContext: EvaluationContext? = null) {
         this@OpenFeatureAPI.provider = provider
-        providersFlow.tryEmit(provider)
+        // TODO consider if stale status should emit? _statusFlow.tryEmit(OpenFeatureStatus.Stale)
         if (initialContext != null) context = initialContext
         try {
-            provider.initialize(context)
+            getProvider().initialize(context)
+            _statusFlow.tryEmit(OpenFeatureStatus.Ready)
+        } catch (e: OpenFeatureError) {
+            _statusFlow.tryEmit(OpenFeatureStatus.Error(e))
         } catch (e: Throwable) {
-            // This is not allowed to happen
+            _statusFlow.tryEmit(OpenFeatureStatus.Error(OpenFeatureError.GeneralError(e.message ?: e.javaClass.name)))
+            // TODO deal with things by setting status to Error or Fatal
         }
     }
 
     suspend fun setProviderAndWait(
         provider: FeatureProvider,
-        dispatcher: CoroutineDispatcher,
         initialContext: EvaluationContext? = null
     ) {
         setProvider(provider, initialContext)
-        provider.awaitReadyOrError(dispatcher)
     }
 
     fun getProvider(): FeatureProvider {
@@ -49,18 +50,31 @@ object OpenFeatureAPI {
         provider = NOOP_PROVIDER
     }
 
-    fun setEvaluationContext(evaluationContext: EvaluationContext) {
+    suspend fun setEvaluationContext(evaluationContext: EvaluationContext) {
         val oldContext = context
         context = evaluationContext
-        getProvider().onContextSet(oldContext, evaluationContext)
+        if (oldContext != evaluationContext) {
+            _statusFlow.tryEmit(OpenFeatureStatus.Reconciling)
+            try {
+                getProvider().onContextSet(oldContext, evaluationContext)
+                _statusFlow.tryEmit(OpenFeatureStatus.Ready)
+            } catch (e: OpenFeatureError) {
+                _statusFlow.tryEmit(OpenFeatureStatus.Error(e))
+                // TODO how do we handle fatal errors?
+            } catch (e: Throwable) {
+                _statusFlow.tryEmit(
+                    OpenFeatureStatus.Error(OpenFeatureError.GeneralError(e.message ?: e.javaClass.name))
+                )
+            }
+        }
     }
 
     fun getEvaluationContext(): EvaluationContext? {
         return context
     }
 
     fun getProviderMetadata(): ProviderMetadata? {
-        return provider.metadata
+        return getProvider().metadata
     }
 
     fun getClient(name: String? = null, version: String? = null): Client {
@@ -76,16 +90,9 @@ object OpenFeatureAPI {
     }
 
     fun shutdown() {
-        provider.shutdown()
+        _statusFlow.tryEmit(OpenFeatureStatus.NotReady)
+        getProvider().shutdown()
     }
 
-    /*
-    Observe events from currently configured Provider.
-    */
-    @OptIn(ExperimentalCoroutinesApi::class)
-    internal inline fun <reified T : OpenFeatureEvents> observe(): Flow<T> {
-        return sharedProvidersFlow.flatMapLatest { provider ->
-            provider.observe<T>()
-        }
-    }
+    fun getStatus(): OpenFeatureStatus = statusFlow.replayCache.first()
 }

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

@@ -0,0 +1,35 @@
+package dev.openfeature.sdk
+
+import dev.openfeature.sdk.exceptions.OpenFeatureError
+
+sealed interface OpenFeatureStatus {
+    /**
+     * The provider has not been initialized and cannot yet evaluate flags.
+     */
+    object NotReady : OpenFeatureStatus
+
+    /**
+     * The provider is ready to resolve flags.
+     */
+    object Ready : OpenFeatureStatus
+
+    /**
+     * The provider is in an error state and unable to evaluate flags.
+     */
+    class Error(val error: OpenFeatureError) : OpenFeatureStatus
+
+    /**
+     * The provider's cached state is no longer valid and may not be up-to-date with the source of truth.
+     */
+    object Stale : OpenFeatureStatus
+
+    /**
+     * The provider has entered an irrecoverable error state.
+     */
+    object Fatal : OpenFeatureStatus
+
+    /**
+     * The provider is reconciling its state with a context change.
+     */
+    object Reconciling : OpenFeatureStatus
+}