storage_manager_example.dart

Go to the documentation of this file.

import 'dart:async';
import 'dart:io';
import 'package:navigine_sdk/navigine_sdk.dart';

class StorageManagerExample {
  NavigineSdk? _sdk;
  StorageManager? _storageManager;
  KeyValueStorage? _userStorage;
  KeyValueStorage? _appStorage;
  KeyValueStorage? _cacheStorage;
 
  StorageManagerExample() {
    _initializeSdk();
    _setupStorages();
  }

  void _initializeSdk() {
    try {
      // [dart_NavigineSdk_getInstance]
      // Get SDK instance
      _sdk = NavigineSdk.getInstance();
      // [dart_NavigineSdk_getInstance]
 
      // [dart_NavigineSdk_setUserHash]
      // Set user hash
      _sdk?.setUserHash("USER-HASH-HERE");
      // [dart_NavigineSdk_setUserHash]
 
      // [dart_NavigineSdk_setServer]
      // Set server URL (optional)
      _sdk?.setServer("https://custom.navigine.com");
      // [dart_NavigineSdk_setServer]
 
      // [dart_NavigineSdk_getStorageManager]
      // Get StorageManager for working with storages
      _storageManager = _sdk?.getStorageManager();
      // [dart_NavigineSdk_getStorageManager]
 
      if (_storageManager != null) {
        print("StorageManager successfully initialized");
      }
    } catch (e) {
      print("Error initializing SDK: $e");
    }
  }

  void _setupStorages() {
    if (_storageManager == null) {
      print("StorageManager not initialized");
      return;
    }
 
    // [dart_StorageManager_getStorage]
    // Get or create different storage instances
    _userStorage = _storageManager!.getStorage("user_preferences");
    _appStorage = _storageManager!.getStorage("app_settings");
    _cacheStorage = _storageManager!.getStorage("cache");
    // [dart_StorageManager_getStorage]
 
    print("Storage instances created");
  }

  void demonstrateStorageManagerMethods() {
    if (_storageManager == null) {
      print("StorageManager not initialized");
      return;
    }
 
    // [dart_StorageManager_getStorageList]
    // Get list of all existing storages
    List<String> storageList = _storageManager!.getStorageList();
    print("Existing storages: $storageList");
    // [dart_StorageManager_getStorageList]
 
    // [dart_StorageManager_getStorage1]
    // Get or create storage by name
    KeyValueStorage testStorage = _storageManager!.getStorage("test_storage");
    print("Created test storage");
    // [dart_StorageManager_getStorage1]
 
    // Demonstrate storage creation and listing
    _storageManager!.getStorage("another_storage");
    List<String> updatedList = _storageManager!.getStorageList();
    print("Updated storage list: $updatedList");
 
    // [dart_StorageManager_removeStorage]
    // Remove storage and all its data
    _storageManager!.removeStorage("test_storage");
    print("Removed test storage");
    // [dart_StorageManager_removeStorage]
 
    List<String> finalList = _storageManager!.getStorageList();
    print("Final storage list: $finalList");
  }

