Initial implementation of the flag caching and defaults

.gitignore

@@ -15,3 +15,4 @@ build
 local.properties
 
 .idea
+FlagsmithClient/cache

FlagsmithClient/build.gradle.kts

@@ -68,12 +68,17 @@ android {
 
 dependencies {
     implementation("com.google.code.gson:gson:2.10")
-    implementation("com.github.kittinunf.fuel:fuel:2.3.1")
-    implementation("com.github.kittinunf.fuel:fuel-gson:2.3.1")
+
+    // HTTP Client
+    implementation("com.squareup.retrofit2:retrofit:2.9.0")
+    implementation("com.squareup.retrofit2:converter-gson:2.9.0")
 
     testImplementation("junit:junit:4.13.2")
     testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.4")
     testImplementation("org.mock-server:mockserver-netty-no-dependencies:5.14.0")
+
+    testImplementation("org.awaitility:awaitility-kotlin:4.2.0")
+    testImplementation("org.mockito.kotlin:mockito-kotlin:5.0.0")
 }
 
 kover {

FlagsmithClient/src/main/java/com/flagsmith/Flagsmith.kt

@@ -1,15 +1,10 @@
 package com.flagsmith
 
 import android.content.Context
-import com.flagsmith.endpoints.FlagsEndpoint
-import com.flagsmith.endpoints.IdentityFlagsAndTraitsEndpoint
-import com.flagsmith.endpoints.TraitsEndpoint
-import com.flagsmith.entities.Flag
-import com.flagsmith.entities.IdentityFlagsAndTraits
-import com.flagsmith.entities.Trait
-import com.flagsmith.entities.TraitWithIdentity
+import com.flagsmith.entities.*
 import com.flagsmith.internal.FlagsmithAnalytics
-import com.flagsmith.internal.FlagsmithClient
+import com.flagsmith.internal.FlagsmithRetrofitService
+import com.flagsmith.internal.enqueueWithResult
 
 /**
  * Flagsmith
@@ -28,26 +23,39 @@ class Flagsmith constructor(
     private val baseUrl: String = "https://edge.api.flagsmith.com/api/v1",
     private val context: Context? = null,
     private val enableAnalytics: Boolean = DEFAULT_ENABLE_ANALYTICS,
-    private val analyticsFlushPeriod: Int = DEFAULT_ANALYTICS_FLUSH_PERIOD_SECONDS
+    private val analyticsFlushPeriod: Int = DEFAULT_ANALYTICS_FLUSH_PERIOD_SECONDS,
+    private val cacheConfig: FlagsmithCacheConfig = FlagsmithCacheConfig(),
+    private val defaultFlags: List<Flag> = emptyList(),
+    private val requestTimeoutSeconds: Long = 4L,
+    private val readTimeoutSeconds: Long = 6L,
+    private val writeTimeoutSeconds: Long = 6L
 ) {
-    private val client: FlagsmithClient = FlagsmithClient(baseUrl, environmentKey)
+    private val retrofit: FlagsmithRetrofitService = FlagsmithRetrofitService.create(
+        baseUrl = baseUrl, environmentKey = environmentKey, context = context, cacheConfig = cacheConfig,
+        requestTimeoutSeconds = requestTimeoutSeconds, readTimeoutSeconds = readTimeoutSeconds, writeTimeoutSeconds = writeTimeoutSeconds)
     private val analytics: FlagsmithAnalytics? =
         if (!enableAnalytics) null
-        else if (context != null) FlagsmithAnalytics(context, client, analyticsFlushPeriod)
+        else if (context != null) FlagsmithAnalytics(context, retrofit, analyticsFlushPeriod)
         else throw IllegalArgumentException("Flagsmith requires a context to use the analytics feature")
 
+    init {
+        if (cacheConfig.enableCache && context == null) {
+            throw IllegalArgumentException("Flagsmith requires a context to use the cache feature")
+        }
+    }
+
     companion object {
         const val DEFAULT_ENABLE_ANALYTICS = true
         const val DEFAULT_ANALYTICS_FLUSH_PERIOD_SECONDS = 10
     }
 
     fun getFeatureFlags(identity: String? = null, result: (Result<List<Flag>>) -> Unit) {
         if (identity != null) {
-            getIdentityFlagsAndTraits(identity) { res ->
+            retrofit.getIdentityFlagsAndTraits(identity).enqueueWithResult { res ->
                 result(res.map { it.flags })
             }
         } else {
-            client.request(FlagsEndpoint, result)
+            retrofit.getFlags().enqueueWithResult(defaults = defaultFlags, result = result)
         }
     }
 
@@ -68,20 +76,20 @@ class Flagsmith constructor(
     }
 
     fun getTrait(id: String, identity: String, result: (Result<Trait?>) -> Unit) =
-        getIdentityFlagsAndTraits(identity) { res ->
+        retrofit.getIdentityFlagsAndTraits(identity).enqueueWithResult { res ->
             result(res.map { value -> value.traits.find { it.key == id } })
         }
 
     fun getTraits(identity: String, result: (Result<List<Trait>>) -> Unit) =
-        getIdentityFlagsAndTraits(identity) { res ->
+        retrofit.getIdentityFlagsAndTraits(identity).enqueueWithResult { res ->
             result(res.map { it.traits })
         }
 
     fun setTrait(trait: Trait, identity: String, result: (Result<TraitWithIdentity>) -> Unit) =
-        client.request(TraitsEndpoint(trait = trait, identity = identity), result)
+        retrofit.postTraits(TraitWithIdentity(trait.key, trait.value, Identity(identity))).enqueueWithResult(result = result)
 
     fun getIdentity(identity: String, result: (Result<IdentityFlagsAndTraits>) -> Unit) =
-        getIdentityFlagsAndTraits(identity, result)
+        retrofit.getIdentityFlagsAndTraits(identity).enqueueWithResult(defaults = null, result = result)
 
     private fun getFeatureFlag(
         featureId: String,
@@ -95,8 +103,4 @@ class Flagsmith constructor(
         })
     }
 
-    private fun getIdentityFlagsAndTraits(
-        identity: String,
-        result: (Result<IdentityFlagsAndTraits>) -> Unit
-    ) = client.request(IdentityFlagsAndTraitsEndpoint(identity = identity), result)
 }

FlagsmithClient/src/main/java/com/flagsmith/FlagsmithCacheConfig.kt

@@ -0,0 +1,7 @@
+package com.flagsmith
+
+data class FlagsmithCacheConfig (
+        val enableCache: Boolean = false,
+        val cacheTTLSeconds: Long = 3600L, // Default to 1 hour
+        val cacheSize: Long = 10L * 1024L * 1024L, // 10 MB
+)

FlagsmithClient/src/main/java/com/flagsmith/entities/Flag.kt

@@ -1,17 +1,6 @@
 package com.flagsmith.entities
 
-import com.flagsmith.internal.Deserializer
-import com.flagsmith.internal.fromJson
 import com.google.gson.annotations.SerializedName
-import com.google.gson.reflect.TypeToken
-import java.io.Reader
-
-class FlagListDeserializer: Deserializer<List<Flag>> {
-    override fun deserialize(reader: Reader): List<Flag>? {
-        val type = object : TypeToken<ArrayList<Flag>>() {}.type
-        return reader.fromJson<ArrayList<Flag>?>(type = type)
-    }
-}
 
 data class Flag(
     val feature: Feature,
@@ -27,4 +16,4 @@ data class Feature(
     @SerializedName(value = "initial_value") val initialValue: String,
     @SerializedName(value = "default_enabled") val defaultEnabled: Boolean,
     val type: String
-)
+)

FlagsmithClient/src/main/java/com/flagsmith/entities/IdentityFlagsAndTraits.kt

@@ -1,14 +1,5 @@
 package com.flagsmith.entities
 
-import com.flagsmith.internal.Deserializer
-import com.flagsmith.internal.fromJson
-import java.io.Reader
-
-class IdentityFlagsAndTraitsDeserializer: Deserializer<IdentityFlagsAndTraits> {
-    override fun deserialize(reader: Reader): IdentityFlagsAndTraits? =
-        reader.fromJson(IdentityFlagsAndTraits::class.java)
-}
-
 data class IdentityFlagsAndTraits(
     val flags: ArrayList<Flag>,
     val traits: ArrayList<Trait>

FlagsmithClient/src/main/java/com/flagsmith/entities/Trait.kt

@@ -1,15 +1,9 @@
 package com.flagsmith.entities
 
-import com.flagsmith.internal.Deserializer
-import com.flagsmith.internal.fromJson
+
 import com.google.gson.annotations.SerializedName
 import java.io.Reader
 
-class TraitWithIdentityDeserializer: Deserializer<TraitWithIdentity> {
-    override fun deserialize(reader: Reader): TraitWithIdentity? =
-        reader.fromJson(TraitWithIdentity::class.java)
-}
-
 data class Trait(
     val identifier: String? = null,
     @SerializedName(value = "trait_key") val key: String,

FlagsmithClient/src/main/java/com/flagsmith/internal/FlagsmithAnalytics.kt

@@ -5,13 +5,12 @@ import android.content.SharedPreferences
 import android.os.Handler
 import android.os.Looper
 import android.util.Log
-import com.flagsmith.endpoints.AnalyticsEndpoint
 import org.json.JSONException
 import org.json.JSONObject
 
 class FlagsmithAnalytics constructor(
     private val context: Context,
-    private val client: FlagsmithClient,
+    private val retrofitService: FlagsmithRetrofitService,
     private val flushPeriod: Int
 ) {
     private val applicationContext: Context = context.applicationContext
@@ -21,9 +20,8 @@ class FlagsmithAnalytics constructor(
     private val timerRunnable = object : Runnable {
         override fun run() {
             if (currentEvents.isNotEmpty()) {
-                client.request(AnalyticsEndpoint(eventMap = currentEvents)) {
-                    it
-                        .onSuccess { resetMap() }
+                retrofitService.postAnalytics(currentEvents).enqueueWithResult { result ->
+                    result.onSuccess { resetMap() }
                         .onFailure { err ->
                             Log.e(
                                 "FLAGSMITH",

FlagsmithClient/src/main/java/com/flagsmith/internal/FlagsmithRetrofitService.kt

@@ -0,0 +1,104 @@
+package com.flagsmith.internal;
+
+import android.content.Context
+import android.util.Log
+import com.flagsmith.FlagsmithCacheConfig
+import com.flagsmith.entities.Flag
+import com.flagsmith.entities.IdentityFlagsAndTraits
+import com.flagsmith.entities.TraitWithIdentity
+import okhttp3.Interceptor
+import okhttp3.OkHttpClient
+import retrofit2.*
+import retrofit2.converter.gson.GsonConverterFactory
+import retrofit2.http.Body
+import retrofit2.http.GET
+import retrofit2.http.POST
+import retrofit2.http.Query
+
+interface FlagsmithRetrofitService {
+
+    @GET("identities/")
+    fun getIdentityFlagsAndTraits(@Query("identity") identity: String) : Call<IdentityFlagsAndTraits>
+
+    @GET("flags/")
+    fun getFlags() : Call<List<Flag>>
+
+    @POST("traits/")
+    fun postTraits(@Body trait: TraitWithIdentity) : Call<TraitWithIdentity>
+
+    @POST("analytics/flags/")
+    fun postAnalytics(@Body eventMap: Map<String, Int?>) : Call<Unit>
+
+    companion object {
+        fun create(
+            baseUrl: String,
+            environmentKey: String,
+            context: Context?,
+            cacheConfig: FlagsmithCacheConfig,
+            requestTimeoutSeconds: Long,
+            readTimeoutSeconds: Long,
+            writeTimeoutSeconds: Long,
+        ): FlagsmithRetrofitService {
+            fun cacheControlInterceptor(): Interceptor {
+                return Interceptor { chain ->
+                    val response = chain.proceed(chain.request())
+                    response.newBuilder()
+                        .header("Cache-Control", "public, max-age=${cacheConfig.cacheTTLSeconds}")
+                        .removeHeader("Pragma")
+                        .build()
+                }
+            }
+
+            fun envKeyInterceptor(environmentKey: String): Interceptor {
+                return Interceptor { chain ->
+                    val request = chain.request().newBuilder()
+                        .addHeader("X-environment-key", environmentKey)
+                        .build()
+                    chain.proceed(request)
+                }
+            }
+
+            val client = OkHttpClient.Builder()
+                .addInterceptor(envKeyInterceptor(environmentKey))
+                .let { if (cacheConfig.enableCache) it.addNetworkInterceptor(cacheControlInterceptor()) else it }
+                .callTimeout(requestTimeoutSeconds, java.util.concurrent.TimeUnit.SECONDS)
+                .readTimeout(readTimeoutSeconds, java.util.concurrent.TimeUnit.SECONDS)
+                .writeTimeout(writeTimeoutSeconds, java.util.concurrent.TimeUnit.SECONDS)
+                .cache(if (context != null && cacheConfig.enableCache) okhttp3.Cache(context.cacheDir, cacheConfig.cacheSize) else null)
+                .build()
+
+            val retrofit = Retrofit.Builder()
+                .baseUrl(baseUrl)
+                .addConverterFactory(GsonConverterFactory.create())
+                .client(client)
+                .build()
+
+            return retrofit.create(FlagsmithRetrofitService::class.java)
+        }
+    }
+}
+
+// Convert a Retrofit Call to a standard Kotlin Result by extending the Call class
+// This avoids having to use the suspend keyword in the FlagsmithClient to break the API
+// And also avoids a lot of code duplication
+fun <T> Call<T>.enqueueWithResult(defaults: T? = null, result: (Result<T>) -> Unit) {
+    this.enqueue(object : Callback<T> {
+        override fun onResponse(call: Call<T>, response: Response<T>) {
+            if (response.isSuccessful && response.body() != null) {
+                result(Result.success(response.body()!!))
+            } else {
+                onFailure(call, HttpException(response))
+            }
+        }
+
+        override fun onFailure(call: Call<T>, t: Throwable) {
+            // If we've got defaults to return, return them
+            if (defaults != null) {
+                result(Result.success(defaults))
+            } else {
+                result(Result.failure(t))
+            }
+        }
+    })
+}
+