Caching integration settings and restoring last successful cache

packages/core/lib/analytics.dart

@@ -353,18 +353,37 @@ class Analytics with ClientMethods {
   }
 
   Future _fetchSettings() async {
+    // Try to fetch settings from network
     final settings =
         await httpClient.settingsFor(state.configuration.state.writeKey);
-    if (settings == null) {
-      log("""Could not receive settings from Segment. ${state.configuration.state.defaultIntegrationSettings != null ? 'Will use the default settings.' : 'Device mode destinations will be ignored unless you specify default settings in the client config.'}""",
-          kind: LogFilterKind.warning);
 
-      state.integrations.state =
-          state.configuration.state.defaultIntegrationSettings ?? {};
-    } else {
+    if (settings != null) {
+      // Priority 1: Newly fetched settings from network
       final integrations = settings.integrations;
-      log("Received settings from Segment succesfully.");
+      log("Received settings from Segment successfully.");
       state.integrations.state = integrations;
+      return;
+    }
+
+    // Network fetch failed, check for cached settings
+    final cachedSettings = await state.integrations.loadCachedSettings();
+
+    if (cachedSettings.isNotEmpty) {
+      // Priority 2: Use cached settings if available
+      log("Could not receive settings from Segment. Using cached settings.",
+          kind: LogFilterKind.warning);
+      // No need to set state.integrations.state as loadCachedSettings already updated it
+    } else if (state.configuration.state.defaultIntegrationSettings != null) {
+      // Priority 3: Fall back to default settings if no cache
+      log("Could not receive settings from Segment. Using default settings.",
+          kind: LogFilterKind.warning);
+      state.integrations.state =
+          state.configuration.state.defaultIntegrationSettings!;
+    } else {
+      // Priority 4: Last resort - empty map
+      log("Could not receive settings from Segment. Device mode destinations will not be used unless you specify default settings in the client config.",
+          kind: LogFilterKind.warning);
+      state.integrations.state = {};
     }
   }
 

packages/core/lib/state.dart

@@ -33,18 +33,19 @@ class StateManager {
     deepLinkData.init(errorHandler, storageJson);
     userInfo.init(errorHandler, storageJson);
     context.init(errorHandler, storageJson);
+    integrations.init(errorHandler, storageJson);
   }
 
   StateManager(Store store, System system, Configuration configuration)
       : system = SystemState(system),
         configuration = ConfigurationState(configuration),
-        integrations = IntegrationsState({}),
+        integrations = IntegrationsState(store),
         filters = FiltersState(store),
         deepLinkData = DeepLinkDataState(store),
         userInfo = UserInfoState(store),
         context = ContextState(store, configuration) {
     _ready = Future.wait<void>(
-            [filters.ready, deepLinkData.ready, userInfo.ready, context.ready])
+            [filters.ready, deepLinkData.ready, userInfo.ready, context.ready, integrations.ready])
         .then((_) => _isReady = true);
   }
 }
@@ -500,19 +501,50 @@ class TransformerConfigMap {
 }
 
 class IntegrationsState extends StateNotifier<Map<String, dynamic>> {
-  IntegrationsState(super.integrations);
+  final Store _store;
+  final String _key = "integrations";
+  Map<String, dynamic>? _cachedState;
+
+  IntegrationsState(this._store) : super({});
 
   @override
   Map<String, dynamic> get state => super.state;
 
   @override
-  set state(Map<String, dynamic> state) => super.state = state;
+  set state(Map<String, dynamic> newState) {
+    super.state = newState;
+    // Persist to store when state is updated
+    _store.setPersisted(_key, newState);
+  }
 
   void addIntegration(String key, Map<String, dynamic> settings) {
     final integrations = state;
     integrations[key] = settings;
     state = integrations;
   }
+
+  // Load cached settings from store
+  Future<Map<String, dynamic>> loadCachedSettings() async {
+    if (_cachedState != null) {
+      return _cachedState!;
+    }
+
+    final cachedSettings = await _store.getPersisted(_key);
+    if (cachedSettings != null) {
+      _cachedState = cachedSettings;
+      // Update in-memory state with cached settings
+      super.state = cachedSettings;
+      return cachedSettings;
+    }
+
+    return {};
+  }
+
+  // For compatibility with the ready mechanism
+  Future<void> get ready => Future.value();
+  void init(ErrorHandler errorHandler, bool storageJson) {
+    loadCachedSettings();
+  }
 }
 
 class ConfigurationState extends StateNotifier<Configuration> {

packages/core/test/analytics_test.dart

@@ -14,6 +14,7 @@ import 'package:shared_preferences/shared_preferences.dart';
 
 import 'mocks/mocks.dart';
 import 'mocks/mocks.mocks.dart';
+import 'mocks/mock_store.dart';
 
 void main() {
   WidgetsFlutterBinding.ensureInitialized();
@@ -137,6 +138,125 @@ void main() {
               );
       expect(analytics, isA<Analytics>());
     });