  void demonstrateKeyValueStorageMethods() {
    if (_userStorage == null) {
      print("User storage not initialized");
      return;
    }
 
    print("\n=== KeyValueStorage Methods Demonstration ===");
 
    // [dart_KeyValueStorage_putString]
    // Store string values
    _userStorage!.putString("user_name", "John Doe");
    _userStorage!.putString("user_email", "john.doe@example.com");
    print("Stored string values");
    // [dart_KeyValueStorage_putString]
 
    // [dart_KeyValueStorage_putInt]
    // Store integer values
    _userStorage!.putInt("user_age", 25);
    _userStorage!.putInt("login_count", 42);
    print("Stored integer values");
    // [dart_KeyValueStorage_putInt]
 
    // [dart_KeyValueStorage_putLong]
    // Store long values
    _userStorage!.putLong("registration_timestamp", 1640995200000);
    _userStorage!.putLong(
      "last_login_timestamp",
      DateTime.now().millisecondsSinceEpoch,
    );
    print("Stored long values");
    // [dart_KeyValueStorage_putLong]
 
    // [dart_KeyValueStorage_putBool]
    // Store boolean values
    _userStorage!.putBool("is_premium", true);
    _userStorage!.putBool("notifications_enabled", false);
    print("Stored boolean values");
    // [dart_KeyValueStorage_putBool]
 
    // [dart_KeyValueStorage_putFloat]
    // Store float values
    _userStorage!.putFloat("user_rating", 4.5);
    _userStorage!.putFloat("temperature", 23.5);
    print("Stored float values");
    // [dart_KeyValueStorage_putFloat]
 
    // [dart_KeyValueStorage_putDouble]
    // Store double values
    _userStorage!.putDouble("user_location_lat", 55.7558);
    _userStorage!.putDouble("user_location_lng", 37.6176);
    print("Stored double values");
    // [dart_KeyValueStorage_putDouble]
 
    // [dart_KeyValueStorage_contains]
    // Check if keys exist
    bool hasUserName = _userStorage!.contains("user_name");
    bool hasNonExistent = _userStorage!.contains("non_existent_key");
    print("Contains 'user_name': $hasUserName");
    print("Contains 'non_existent_key': $hasNonExistent");
    // [dart_KeyValueStorage_contains]
 
    // [dart_KeyValueStorage_getKeys]
    // Get all stored keys
    List<String> allKeys = _userStorage!.getKeys();
    print("All stored keys: $allKeys");
    // [dart_KeyValueStorage_getKeys]
 
    // [dart_KeyValueStorage_getString]
    // Retrieve string values with defaults
    String userName = _userStorage!.getString("user_name", "Unknown");
    String userEmail = _userStorage!.getString("user_email", "");
    String nonExistent = _userStorage!.getString(
      "non_existent_key",
      "default_value",
    );
    print("User name: $userName");
    print("User email: $userEmail");
    print("Non-existent key: $nonExistent");
    // [dart_KeyValueStorage_getString]
 
    // [dart_KeyValueStorage_getInt]
    // Retrieve integer values with defaults
    int userAge = _userStorage!.getInt("user_age", 0);
    int loginCount = _userStorage!.getInt("login_count", 0);
    int nonExistentInt = _userStorage!.getInt("non_existent_int", -1);
    print("User age: $userAge");
    print("Login count: $loginCount");
    print("Non-existent int: $nonExistentInt");
    // [dart_KeyValueStorage_getInt]
 
    // [dart_KeyValueStorage_getLong]
    // Retrieve long values with defaults
    long regTimestamp = _userStorage!.getLong("registration_timestamp", 0);
    long lastLogin = _userStorage!.getLong("last_login_timestamp", 0);
    long nonExistentLong = _userStorage!.getLong("non_existent_long", -1);
    print("Registration timestamp: $regTimestamp");
    print("Last login timestamp: $lastLogin");
    print("Non-existent long: $nonExistentLong");
    // [dart_KeyValueStorage_getLong]
 
    // [dart_KeyValueStorage_getBool]
    // Retrieve boolean values with defaults
    bool isPremium = _userStorage!.getBool("is_premium", false);
    bool notificationsEnabled = _userStorage!.getBool(
      "notifications_enabled",
      true,
    );
    bool nonExistentBool = _userStorage!.getBool("non_existent_bool", false);
    print("Is premium: $isPremium");
    print("Notifications enabled: $notificationsEnabled");
    print("Non-existent bool: $nonExistentBool");
    // [dart_KeyValueStorage_getBool]
 
    // [dart_KeyValueStorage_getFloat]
    // Retrieve float values with defaults
    float userRating = _userStorage!.getFloat("user_rating", 0.0);
    float temperature = _userStorage!.getFloat("temperature", 0.0);
    float nonExistentFloat = _userStorage!.getFloat("non_existent_float", -1.0);
    print("User rating: $userRating");
    print("Temperature: $temperature");
    print("Non-existent float: $nonExistentFloat");
    // [dart_KeyValueStorage_getFloat]
 
    // [dart_KeyValueStorage_getDouble]
    // Retrieve double values with defaults
    double userLat = _userStorage!.getDouble("user_location_lat", 0.0);
    double userLng = _userStorage!.getDouble("user_location_lng", 0.0);
    double nonExistentDouble = _userStorage!.getDouble(
      "non_existent_double",
      -1.0,
    );
    print("User location lat: $userLat");
    print("User location lng: $userLng");
    print("Non-existent double: $nonExistentDouble");
    // [dart_KeyValueStorage_getDouble]
 
    // [dart_KeyValueStorage_remove]
    // Remove specific keys
    _userStorage!.remove("user_age");
    _userStorage!.remove("non_existent_key"); // No-op
    print("Removed 'user_age' key");
    // [dart_KeyValueStorage_remove]
 
    // Verify removal
    bool stillHasAge = _userStorage!.contains("user_age");
    print("Still contains 'user_age': $stillHasAge");
 
    // [dart_KeyValueStorage_clear]
    // Clear all data
    _userStorage!.clear();
    print("Cleared all data from user storage");
    // [dart_KeyValueStorage_clear]
 
    // Verify clear
    List<String> keysAfterClear = _userStorage!.getKeys();
    print("Keys after clear: $keysAfterClear");
  }

