StorageManagerExample.kt

Go to the documentation of this file.

import java.util.*
 
/**
 * StorageManager and KeyValueStorage usage example for Kotlin
 * Demonstrates working with storage management, key-value storage operations, and data persistence
 */
class StorageManagerExample {
    private var sdk: NavigineSdk? = null
    private var storageManager: StorageManager? = null
    private var userStorage: KeyValueStorage? = null
    private var appStorage: KeyValueStorage? = null
    private var cacheStorage: KeyValueStorage? = null
 
    init {
        initializeSdk()
        setupStorages()
    }
 
    /**
     * Initialize SDK and get StorageManager
     */
    private fun initializeSdk() {
        try {
            // [kotlin_NavigineSdk_getInstance]
            // Get SDK instance
            sdk = NavigineSdk.getInstance()
            // [kotlin_NavigineSdk_getInstance]
 
            // [kotlin_NavigineSdk_setUserHash]
            // Set user hash
            sdk?.setUserHash("USER-HASH-HERE")
            // [kotlin_NavigineSdk_setUserHash]
 
            // [kotlin_NavigineSdk_setServer]
            // Set server URL (optional)
            sdk?.setServer("https://custom.navigine.com")
            // [kotlin_NavigineSdk_setServer]
 
            // [kotlin_NavigineSdk_getStorageManager]
            // Get StorageManager for working with storages
            storageManager = sdk?.getStorageManager()
            // [kotlin_NavigineSdk_getStorageManager]
 
            if (storageManager != null) {
                println("StorageManager successfully initialized")
            }
        } catch (e: Exception) {
            println("Error initializing SDK: ${e.message}")
        }
    }
 
    /**
     * Setup different storage instances
     */
    private fun setupStorages() {
        if (storageManager == null) {
            println("StorageManager not initialized")
            return
        }
 
        // [kotlin_StorageManager_getStorage]
        // Get or create different storage instances
        userStorage = storageManager!!.getStorage("user_preferences")
        appStorage = storageManager!!.getStorage("app_settings")
        cacheStorage = storageManager!!.getStorage("cache")
        // [kotlin_StorageManager_getStorage]
 
        println("Storage instances created")
    }
 
    /**
     * Demonstrate StorageManager methods
     */
    fun demonstrateStorageManagerMethods() {
        if (storageManager == null) {
            println("StorageManager not initialized")
            return
        }
 
        // [kotlin_StorageManager_getStorageList]
        // Get list of all existing storages
        val storageList: List<String> = storageManager!!.getStorageList()
        println("Existing storages: $storageList")
        // [kotlin_StorageManager_getStorageList]
 
        // [kotlin_StorageManager_getStorage1]
        // Get or create storage by name
        val testStorage: KeyValueStorage = storageManager!!.getStorage("test_storage")
        println("Created test storage")
        // [kotlin_StorageManager_getStorage1]
 
        // Demonstrate storage creation and listing
        storageManager!!.getStorage("another_storage")
        val updatedList: List<String> = storageManager!!.getStorageList()
        println("Updated storage list: $updatedList")
 
        // [kotlin_StorageManager_removeStorage]
        // Remove storage and all its data
        storageManager!!.removeStorage("test_storage")
        println("Removed test storage")
        // [kotlin_StorageManager_removeStorage]
 
        val finalList: List<String> = storageManager!!.getStorageList()
        println("Final storage list: $finalList")
    }
 
