chore: support native default value and listen for update

Author: bradly0cjw

lib/repositories/feature_flag_providers.dart

@@ -10,7 +10,12 @@ final featureFlagsProvider =
 class FeatureFlagsNotifier extends AsyncNotifier<List<FeatureFlag>> {
   @override
   Future<List<FeatureFlag>> build() async {
-    return ref.watch(featureFlagRepositoryProvider).getAllFlags();
+    final repo = ref.watch(featureFlagRepositoryProvider);
+    // Listen for real-time updates from Remote Config/Repository
+    final subscription = repo.onUpdated.listen((_) => ref.invalidateSelf());
+    ref.onDispose(subscription.cancel);
+
+    return repo.getAllFlags();
   }
 
   Future<void> refreshFlags() async {

lib/repositories/feature_flag_repository.dart

@@ -61,6 +61,7 @@ final featureFlagRepositoryProvider = Provider<FeatureFlagRepository>((ref) {
 class FeatureFlagRepository {
   final FeatureFlagService _service;
   final SharedPreferencesAsync _prefs;
+  final _updateController = StreamController<void>.broadcast();
   Map<String, FeatureFlagData>? _defaultsCache;
   List<FeatureFlag>? _flagsCache;
 
@@ -70,6 +71,9 @@ class FeatureFlagRepository {
   }) : _service = service,
        _prefs = prefs;
 
+  /// A stream that emits whenever feature flags are updated from a remote source.
+  Stream<void> get onUpdated => _updateController.stream;
+
   Future<Map<String, FeatureFlagData>> _getDefaults({
     bool forceRefresh = false,
   }) async {
@@ -79,6 +83,28 @@ class FeatureFlagRepository {
 
   /// Initializes the repository by warming up the cache.
   Future<void> init() async {
+    // Initialize Remote Config with local defaults
+    try {
+      final localJson = await _service.loadLocalJson();
+      await firebaseService.init(defaults: {'feature_flags': localJson});
+
+      // Listen for remote updates
+      firebaseService.onConfigUpdated.listen((_) {
+        log(
+          'Remote Config updated, invalidating feature flag cache',
+          name: 'FeatureFlagRepository',
+        );
+        _defaultsCache = null;
+        _flagsCache = null;
+        _updateController.add(null);
+      });
+    } catch (e) {
+      log(
+        'Failed to initialize Remote Config defaults: $e',
+        name: 'FeatureFlagRepository',
+      );
+    }
+
     await getAllFlags();
     log('FeatureFlagRepository initialized', name: 'FeatureFlagRepository');
   }

lib/services/feature_flag/feature_flag_service.dart

@@ -13,8 +13,12 @@ final featureFlagServiceProvider = Provider<FeatureFlagService>((ref) {
 /// Service for fetching default feature flags from the local JSON config.
 /// Extended with Firebase Remote Config to allow remote overrides.
 class FeatureFlagService {
+  Future<String> loadLocalJson() async {
+    return await rootBundle.loadString('assets/feature_flags.json');
+  }
+
   Future<Map<String, FeatureFlagData>> fetchDefaultFlags() async {
-    final jsonString = await rootBundle.loadString('assets/feature_flags.json');
+    final jsonString = await loadLocalJson();
     final localDefaults = jsonDecode(jsonString) as Map<String, dynamic>;
 
     final result = firebaseService.getRemoteConfigString('feature_flags');

lib/services/firebase_service.dart

@@ -1,6 +1,7 @@
 import 'package:firebase_analytics/firebase_analytics.dart';
 import 'package:firebase_crashlytics/firebase_crashlytics.dart';
 import 'package:firebase_remote_config/firebase_remote_config.dart';
+import 'dart:async';
 import 'dart:developer' as dev;
 
 /// Global toggle for Firebase features.
@@ -25,8 +26,14 @@ var firebaseService = const FirebaseService();
 /// firebase.crashlytics?.recordError(e, stack);
 /// ```
 class FirebaseService {
+  static final _updateController = StreamController<void>.broadcast();
+  static bool _isInitialized = false;
+
   const FirebaseService();
 
+  /// A stream that emits whenever the Remote Config is updated and activated.
+  Stream<void> get onConfigUpdated => _updateController.stream;
+
   /// The [FirebaseAnalytics] instance, or `null` if Firebase is disabled.
   FirebaseAnalytics? get analytics =>
       useFirebase ? FirebaseAnalytics.instance : null;
@@ -64,15 +71,44 @@ class FirebaseService {
   /// Initializes Firebase Remote Config.
   ///
   /// Call this at app start to fetch and activate the latest configuration.
-  Future<void> init() async {
+  /// Optionally provide [defaults] for in-app default values.
+  Future<void> init({Map<String, dynamic>? defaults}) async {
     final rc = remoteConfig;
     if (rc == null) return;
 
+    if (_isInitialized) {
+      if (defaults != null) await setDefaults(defaults);
+      return;
+    }
+
+    if (defaults != null) {
+      await rc.setDefaults(defaults);
+    }
+
+    _setupUpdateListener(rc);
+
     await _fetchAndActivate(
       rc,
       context: 'initialized',
       setupSettings: true,
     );
+    _isInitialized = true;
+  }
+
+  /// Updates the in-app default values for Remote Config.
+  Future<void> setDefaults(Map<String, dynamic> defaults) async {
+    await remoteConfig?.setDefaults(defaults);
+  }
+
+  void _setupUpdateListener(FirebaseRemoteConfig rc) {
+    rc.onConfigUpdated.listen((event) async {
+      dev.log(
+        'Remote Config updated: ${event.updatedKeys}',
+        name: 'FirebaseService',
+      );
+      await rc.activate();
+      _updateController.add(null);
+    });
   }
 
   /// Forces a fresh fetch and activation of Remote Config.