  void demonstrateMultipleStorages() {
    if (_userStorage == null || _appStorage == null || _cacheStorage == null) {
      print("Storages not initialized");
      return;
    }
 
    print("\n=== Multiple Storages Demonstration ===");
 
    // Store different data in different storages
    _userStorage!.putString("name", "John Doe");
    _userStorage!.putInt("age", 25);
    _userStorage!.putBool("is_premium", true);
 
    _appStorage!.putString("theme", "dark");
    _appStorage!.putInt("api_version", 2);
    _appStorage!.putBool("debug_mode", false);
 
    _cacheStorage!.putLong(
      "last_update",
      DateTime.now().millisecondsSinceEpoch,
    );
    _cacheStorage!.putString("api_token", "abc123");
    _cacheStorage!.putDouble("cached_rating", 4.2);
 
    // Retrieve data from different storages
    print("User storage data:");
    _demonstrateStorageData(_userStorage!);
 
    print("\nApp storage data:");
    _demonstrateStorageData(_appStorage!);
 
    print("\nCache storage data:");
    _demonstrateStorageData(_cacheStorage!);
  }

  void _demonstrateStorageData(KeyValueStorage storage) {
    List<String> keys = storage.getKeys();
    for (String key in keys) {
      if (storage.contains(key)) {
        // Try to get value as string first
        String stringValue = storage.getString(key, "");
        if (stringValue.isNotEmpty) {
          print("  $key: $stringValue (string)");
          continue;
        }
 
        // Try integer
        int intValue = storage.getInt(key, -999999);
        if (intValue != -999999) {
          print("  $key: $intValue (int)");
          continue;
        }
 
        // Try long
        long longValue = storage.getLong(key, -999999);
        if (longValue != -999999) {
          print("  $key: $longValue (long)");
          continue;
        }
 
        // Try boolean
        bool boolValue = storage.getBool(key, false);
        if (storage.contains(key)) {
          print("  $key: $boolValue (bool)");
          continue;
        }
 
        // Try float
        float floatValue = storage.getFloat(key, -999999.0);
        if (floatValue != -999999.0) {
          print("  $key: $floatValue (float)");
          continue;
        }
 
        // Try double
        double doubleValue = storage.getDouble(key, -999999.0);
        if (doubleValue != -999999.0) {
          print("  $key: $doubleValue (double)");
        }
      }
    }
  }

  void demonstrateStorageAnalytics() {
    if (_storageManager == null) {
      print("StorageManager not initialized");
      return;
    }
 
    print("\n=== Storage Analytics ===");
 
    // Analyze all storages
    List<String> allStorages = _storageManager!.getStorageList();
    print("Total storages: ${allStorages.length}");
 
    for (String storageName in allStorages) {
      KeyValueStorage storage = _storageManager!.getStorage(storageName);
      List<String> keys = storage.getKeys();
      print("Storage '$storageName' contains ${keys.length} items");
 
      // Analyze data types
      int stringCount = 0;
      int intCount = 0;
      int longCount = 0;
      int boolCount = 0;
      int floatCount = 0;
      int doubleCount = 0;
 
      for (String key in keys) {
        // Count by trying to get each type
        String stringValue = storage.getString(key, "");
        if (stringValue.isNotEmpty) {
          stringCount++;
          continue;
        }
 
        int intValue = storage.getInt(key, -999999);
        if (intValue != -999999) {
          intCount++;
          continue;
        }
 
        long longValue = storage.getLong(key, -999999);
        if (longValue != -999999) {
          longCount++;
          continue;
        }
 
        bool boolValue = storage.getBool(key, false);
        if (storage.contains(key)) {
          boolCount++;
          continue;
        }
 
        float floatValue = storage.getFloat(key, -999999.0);
        if (floatValue != -999999.0) {
          floatCount++;
          continue;
        }
 
        double doubleValue = storage.getDouble(key, -999999.0);
        if (doubleValue != -999999.0) {
          doubleCount++;
        }
      }
 
      print("  - Strings: $stringCount");
      print("  - Integers: $intCount");
      print("  - Longs: $longCount");
      print("  - Booleans: $boolCount");
      print("  - Floats: $floatCount");
      print("  - Doubles: $doubleCount");
    }
  }