    /**
     * Demonstrate KeyValueStorage methods
     */
    fun demonstrateKeyValueStorageMethods() {
        if (userStorage == null) {
            println("User storage not initialized")
            return
        }
 
        println("\n=== KeyValueStorage Methods Demonstration ===")
 
        // [kotlin_KeyValueStorage_putString]
        // Store string values
        userStorage!!.putString("user_name", "John Doe")
        userStorage!!.putString("user_email", "john.doe@example.com")
        println("Stored string values")
        // [kotlin_KeyValueStorage_putString]
 
        // [kotlin_KeyValueStorage_putInt]
        // Store integer values
        userStorage!!.putInt("user_age", 25)
        userStorage!!.putInt("login_count", 42)
        println("Stored integer values")
        // [kotlin_KeyValueStorage_putInt]
 
        // [kotlin_KeyValueStorage_putLong]
        // Store long values
        userStorage!!.putLong("registration_timestamp", 1640995200000L)
        userStorage!!.putLong("last_login_timestamp", System.currentTimeMillis())
        println("Stored long values")
        // [kotlin_KeyValueStorage_putLong]
 
        // [kotlin_KeyValueStorage_putBool]
        // Store boolean values
        userStorage!!.putBool("is_premium", true)
        userStorage!!.putBool("notifications_enabled", false)
        println("Stored boolean values")
        // [kotlin_KeyValueStorage_putBool]
 
        // [kotlin_KeyValueStorage_putFloat]
        // Store float values
        userStorage!!.putFloat("user_rating", 4.5f)
        userStorage!!.putFloat("temperature", 23.5f)
        println("Stored float values")
        // [kotlin_KeyValueStorage_putFloat]
 
        // [kotlin_KeyValueStorage_putDouble]
        // Store double values
        userStorage!!.putDouble("user_location_lat", 55.7558)
        userStorage!!.putDouble("user_location_lng", 37.6176)
        println("Stored double values")
        // [kotlin_KeyValueStorage_putDouble]
 
        // [kotlin_KeyValueStorage_contains]
        // Check if keys exist
        val hasUserName: Boolean = userStorage!!.contains("user_name")
        val hasNonExistent: Boolean = userStorage!!.contains("non_existent_key")
        println("Contains 'user_name': $hasUserName")
        println("Contains 'non_existent_key': $hasNonExistent")
        // [kotlin_KeyValueStorage_contains]
 
        // [kotlin_KeyValueStorage_getKeys]
        // Get all stored keys
        val allKeys: List<String> = userStorage!!.getKeys()
        println("All stored keys: $allKeys")
        // [kotlin_KeyValueStorage_getKeys]
 
        // [kotlin_KeyValueStorage_getString]
        // Retrieve string values with defaults
        val userName: String = userStorage!!.getString("user_name", "Unknown")
        val userEmail: String = userStorage!!.getString("user_email", "")
        val nonExistent: String = userStorage!!.getString("non_existent_key", "default_value")
        println("User name: $userName")
        println("User email: $userEmail")
        println("Non-existent key: $nonExistent")
        // [kotlin_KeyValueStorage_getString]
 
        // [kotlin_KeyValueStorage_getInt]
        // Retrieve integer values with defaults
        val userAge: Int = userStorage!!.getInt("user_age", 0)
        val loginCount: Int = userStorage!!.getInt("login_count", 0)
        val nonExistentInt: Int = userStorage!!.getInt("non_existent_int", -1)
        println("User age: $userAge")
        println("Login count: $loginCount")
        println("Non-existent int: $nonExistentInt")
        // [kotlin_KeyValueStorage_getInt]
 
        // [kotlin_KeyValueStorage_getLong]
        // Retrieve long values with defaults
        val regTimestamp: Long = userStorage!!.getLong("registration_timestamp", 0)
        val lastLogin: Long = userStorage!!.getLong("last_login_timestamp", 0)
        val nonExistentLong: Long = userStorage!!.getLong("non_existent_long", -1)
        println("Registration timestamp: $regTimestamp")
        println("Last login timestamp: $lastLogin")
        println("Non-existent long: $nonExistentLong")
        // [kotlin_KeyValueStorage_getLong]
 
        // [kotlin_KeyValueStorage_getBool]
        // Retrieve boolean values with defaults
        val isPremium: Boolean = userStorage!!.getBool("is_premium", false)
        val notificationsEnabled: Boolean = userStorage!!.getBool("notifications_enabled", true)
        val nonExistentBool: Boolean = userStorage!!.getBool("non_existent_bool", false)
        println("Is premium: $isPremium")
        println("Notifications enabled: $notificationsEnabled")
        println("Non-existent bool: $nonExistentBool")
        // [kotlin_KeyValueStorage_getBool]
 
        // [kotlin_KeyValueStorage_getFloat]
        // Retrieve float values with defaults
        val userRating: Float = userStorage!!.getFloat("user_rating", 0.0f)
        val temperature: Float = userStorage!!.getFloat("temperature", 0.0f)
        val nonExistentFloat: Float = userStorage!!.getFloat("non_existent_float", -1.0f)
        println("User rating: $userRating")
        println("Temperature: $temperature")
        println("Non-existent float: $nonExistentFloat")
        // [kotlin_KeyValueStorage_getFloat]
 
        // [kotlin_KeyValueStorage_getDouble]
        // Retrieve double values with defaults
        val userLat: Double = userStorage!!.getDouble("user_location_lat", 0.0)
        val userLng: Double = userStorage!!.getDouble("user_location_lng", 0.0)
        val nonExistentDouble: Double = userStorage!!.getDouble("non_existent_double", -1.0)
        println("User location lat: $userLat")
        println("User location lng: $userLng")
        println("Non-existent double: $nonExistentDouble")
        // [kotlin_KeyValueStorage_getDouble]
 
        // [kotlin_KeyValueStorage_remove]
        // Remove specific keys
        userStorage!!.remove("user_age")
        userStorage!!.remove("non_existent_key") // No-op
        println("Removed 'user_age' key")
        // [kotlin_KeyValueStorage_remove]
 
        // Verify removal
        val stillHasAge: Boolean = userStorage!!.contains("user_age")
        println("Still contains 'user_age': $stillHasAge")
 
        // [kotlin_KeyValueStorage_clear]
        // Clear all data
        userStorage!!.clear()
        println("Cleared all data from user storage")
        // [kotlin_KeyValueStorage_clear]
 
        // Verify clear
        val keysAfterClear: List<String> = userStorage!!.getKeys()
        println("Keys after clear: $keysAfterClear")
    }
 