+
+    group("Integration Settings Persistence", () {
+      test("settings loading and fallback behavior", () async {
+        // Setup
+        final testSettings = {"test_integration": {"setting1": "value1"}};
+        final defaultSettings = {"default_integration": {"enabled": true}};
+        AnalyticsPlatform.instance = MockPlatform();
+        LogFactory.logger = Mocks.logTarget();
+        SharedPreferences.setMockInitialValues({});
+
+        // Test Case 1: First initialization with successful network fetch
+        // ---------------------------------------------------------------
+        // Create an in-memory store for testing
+        final mockStore1 = InMemoryStore(storageJson: true);
+
+        final httpClient1 = Mocks.httpClient();
+        when(httpClient1.settingsFor(any))
+            .thenAnswer((_) => Future.value(SegmentAPISettings(testSettings)));
+
+        // Initialize analytics
+        final analytics1 = Analytics(
+          Configuration("test_key"),
+          mockStore1,
+          httpClient: (_) => httpClient1,
+        );
+        await analytics1.init();
+
+        // Verify network settings are used
+        final stateSettings1 = await analytics1.state.integrations.state;
+        expect(stateSettings1, equals(testSettings),
+            reason: "Should use settings from network");
+
+        // Test Case 2: Network failure with default settings
+        // --------------------------------------------------
+        // Create an in-memory store for testing
+        final mockStore2 = InMemoryStore(storageJson: true);
+
+        final failingHttpClient = Mocks.httpClient();
+        when(failingHttpClient.settingsFor(any))
+            .thenAnswer((_) => Future.value(null));
+
+        // Initialize analytics with default settings
+        final analytics2 = Analytics(
+          Configuration("test_key",
+            defaultIntegrationSettings: defaultSettings
+          ),
+          mockStore2,
+          httpClient: (_) => failingHttpClient,
+        );
+        await analytics2.init();
+
+        // Verify default settings are used
+        final stateSettings2 = await analytics2.state.integrations.state;
+        expect(stateSettings2, equals(defaultSettings),
+            reason: "Should fall back to default settings when network fails");
+
+        // Test Case 3: Loading cached settings and refreshing from network
+        // ---------------------------------------------------------------
+        // Create an in-memory store with cached settings
+        final cachedSettings = {"cached_integration": {"setting1": "cached"}};
+        final mockStore3 = InMemoryStore(storageJson: true);
+
+        // Seed the store with cached settings
+        await mockStore3.setPersisted("integrations", cachedSettings);
+
+        // Create HTTP client that returns new settings
+        final newNetworkSettings = {"network_integration": {"setting1": "new"}};
+        final httpClient3 = Mocks.httpClient();
+        when(httpClient3.settingsFor(any))
+            .thenAnswer((_) => Future.value(SegmentAPISettings(newNetworkSettings)));
+
+        // Initialize analytics
+        final analytics3 = Analytics(
+          Configuration("test_key"),
+          mockStore3,
+          httpClient: (_) => httpClient3,
+        );
+
+        // Before initialization, state would be empty
+        expect(analytics3.state.integrations.hasListeners, isFalse);
+
+        // Initialize analytics
+        await analytics3.init();
+
+        // After initialization with cached settings + network fetch, we should have the network settings
+        final stateSettings3 = await analytics3.state.integrations.state;
+        expect(stateSettings3, equals(newNetworkSettings),
+            reason: "Should update cached settings with network settings");
+
+        // Test Case 4: Network failure with cached settings
+        // ------------------------------------------------
+        // Create an in-memory store with cached settings
+        final cachedSettings2 = {"cached_integration2": {"setting1": "cached2"}};
+        final mockStore4 = InMemoryStore(storageJson: true);
+
+        // Seed the store with cached settings
+        await mockStore4.setPersisted("integrations", cachedSettings2);
+
+        // Create failing HTTP client
+        final httpClient4 = Mocks.httpClient();
+        when(httpClient4.settingsFor(any))
+            .thenAnswer((_) => Future.value(null));
+
+        // Initialize analytics with default settings
+        final analytics4 = Analytics(
+          Configuration("test_key",
+            defaultIntegrationSettings: defaultSettings
+          ),
+          mockStore4,
+          httpClient: (_) => httpClient4,
+        );
+        await analytics4.init();
+
+        // After initialization with network failure, we should have cached settings
+        final stateSettings4 = await analytics4.state.integrations.state;
+        expect(stateSettings4, equals(cachedSettings2),
+            reason: "Should use cached settings when network fails, even with default settings");
+      });
+    });
   });
 }
 

packages/core/test/cached_settings_test.dart