  void demonstrateDataMigration() {
    if (_storageManager == null) {
      print("StorageManager not initialized");
      return;
    }
 
    print("\n=== Data Migration Demonstration ===");
 
    // Create old and new storages
    KeyValueStorage oldStorage = _storageManager!.getStorage("old_storage");
    KeyValueStorage newStorage = _storageManager!.getStorage("new_storage");
 
    // Populate old storage with data
    oldStorage.putString("name", "John Doe");
    oldStorage.putInt("age", 25);
    oldStorage.putBool("is_premium", true);
    oldStorage.putDouble("rating", 4.5);
 
    print("Old storage before migration:");
    _demonstrateStorageData(oldStorage);
 
    // Migrate data from old to new storage
    List<String> keys = oldStorage.getKeys();
    for (String key in keys) {
      // Migrate string data
      String stringValue = oldStorage.getString(key, "");
      if (stringValue.isNotEmpty) {
        newStorage.putString(key, stringValue);
        continue;
      }
 
      // Migrate integer data
      int intValue = oldStorage.getInt(key, -999999);
      if (intValue != -999999) {
        newStorage.putInt(key, intValue);
        continue;
      }
 
      // Migrate long data
      long longValue = oldStorage.getLong(key, -999999);
      if (longValue != -999999) {
        newStorage.putLong(key, longValue);
        continue;
      }
 
      // Migrate boolean data
      bool boolValue = oldStorage.getBool(key, false);
      if (oldStorage.contains(key)) {
        newStorage.putBool(key, boolValue);
        continue;
      }
 
      // Migrate float data
      float floatValue = oldStorage.getFloat(key, -999999.0);
      if (floatValue != -999999.0) {
        newStorage.putFloat(key, floatValue);
        continue;
      }
 
      // Migrate double data
      double doubleValue = oldStorage.getDouble(key, -999999.0);
      if (doubleValue != -999999.0) {
        newStorage.putDouble(key, doubleValue);
      }
    }
 
    print("\nNew storage after migration:");
    _demonstrateStorageData(newStorage);
 
    // Remove old storage
    _storageManager!.removeStorage("old_storage");
    print("\nRemoved old storage");
 
    // Verify migration
    List<String> finalStorages = _storageManager!.getStorageList();
    print("Final storage list: $finalStorages");
  }

  void demonstrateStorageCleanup() {
    if (_storageManager == null) {
      print("StorageManager not initialized");
      return;
    }
 
    print("\n=== Storage Cleanup Demonstration ===");
 
    // Create some temporary storages
    _storageManager!.getStorage("temp_cache_1");
    _storageManager!.getStorage("temp_cache_2");
    _storageManager!.getStorage("permanent_storage");
 
    List<String> beforeCleanup = _storageManager!.getStorageList();
    print("Storages before cleanup: $beforeCleanup");
 
    // Clean up temporary storages
    List<String> storages = _storageManager!.getStorageList();
    for (String storageName in storages) {
      if (storageName.startsWith("temp_")) {
        _storageManager!.removeStorage(storageName);
        print("Removed temporary storage: $storageName");
      }
    }
 
    List<String> afterCleanup = _storageManager!.getStorageList();
    print("Storages after cleanup: $afterCleanup");
  }

  void runAllDemonstrations() {
    print("=== StorageManager and KeyValueStorage Examples ===\n");
 
    demonstrateStorageManagerMethods();
    demonstrateKeyValueStorageMethods();
    demonstrateMultipleStorages();
    demonstrateStorageAnalytics();
    demonstrateDataMigration();
    demonstrateStorageCleanup();
 
    print("\n=== All demonstrations completed ===");
  }

  void cleanup() {
    if (_storageManager != null) {
      // Remove test storages
      List<String> storages = _storageManager!.getStorageList();
      for (String storageName in storages) {
        if (storageName.startsWith("test_") ||
            storageName.startsWith("temp_") ||
            storageName.startsWith("old_") ||
            storageName.startsWith("new_")) {
          _storageManager!.removeStorage(storageName);
        }
      }
    }
  }
}

void main() {
  StorageManagerExample example = StorageManagerExample();
 
  // Run all demonstrations
  example.runAllDemonstrations();
 
  // Cleanup
  example.cleanup();
 
  print("Example completed successfully!");
}