FFs can now be toggled in release builds too (#3101)

- Removed `StaticFeatureFlagProvider`.
- Always provide `PreferencesFeatureFlagProvider`.
- For the default values of feature flags, use a lambda with a `BuildMeta` parameter so we can customize the return value based on its data.

libraries/featureflag/impl/src/main/kotlin/io/element/android/libraries/featureflag/impl/DefaultFeatureFlagService.kt

@@ -17,6 +17,7 @@
 package io.element.android.libraries.featureflag.impl
 
 import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.libraries.core.meta.BuildMeta
 import io.element.android.libraries.di.AppScope
 import io.element.android.libraries.di.SingleIn
 import io.element.android.libraries.featureflag.api.Feature
@@ -28,14 +29,15 @@ import javax.inject.Inject
 @ContributesBinding(AppScope::class)
 @SingleIn(AppScope::class)
 class DefaultFeatureFlagService @Inject constructor(
-    private val providers: Set<@JvmSuppressWildcards FeatureFlagProvider>
+    private val providers: Set<@JvmSuppressWildcards FeatureFlagProvider>,
+    private val buildMeta: BuildMeta,
 ) : FeatureFlagService {
     override fun isFeatureEnabledFlow(feature: Feature): Flow<Boolean> {
         return providers.filter { it.hasFeature(feature) }
             .sortedByDescending(FeatureFlagProvider::priority)
             .firstOrNull()
             ?.isFeatureEnabledFlow(feature)
-            ?: flowOf(feature.defaultValue)
+            ?: flowOf(feature.defaultValue(buildMeta))
     }
 
     override suspend fun setFeatureEnabled(feature: Feature, enabled: Boolean): Boolean {

libraries/featureflag/impl/src/main/kotlin/io/element/android/libraries/featureflag/impl/PreferencesFeatureFlagProvider.kt

@@ -22,6 +22,7 @@ import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.booleanPreferencesKey
 import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.preferencesDataStore
+import io.element.android.libraries.core.meta.BuildMeta
 import io.element.android.libraries.di.ApplicationContext
 import io.element.android.libraries.featureflag.api.Feature
 import kotlinx.coroutines.flow.Flow
@@ -34,7 +35,10 @@ private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(na
 /**
  * Note: this will be used only in the nightly and in the debug build.
  */
-class PreferencesFeatureFlagProvider @Inject constructor(@ApplicationContext context: Context) : MutableFeatureFlagProvider {
+class PreferencesFeatureFlagProvider @Inject constructor(
+    @ApplicationContext context: Context,
+    private val buildMeta: BuildMeta,
+) : MutableFeatureFlagProvider {
     private val store = context.dataStore
 
     override val priority = MEDIUM_PRIORITY
@@ -47,7 +51,7 @@ class PreferencesFeatureFlagProvider @Inject constructor(@ApplicationContext con
 
     override fun isFeatureEnabledFlow(feature: Feature): Flow<Boolean> {
         return store.data.map { prefs ->
-            prefs[booleanPreferencesKey(feature.key)] ?: feature.defaultValue
+            prefs[booleanPreferencesKey(feature.key)] ?: feature.defaultValue(buildMeta)
         }.distinctUntilChanged()
     }
 

libraries/featureflag/impl/src/main/kotlin/io/element/android/libraries/featureflag/impl/StaticFeatureFlagProvider.kt

@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2023 New Vector Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.element.android.libraries.featureflag.impl
-
-import io.element.android.appconfig.OnBoardingConfig
-import io.element.android.libraries.featureflag.api.Feature
-import io.element.android.libraries.featureflag.api.FeatureFlags
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flowOf
-import javax.inject.Inject
-
-/**
- * This provider is used for release build.
- * This is the place to enable or disable feature for the release build.
- */
-class StaticFeatureFlagProvider @Inject constructor() :
-    FeatureFlagProvider {
-    override val priority = LOW_PRIORITY
-
-    override fun isFeatureEnabledFlow(feature: Feature): Flow<Boolean> {
-        val isFeatureEnabled = if (feature is FeatureFlags) {
-            when (feature) {
-                FeatureFlags.LocationSharing -> true
-                FeatureFlags.Polls -> true
-                FeatureFlags.NotificationSettings -> true
-                FeatureFlags.VoiceMessages -> true
-                FeatureFlags.PinUnlock -> true
-                FeatureFlags.Mentions -> true
-                FeatureFlags.MarkAsUnread -> true
-                FeatureFlags.RoomDirectorySearch -> false
-                FeatureFlags.ShowBlockedUsersDetails -> false
-                FeatureFlags.QrCodeLogin -> OnBoardingConfig.CAN_LOGIN_WITH_QR_CODE
-                FeatureFlags.IncomingShare -> true
-            }
-        } else {
-            false
-        }
-        return flowOf(isFeatureEnabled)
-    }
-
-    override fun hasFeature(feature: Feature) = true
-}

libraries/featureflag/impl/src/main/kotlin/io/element/android/libraries/featureflag/impl/di/FeatureFlagModule.kt

@@ -20,11 +20,9 @@ import com.squareup.anvil.annotations.ContributesTo
 import dagger.Module
 import dagger.Provides
 import dagger.multibindings.ElementsIntoSet
-import io.element.android.libraries.core.meta.BuildType
 import io.element.android.libraries.di.AppScope
 import io.element.android.libraries.featureflag.impl.FeatureFlagProvider
 import io.element.android.libraries.featureflag.impl.PreferencesFeatureFlagProvider
-import io.element.android.libraries.featureflag.impl.StaticFeatureFlagProvider
 
 @Module
 @ContributesTo(AppScope::class)
@@ -33,20 +31,10 @@ object FeatureFlagModule {
     @Provides
     @ElementsIntoSet
     fun providesFeatureFlagProvider(
-        buildType: BuildType,
         mutableFeatureFlagProvider: PreferencesFeatureFlagProvider,
-        staticFeatureFlagProvider: StaticFeatureFlagProvider,
     ): Set<FeatureFlagProvider> {
-        val providers = HashSet<FeatureFlagProvider>()
-        when (buildType) {
-            BuildType.RELEASE -> {
-                providers.add(staticFeatureFlagProvider)
-            }
-            BuildType.NIGHTLY,
-            BuildType.DEBUG -> {
-                providers.add(mutableFeatureFlagProvider)
-            }
+        return buildSet {
+            add(mutableFeatureFlagProvider)
         }
-        return providers
     }
 }

libraries/featureflag/impl/src/test/kotlin/io/element/android/libraries/featureflag/impl/DefaultFeatureFlagServiceTest.kt

@@ -19,38 +19,42 @@ package io.element.android.libraries.featureflag.impl
 import app.cash.turbine.test
 import com.google.common.truth.Truth.assertThat
 import io.element.android.libraries.featureflag.api.FeatureFlags
+import io.element.android.libraries.matrix.test.core.aBuildMeta
 import kotlinx.coroutines.test.runTest
 import org.junit.Test
 
 class DefaultFeatureFlagServiceTest {
     @Test
     fun `given service without provider when feature is checked then it returns the default value`() = runTest {
-        val featureFlagService = DefaultFeatureFlagService(emptySet())
+        val buildMeta = aBuildMeta()
+        val featureFlagService = DefaultFeatureFlagService(emptySet(), buildMeta)
         featureFlagService.isFeatureEnabledFlow(FeatureFlags.LocationSharing).test {
-            assertThat(awaitItem()).isEqualTo(FeatureFlags.LocationSharing.defaultValue)
+            assertThat(awaitItem()).isEqualTo(FeatureFlags.LocationSharing.defaultValue(buildMeta))
             cancelAndIgnoreRemainingEvents()
         }
     }
 
     @Test
     fun `given service without provider when set enabled feature is called then it returns false`() = runTest {
-        val featureFlagService = DefaultFeatureFlagService(emptySet())
+        val featureFlagService = DefaultFeatureFlagService(emptySet(), aBuildMeta())
         val result = featureFlagService.setFeatureEnabled(FeatureFlags.LocationSharing, true)
         assertThat(result).isFalse()
     }
 
     @Test
     fun `given service with a runtime provider when set enabled feature is called then it returns true`() = runTest {
-        val featureFlagProvider = FakeMutableFeatureFlagProvider(0)
-        val featureFlagService = DefaultFeatureFlagService(setOf(featureFlagProvider))
+        val buildMeta = aBuildMeta()
+        val featureFlagProvider = FakeMutableFeatureFlagProvider(0, buildMeta)
+        val featureFlagService = DefaultFeatureFlagService(setOf(featureFlagProvider), buildMeta)
         val result = featureFlagService.setFeatureEnabled(FeatureFlags.LocationSharing, true)
         assertThat(result).isTrue()
     }
 
     @Test
     fun `given service with a runtime provider and feature enabled when feature is checked then it returns the correct value`() = runTest {
-        val featureFlagProvider = FakeMutableFeatureFlagProvider(0)
-        val featureFlagService = DefaultFeatureFlagService(setOf(featureFlagProvider))
+        val buildMeta = aBuildMeta()
+        val featureFlagProvider = FakeMutableFeatureFlagProvider(0, buildMeta)
+        val featureFlagService = DefaultFeatureFlagService(setOf(featureFlagProvider), buildMeta)
         featureFlagService.setFeatureEnabled(FeatureFlags.LocationSharing, true)
         featureFlagService.isFeatureEnabledFlow(FeatureFlags.LocationSharing).test {
             assertThat(awaitItem()).isTrue()
@@ -61,9 +65,10 @@ class DefaultFeatureFlagServiceTest {
 
     @Test
     fun `given service with 2 runtime providers when feature is checked then it uses the priority correctly`() = runTest {
-        val lowPriorityFeatureFlagProvider = FakeMutableFeatureFlagProvider(LOW_PRIORITY)
-        val highPriorityFeatureFlagProvider = FakeMutableFeatureFlagProvider(HIGH_PRIORITY)
-        val featureFlagService = DefaultFeatureFlagService(setOf(lowPriorityFeatureFlagProvider, highPriorityFeatureFlagProvider))
+        val buildMeta = aBuildMeta()
+        val lowPriorityFeatureFlagProvider = FakeMutableFeatureFlagProvider(LOW_PRIORITY, buildMeta)
+        val highPriorityFeatureFlagProvider = FakeMutableFeatureFlagProvider(HIGH_PRIORITY, buildMeta)
+        val featureFlagService = DefaultFeatureFlagService(setOf(lowPriorityFeatureFlagProvider, highPriorityFeatureFlagProvider), buildMeta)
         lowPriorityFeatureFlagProvider.setFeatureEnabled(FeatureFlags.LocationSharing, false)
         highPriorityFeatureFlagProvider.setFeatureEnabled(FeatureFlags.LocationSharing, true)
         featureFlagService.isFeatureEnabledFlow(FeatureFlags.LocationSharing).test {

libraries/featureflag/impl/src/test/kotlin/io/element/android/libraries/featureflag/impl/FakeMutableFeatureFlagProvider.kt

@@ -16,11 +16,15 @@
 
 package io.element.android.libraries.featureflag.impl
 
+import io.element.android.libraries.core.meta.BuildMeta
 import io.element.android.libraries.featureflag.api.Feature
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 
-class FakeMutableFeatureFlagProvider(override val priority: Int) : MutableFeatureFlagProvider {
+class FakeMutableFeatureFlagProvider(
+    override val priority: Int,
+    private val buildMeta: BuildMeta,
+) : MutableFeatureFlagProvider {
     private val enabledFeatures = mutableMapOf<String, MutableStateFlow<Boolean>>()
 
     override suspend fun setFeatureEnabled(feature: Feature, enabled: Boolean) {
@@ -29,7 +33,7 @@ class FakeMutableFeatureFlagProvider(override val priority: Int) : MutableFeatur
     }
 
     override fun isFeatureEnabledFlow(feature: Feature): Flow<Boolean> {
-        return enabledFeatures.getOrPut(feature.key) { MutableStateFlow(feature.defaultValue) }
+        return enabledFeatures.getOrPut(feature.key) { MutableStateFlow(feature.defaultValue(buildMeta)) }
     }
 
     override fun hasFeature(feature: Feature): Boolean = true