Feature Flags in Android: Ship Faster with Remote Config and Gradual Rollouts

// The interface the rest of the app depends on
interface FeatureFlags {
    fun isEnabled(flag: Flag): Boolean
}

// A closed set: Flag.entries lists every flag, no reflection needed
enum class Flag(
    val key: String,
    val defaultValue: Boolean,
    val owner: String,
    val removeBy: String?  // ISO date, or null for a permanent switch
) {
    NEW_CHECKOUT_FLOW(
        key = "new_checkout_flow",
        defaultValue = false,
        owner = "payments-team",
        removeBy = "2027-01-15"
    ),
    AI_RECOMMENDATIONS(
        key = "ai_recommendations",
        defaultValue = false,
        owner = "ml-team",
        removeBy = "2027-02-01"
    ),
    PAYMENTS_KILL_SWITCH(
        key = "payments_enabled",
        defaultValue = true,
        owner = "payments-team",
        removeBy = null
    ),
}

// A fake for tests
class FakeFeatureFlags(
    private val enabled: Set<Flag> = emptySet()
) : FeatureFlags {
    override fun isEnabled(flag: Flag) = flag in enabled
}

class FirebaseFeatureFlags(
    private val remoteConfig: FirebaseRemoteConfig
) : FeatureFlags {

    // Call once at startup, before the first screen reads a flag.
    fun start() {
        remoteConfig.setDefaultsAsync(
            Flag.entries.associate { it.key to it.defaultValue }
        )
        // Strategy 3: use what the last session fetched...
        remoteConfig.activate()
        // ...and fetch for the next one. Nothing changes mid-session.
        remoteConfig.fetch()
    }

    override fun isEnabled(flag: Flag): Boolean =
        remoteConfig.getBoolean(flag.key)

    // Real-time, for the few flags that cannot wait for a restart.
    fun killSwitch(flag: Flag): Flow<Boolean> = callbackFlow {
        trySend(isEnabled(flag))

        val listener = object : ConfigUpdateListener {
            override fun onUpdate(configUpdate: ConfigUpdate) {
                if (flag.key in configUpdate.updatedKeys) {
                    remoteConfig.activate().addOnCompleteListener {
                        trySend(isEnabled(flag))
                    }
                }
            }

            override fun onError(error: FirebaseRemoteConfigException) {
                close(error)
            }
        }
        val registration = remoteConfig.addOnConfigUpdateListener(listener)

        awaitClose { registration.remove() }
    }
}

@HiltViewModel
class CheckoutViewModel @Inject constructor(
    featureFlags: FeatureFlags
) : ViewModel() {

    // Read once: stable for the life of this screen
    val useNewFlow: Boolean =
        featureFlags.isEnabled(Flag.NEW_CHECKOUT_FLOW)
}

@Composable
fun CheckoutScreen(viewModel: CheckoutViewModel = hiltViewModel()) {
    CheckoutContent(
        useNewFlow = viewModel.useNewFlow,
        onComplete = viewModel::onCheckoutComplete
    )
}

// The stateless composable takes the value, not the flag system
@Composable
fun CheckoutContent(useNewFlow: Boolean, onComplete: () -> Unit) {
    if (useNewFlow) {
        NewCheckoutFlow(onComplete = onComplete)
    } else {
        LegacyCheckoutFlow(onComplete = onComplete)
    }
}

// Debug builds only: local overrides win over the real provider
class DebugFeatureFlags(
    private val real: FeatureFlags,
    initialOverrides: Map<Flag, Boolean> = emptyMap()
) : FeatureFlags {

    private val overrides = MutableStateFlow(initialOverrides)

    override fun isEnabled(flag: Flag): Boolean =
        overrides.value[flag] ?: real.isEnabled(flag)

    fun setOverride(flag: Flag, value: Boolean) {
        overrides.update { it + (flag to value) }
    }

    fun clearOverride(flag: Flag) {
        overrides.update { it - flag }
    }

    fun clearAll() {
        overrides.value = emptyMap()
    }

    // Collect this to persist changes off the main thread
    val changes: StateFlow<Map<Flag, Boolean>> = overrides.asStateFlow()
}

class FlagHygieneTest {

    @Test
    fun `no temporary flag is past its removal date`() {
        val today = LocalDate.now()
        val overdue = Flag.entries.filter { flag ->
            flag.removeBy?.let { LocalDate.parse(it) < today } ?: false
        }

        assertTrue(
            "Overdue flags: " +
                overdue.joinToString { it.key + " (" + it.owner + ")" },
            overdue.isEmpty()
        )
    }
}