Specification says that even for concrete methods above we need to return ResolutionDetails https://openfeature.dev/specification/sections/providers, but we are returning just the objects. Is it fine to not use this structure there?

We are not implementing the OpenFeature specification, rather we're exposing enough to allow a shim package to implement the OpenFeature Provider spec. This is the resolve method.
The concrete methods above mirror the OpenFeature Client interface, which the dev uses in their app. This is to make this SDK still be functional and useful, even without OpenFeature layered on top.

Should we support nullable types (values) here? If it is not the case, type should be T : Any

non null all the way.

reworded

I think this is confusing: here we have 3 resolveXXX methods, and the fact that there is resolveInternal with a result passed to resolveTracked doesn't add clarity. Should resolveInternal be renamed, maybe?

yes, I agree.
I renamed to readAndParseAssignment

minor: it is better to move this up, so that we have interface methods grouped first and only after them we have private methods.

done

do we need to explicitly make return type nullable? Cannot we return empty collection if JSONObject is empty?

good idea. there is no reason to return null

maybe it is worth to log it with MAINTAINER target?

I was on the fence about this one b/c I wanted to keep the singleton. It would be useful to get a handle on any exception that happens here. I just discovered Kotlin's Result, so using that instead

should we also check for VariationType.NUMBER here as below?

yes, you're right. The number type that the backend is sending will evolve into sending specifically a float or an integer variant type so it should be usable as either now.

I think this one can be just { s: String -> s }: input and output types are the same, so cast is not needed

👍

we still have the usage of double term in API, should we keep it here? Or is it the change per spec?

These are the types that are sent over the wire. We actually need only one numeric resolution function - the number type is what is required for open feature. We'll treat number, float, and integer as satisfying the "resolveDouble" method. integer type and numeric type will satisfy resolveInteger

Can value be null? If not, it is better to do data class ResolutionDetails<T: Any>

thanks for the tip.

If value is never null, you should make T: Any everywhere like I described here https://github.com/DataDog/dd-sdk-android/pull/2923/files#r2444011674

thanks again

I only see that FLAG_NOT_FOUND, PARSE_ERROR and TYPE_MISMATCH are used in this PR. Will others be used in other PRs or are they not needed?

pruned!

e.g., "TARGETING_MATCH", "DEFAULT", "ERROR"

Is it possible to make this a enum instead of a String?

@Suppress("UNCHECKED_CAST")

this is not needed here

removed

nit

You don't actually need a defaultValue here. You can pass the class itself using KClass.

internal object FlagValueConverter {

    fun <T : Any> convert(variationValue: String, variationType: String, resultType: KClass<T>): T? {
        if (!isTypeCompatible(variationType, resultType)) {
            return null
        }
        return try {
            doConvert(variationValue, resultType)
        } catch (
            @Suppress("TooGenericExceptionCaught", "SwallowedException")
            e: Exception
        ) {
            null
        }
    }

    fun isTypeCompatible(variationType: String, resultType: KClass<*>): Boolean = when (resultType) {
        Boolean::class -> variationType == VariationType.BOOLEAN.value
        String::class -> variationType == VariationType.STRING.value
        Int::class -> variationType == VariationType.INTEGER.value
        Double::class -> variationType == VariationType.NUMBER.value || variationType == VariationType.FLOAT.value
        JSONObject::class -> variationType == VariationType.OBJECT.value
        else -> false
    }
    
    @Suppress("UNCHECKED_CAST")
    private fun <T : Any> doConvert(s: String, resultType: KClass<T>): T? = when (resultType) {
        Boolean::class -> s.lowercase(Locale.US).toBooleanStrictOrNull() as? T
        String::class -> s as? T
        Int::class -> s.toIntOrNull() as? T
        Double::class -> s.toDoubleOrNull() as? T
        JSONObject::class -> JSONObject(s) as? T
        else -> null
    }

    fun getTypeName(type: KClass<*>): String = when (type) {
        Boolean::class -> "Boolean"
        String::class -> "String"
        Int::class -> "Int"
        Double::class -> "Double"
        JSONObject::class -> "JSONObject"
        else -> type.simpleName ?: "Unknown"
    }
}

this is great, thank you