    /**
     * Demonstrate multiple storages
     */
    fun demonstrateMultipleStorages() {
        if (userStorage == null || appStorage == null || cacheStorage == null) {
            println("Storages not initialized")
            return
        }
 
        println("\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", System.currentTimeMillis())
        cacheStorage!!.putString("api_token", "abc123")
        cacheStorage!!.putDouble("cached_rating", 4.2)
 
        // Retrieve data from different storages
        println("User storage data:")
        demonstrateStorageData(userStorage!!)
 
        println("\nApp storage data:")
        demonstrateStorageData(appStorage!!)
 
        println("\nCache storage data:")
        demonstrateStorageData(cacheStorage!!)
    }
 
    /**
     * Demonstrate storage data
     */
    private fun demonstrateStorageData(storage: KeyValueStorage) {
        val keys: List<String> = storage.getKeys()
        for (key in keys) {
            if (storage.contains(key)) {
                // Try to get value as string first
                val stringValue: String = storage.getString(key, "")
                if (stringValue.isNotEmpty()) {
                    println("  $key: $stringValue (string)")
                    continue
                }
 
                // Try integer
                val intValue: Int = storage.getInt(key, -999999)
                if (intValue != -999999) {
                    println("  $key: $intValue (int)")
                    continue
                }
 
                // Try long
                val longValue: Long = storage.getLong(key, -999999)
                if (longValue != -999999) {
                    println("  $key: $longValue (long)")
                    continue
                }
 
                // Try boolean
                val boolValue: Boolean = storage.getBool(key, false)
                if (storage.contains(key)) {
                    println("  $key: $boolValue (bool)")
                    continue
                }
 
                // Try float
                val floatValue: Float = storage.getFloat(key, -999999.0f)
                if (floatValue != -999999.0f) {
                    println("  $key: $floatValue (float)")
                    continue
                }
 
                // Try double
                val doubleValue: Double = storage.getDouble(key, -999999.0)
                if (doubleValue != -999999.0) {
                    println("  $key: $doubleValue (double)")
                }
            }
        }
    }
 
    /**
     * Demonstrate storage analytics
     */
    fun demonstrateStorageAnalytics() {
        if (storageManager == null) {
            println("StorageManager not initialized")
            return
        }
 
        println("\n=== Storage Analytics ===")
 
        // Analyze all storages
        val allStorages: List<String> = storageManager!!.getStorageList()
        println("Total storages: ${allStorages.size}")
 
        for (storageName in allStorages) {
            val storage: KeyValueStorage = storageManager!!.getStorage(storageName)
            val keys: List<String> = storage.getKeys()
            println("Storage '$storageName' contains ${keys.size} items")
 
            // Analyze data types
            var stringCount = 0
            var intCount = 0
            var longCount = 0
            var boolCount = 0
            var floatCount = 0
            var doubleCount = 0
 
            for (key in keys) {
                // Count by trying to get each type
                val stringValue: String = storage.getString(key, "")
                if (stringValue.isNotEmpty()) {
                    stringCount++
                    continue
                }
 
                val intValue: Int = storage.getInt(key, -999999)
                if (intValue != -999999) {
                    intCount++
                    continue
                }
 
                val longValue: Long = storage.getLong(key, -999999)
                if (longValue != -999999) {
                    longCount++
                    continue
                }
 
                val boolValue: Boolean = storage.getBool(key, false)
                if (storage.contains(key)) {
                    boolCount++
                    continue
                }
 
                val floatValue: Float = storage.getFloat(key, -999999.0f)
                if (floatValue != -999999.0f) {
                    floatCount++
                    continue
                }
 
                val doubleValue: Double = storage.getDouble(key, -999999.0)
                if (doubleValue != -999999.0) {
                    doubleCount++
                }
            }
 
            println("  - Strings: $stringCount")
            println("  - Integers: $intCount")
            println("  - Longs: $longCount")
            println("  - Booleans: $boolCount")
            println("  - Floats: $floatCount")
            println("  - Doubles: $doubleCount")
        }
    }
 