@@ -0,0 +1,140 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/mockito.dart';
+import 'package:segment_analytics/analytics.dart';
+import 'package:segment_analytics/state.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:flutter/widgets.dart';
+import 'package:segment_analytics/analytics_platform_interface.dart';
+import 'package:segment_analytics/logger.dart';
+
+import 'mocks/mocks.dart';
+import 'mocks/mocks.mocks.dart';
+import 'mocks/mock_store.dart';
+
+// Test that verifies the priority order of settings:
+// 1. Network settings
+// 2. Cached settings
+// 3. Default settings
+// 4. Empty map
+void main() {
+  WidgetsFlutterBinding.ensureInitialized();
+
+  group("Integration Settings Priority Test", () {
+    test("Settings priority order: network > cache > default > empty", () async {
+      // Setup
+      final networkSettings = {"network_integration": {"setting1": "network_value"}};
+      final cachedSettings = {"cached_integration": {"setting1": "cached_value"}};
+      final defaultSettings = {"default_integration": {"setting1": "default_value"}};
+
+      AnalyticsPlatform.instance = MockPlatform();
+      LogFactory.logger = Mocks.logTarget();
+      SharedPreferences.setMockInitialValues({});
+
+      // Test Case 1: First Initialization with Network Success
+      // ---------------------------------------------------------------
+      // Create an in-memory store with no cached settings
+      final mockStore1 = InMemoryStore(storageJson: true);
+
+      // Note: settings will be stored directly in the InMemoryStore
+
+      // Create HTTP client that returns network settings
+      final httpClient1 = Mocks.httpClient();
+      when(httpClient1.settingsFor(any))
+          .thenAnswer((_) => Future.value(SegmentAPISettings(networkSettings)));
+
+      // Initialize analytics
+      final analytics1 = Analytics(
+        Configuration("test_key",
+          defaultIntegrationSettings: defaultSettings
+        ),
+        mockStore1,
+        httpClient: (_) => httpClient1,
+      );
+      await analytics1.init();
+
+      // Verify network settings are used in this session
+      final stateSettings1 = analytics1.state.integrations.state;
+      expect(stateSettings1, equals(networkSettings),
+          reason: "Should use settings from network on first run");
+
+      // Verify settings were persisted to storage
+      final storedSettings = await mockStore1.getPersisted("integrations");
+      expect(storedSettings, equals(networkSettings),
+          reason: "Network settings should be stored to cache");
+
+      // Test Case 2: Network Failure with Cached Settings
+      // ---------------------------------------------------------------
+      // Create an in-memory store with cached settings
+      final mockStore2 = InMemoryStore(storageJson: true);
+
+      // Seed the store with cached settings
+      await mockStore2.setPersisted("integrations", networkSettings);
+
+      // Create HTTP client that fails
+      final failingHttpClient = Mocks.httpClient();
+      when(failingHttpClient.settingsFor(any))
+          .thenAnswer((_) => Future.value(null));
+
+      // Initialize analytics
+      final analytics2 = Analytics(
+        Configuration("test_key",
+          defaultIntegrationSettings: defaultSettings
+        ),
+        mockStore2,
+        httpClient: (_) => failingHttpClient,
+      );
+      await analytics2.init();
+
+      // Verify cached settings are used when network fails
+      final stateSettings2 = analytics2.state.integrations.state;
+      expect(stateSettings2, equals(networkSettings),
+          reason: "Should use cached settings when network fails");
+
+      // Test Case 3: No Network, No Cache - Uses Default Settings
+      // ---------------------------------------------------------------
+      final mockStore3 = InMemoryStore(storageJson: true);
+
+      // No need to add any cached settings as the store starts empty
+
+      final failingHttpClient2 = Mocks.httpClient();
+      when(failingHttpClient2.settingsFor(any))
+          .thenAnswer((_) => Future.value(null));
+
+      final analytics3 = Analytics(
+        Configuration("test_key",
+          defaultIntegrationSettings: defaultSettings
+        ),
+        mockStore3,
+        httpClient: (_) => failingHttpClient2,
+      );
+      await analytics3.init();
+
+      // Verify default settings are used when no network and no cache
+      final stateSettings3 = analytics3.state.integrations.state;
+      expect(stateSettings3, equals(defaultSettings),
+          reason: "Should use default settings when network fails and no cache");
+
+      // Test Case 4: No Network, No Cache, No Default - Uses Empty Map
+      // ---------------------------------------------------------------
+      final mockStore4 = InMemoryStore(storageJson: true);
+
+      // No need to add any cached settings as the store starts empty
+
+      final failingHttpClient3 = Mocks.httpClient();
+      when(failingHttpClient3.settingsFor(any))
+          .thenAnswer((_) => Future.value(null));
+
+      final analytics4 = Analytics(
+        Configuration("test_key"), // No default settings
+        mockStore4,
+        httpClient: (_) => failingHttpClient3,
+      );
+      await analytics4.init();
+
+      // Verify empty map is used as last resort
+      final stateSettings4 = analytics4.state.integrations.state;
+      expect(stateSettings4, equals({}),
+          reason: "Should use empty map when all else fails");
+    });
+  });
+}