    /**
     * Demonstrate data migration
     */
    fun demonstrateDataMigration() {
        if (storageManager == null) {
            println("StorageManager not initialized")
            return
        }
 
        println("\n=== Data Migration Demonstration ===")
 
        // Create old and new storages
        val oldStorage: KeyValueStorage = storageManager!!.getStorage("old_storage")
        val newStorage: KeyValueStorage = 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)
 
        println("Old storage before migration:")
        demonstrateStorageData(oldStorage)
 
        // Migrate data from old to new storage
        val keys: List<String> = oldStorage.getKeys()
        for (key in keys) {
            // Migrate string data
            val stringValue: String = oldStorage.getString(key, "")
            if (stringValue.isNotEmpty()) {
                newStorage.putString(key, stringValue)
                continue
            }
 
            // Migrate integer data
            val intValue: Int = oldStorage.getInt(key, -999999)
            if (intValue != -999999) {
                newStorage.putInt(key, intValue)
                continue
            }
 
            // Migrate long data
            val longValue: Long = oldStorage.getLong(key, -999999)
            if (longValue != -999999) {
                newStorage.putLong(key, longValue)
                continue
            }
 
            // Migrate boolean data
            val boolValue: Boolean = oldStorage.getBool(key, false)
            if (oldStorage.contains(key)) {
                newStorage.putBool(key, boolValue)
                continue
            }
 
            // Migrate float data
            val floatValue: Float = oldStorage.getFloat(key, -999999.0f)
            if (floatValue != -999999.0f) {
                newStorage.putFloat(key, floatValue)
                continue
            }
 
            // Migrate double data
            val doubleValue: Double = oldStorage.getDouble(key, -999999.0)
            if (doubleValue != -999999.0) {
                newStorage.putDouble(key, doubleValue)
            }
        }
 
        println("\nNew storage after migration:")
        demonstrateStorageData(newStorage)
 
        // Remove old storage
        storageManager!!.removeStorage("old_storage")
        println("\nRemoved old storage")
 
        // Verify migration
        val finalStorages: List<String> = storageManager!!.getStorageList()
        println("Final storage list: $finalStorages")
    }
 
    /**
     * Demonstrate storage cleanup
     */
    fun demonstrateStorageCleanup() {
        if (storageManager == null) {
            println("StorageManager not initialized")
            return
        }
 
        println("\n=== Storage Cleanup Demonstration ===")
 
        // Create some temporary storages
        storageManager!!.getStorage("temp_cache_1")
        storageManager!!.getStorage("temp_cache_2")
        storageManager!!.getStorage("permanent_storage")
 
        val beforeCleanup: List<String> = storageManager!!.getStorageList()
        println("Storages before cleanup: $beforeCleanup")
 
        // Clean up temporary storages
        val storages: List<String> = storageManager!!.getStorageList()
        for (storageName in storages) {
            if (storageName.startsWith("temp_")) {
                storageManager!!.removeStorage(storageName)
                println("Removed temporary storage: $storageName")
            }
        }
 
        val afterCleanup: List<String> = storageManager!!.getStorageList()
        println("Storages after cleanup: $afterCleanup")
    }
 
    /**
     * Run all demonstrations
     */
    fun runAllDemonstrations() {
        println("=== StorageManager and KeyValueStorage Examples ===\n")
 
        demonstrateStorageManagerMethods()
        demonstrateKeyValueStorageMethods()
        demonstrateMultipleStorages()
        demonstrateStorageAnalytics()
        demonstrateDataMigration()
        demonstrateStorageCleanup()
 
        println("\n=== All demonstrations completed ===")
    }
 
    /**
     * Cleanup resources
     */
    fun cleanup() {
        if (storageManager != null) {
            // Remove test storages
            val storages: List<String> = storageManager!!.getStorageList()
            for (storageName in storages) {
                if (storageName.startsWith("test_") ||
                    storageName.startsWith("temp_") ||
                    storageName.startsWith("old_") ||
                    storageName.startsWith("new_")) {
                    storageManager!!.removeStorage(storageName)
                }
            }
        }
    }
}
 
/**
 * Main function to run the example
 */
fun main() {
    val example = StorageManagerExample()
    
    // Run all demonstrations
    example.runAllDemonstrations()
    
    // Cleanup
    example.cleanup()
    
    println("Example completed successfully!")
}