- Added support for multiple StoreX instances with different storage supports

rommansabbir · rommansabbir · commit f2bce070cf56 · 2021-12-12T12:49:49.000+06:00
- Added support for custom Coroutine Scopes
- Documentation updated
diff --git a/README.md b/README.md
@@ -40,22 +40,49 @@ dependencies {
 
 | Latest Releases
 | ------------- |
-| 1.0.0         |
+| 1.2.0         |
 
 ---
 
+### What's new in this version?
+- Multiple instance of StoreX with differnet configuration & storage
+- Added support for custom Coroutine Scopes
+
 ## Initialize
 ````
-StoreXCore.init(application: Application, prefName: String)
+// Create multiple identifers
+object StoreXIdentifiers {
+    val mainConfig : StoreXConfig = StoreXConfig("Something_1", "main_pref")
+    val anotherConfig : StoreXConfig = StoreXConfig("Something_2", "secondary_pref")
+}
+````
+
+````
+// Deprecated. Will be removed in the future version
+StoreXCore.init(this, getString(R.string.app_name))
+
+// New method
+StoreXCore.init(this, mutableListOf(
+    StoreXIdentifiers.mainConfig,
+    StoreXIdentifiers.mainConfig,
+))
 ````
 
 ## How To Access
 ````
+// Deprecated. Will be removed in the future version
 StoreXCore.instance()
+
+// New method
+StoreXCore.instance(configs: StoreXConfig)
 ````
 or else, use the extension function
 ````
+// Deprecated. Will be removed in the future version
 storeXInstance()
+
+// New method
+fun storeXInstance(config: StoreXConfig)
 ````
 which return an instance of `StoreX` [Note:  You must initalize `StoreX` properly before accessing or else it will throw `NotInitializedException`]
 
@@ -104,7 +131,7 @@ First setup an callback for the data changes
         }
     }
 ````
-Create a new sunscriber.
+Create a new subscriber.
 
 Create a new subscriber by providing the `Key`, `Observer ID (Must be unique)` and the `Callback`
 
diff --git a/StoreX/src/main/java/com/rommansabbir/storex/Extension.kt b/StoreX/src/main/java/com/rommansabbir/storex/Extension.kt
@@ -1,7 +1,10 @@
 package com.rommansabbir.storex
 
+@Deprecated("Use new method StoreXCore.instance(config: StoreXConfig) to get specific instance", ReplaceWith("StoreXCore.instance(config: StoreXConfig)"))
 fun storeXInstance(): StoreX = StoreXCore.instance()
 
+fun storeXInstance(config: StoreXConfig): StoreX = StoreXCore.instance(config)
+
 internal fun Subscriber.getKey(): String {
     return "${this.key}_${this.subscriberID}"
 }
diff --git a/StoreX/src/main/java/com/rommansabbir/storex/StoreX.kt b/StoreX/src/main/java/com/rommansabbir/storex/StoreX.kt
@@ -2,18 +2,26 @@ package com.rommansabbir.storex
 
 import com.rommansabbir.storex.callbacks.GetCallback
 import com.rommansabbir.storex.callbacks.SaveCallback
+import kotlinx.coroutines.CoroutineScope
 
 interface StoreX {
     @Throws(RuntimeException::class)
     fun put(key: String, value: StoreAbleObject): Boolean
 
+    @Throws(RuntimeException::class)
+    fun put(scope : CoroutineScope, key: String, value: StoreAbleObject)
+
     fun <T : StoreAbleObject> put(key: String, value: StoreAbleObject, callback: SaveCallback<T>)
 
+    fun <T : StoreAbleObject> put(scope : CoroutineScope,key: String, value: StoreAbleObject, callback: SaveCallback<T>)
+
     @Throws(RuntimeException::class)
     fun <T : StoreAbleObject> get(key: String, objectType: Class<T>): T
 
     fun <T : StoreAbleObject> get(key: String, objectType: Class<T>, callback: GetCallback<T>)
 
+    fun <T : StoreAbleObject> get(scope : CoroutineScope,key: String, objectType: Class<T>, callback: GetCallback<T>)
+
     @Throws(RuntimeException::class)
     fun addSubscriber(subscriber: Subscriber)
 
diff --git a/StoreX/src/main/java/com/rommansabbir/storex/StoreXConfig.kt b/StoreX/src/main/java/com/rommansabbir/storex/StoreXConfig.kt
@@ -0,0 +1,10 @@
+package com.rommansabbir.storex
+
+/**
+ * Represent the configuration for [StoreX].
+ * uId must be an unique identifier.
+ *
+ * @param uId, Unique identifier for the config
+ * @param prefName, SharedPref name for the config
+ */
+data class StoreXConfig(val uId : String, val prefName : String)
diff --git a/StoreX/src/main/java/com/rommansabbir/storex/StoreXCore.kt b/StoreX/src/main/java/com/rommansabbir/storex/StoreXCore.kt
@@ -2,13 +2,26 @@ package com.rommansabbir.storex
 
 import android.app.Application
 import com.google.gson.Gson
+import com.rommansabbir.storex.execptions.DuplicateStoreXConfigException
 import com.rommansabbir.storex.execptions.InvalidEncryptionKeyException
+import com.rommansabbir.storex.execptions.NoConfigFoundException
 import com.rommansabbir.storex.execptions.NotInitializedException
 
 object StoreXCore {
     private var isInitialized: Boolean = false
     private var instance: StoreXInstance? = null
 
+    private var instanceStates: HashMap<String, StoreXState> = HashMap()
+
+    /**
+     * When you go crazy and want to delete all the cache, call this method.
+     */
+    fun clearAllStates() {
+        instanceStates.clear()
+    }
+
+    @Deprecated("Use new method StoreXCore.instance(config: StoreXConfig) to get specific instance",
+        ReplaceWith("StoreXCore.instance(config: StoreXConfig)"))
     @Throws(RuntimeException::class)
     fun instance(): StoreX {
         if (isInitialized) {
@@ -18,6 +31,33 @@ object StoreXCore {
         }
     }
 
+    @Throws(RuntimeException::class)
+    fun instance(configs: StoreXConfig): StoreX {
+        if (isInitialized) {
+            instanceStates[configs.uId]?.let {
+                return it.storeXInstance
+            } ?: run {
+                throw NoConfigFoundException()
+            }
+        } else {
+            throw NotInitializedException()
+        }
+    }
+
+    @Throws(RuntimeException::class)
+    fun init(application: Application, configs: MutableList<StoreXConfig>) {
+        val gson = Gson()
+        configs.forEach {
+            if (instanceStates[it.uId] != null) {
+                throw DuplicateStoreXConfigException()
+            }
+            instanceStates[it.uId] = StoreXState(StoreXInstance(application, it.prefName, gson), it)
+        }
+        this.isInitialized = true
+    }
+
+    @Deprecated("Use new method StoreXCore.init(application: Application, configs: MutableList<StoreXConfig>) initialize properly",
+        ReplaceWith("StoreXCore.init(application: Application, configs: MutableList<StoreXConfig>)"))
     fun init(application: Application, prefName: String): StoreXCore {
         this.instance = StoreXInstance(application, prefName, Gson())
         this.instance!!.registerListener(this.instance!!.listener)
diff --git a/StoreX/src/main/java/com/rommansabbir/storex/StoreXInstance.kt b/StoreX/src/main/java/com/rommansabbir/storex/StoreXInstance.kt
@@ -13,6 +13,7 @@ import com.rommansabbir.storex.execptions.NoStoreAbleObjectFound
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 
 
 internal class StoreXInstance(
@@ -47,24 +48,75 @@ internal class StoreXInstance(
         }
     }
 
+    override fun put(scope: CoroutineScope, key: String, value: StoreAbleObject) {
+        scope.launch {
+            try {
+                val serializedValue: String = serializer.toJson(value)
+                if (StoreXCore.encryptionKey == StoreXCore.NO_ENCRYPTION) {
+                    doCache(key, serializedValue)
+                } else {
+                    val encryptedValue = EncryptionTool.encrypt(serializedValue)
+                    doCache(key, encryptedValue)
+                }
+            } catch (e: Exception) {
+                throw e
+            }
+        }
+    }
+
     override fun <T : StoreAbleObject> put(
         key: String,
         value: StoreAbleObject,
         callback: SaveCallback<T>
     ) {
-        CoroutineScope(Dispatchers.Main).launch {
+        CoroutineScope(Dispatchers.IO).launch {
             try {
                 val serializedValue: String = serializer.toJson(value)
                 if (StoreXCore.encryptionKey == StoreXCore.NO_ENCRYPTION) {
                     doCache(key, serializedValue)
-                    callback.onDone(value as T, null)
+                    withContext(Dispatchers.Main){
+                        callback.onDone(value as T, null)
+                    }
                 } else {
                     val encryptedValue = EncryptionTool.encrypt(serializedValue)
                     doCache(key, encryptedValue)
-                    callback.onDone(value as T, null)
+                    withContext(Dispatchers.Main){
+                        callback.onDone(value as T, null)
+                    }
                 }
             } catch (e: Exception) {
-                callback.onDone(value as T, e)
+                withContext(Dispatchers.Main){
+                    callback.onDone(value as T, e)
+                }
+            }
+        }
+    }
+
+    override fun <T : StoreAbleObject> put(
+        scope: CoroutineScope,
+        key: String,
+        value: StoreAbleObject,
+        callback: SaveCallback<T>,
+    ) {
+        scope.launch {
+            try {
+                val serializedValue: String = serializer.toJson(value)
+                if (StoreXCore.encryptionKey == StoreXCore.NO_ENCRYPTION) {
+                    doCache(key, serializedValue)
+                    withContext(Dispatchers.Main){
+                        callback.onDone(value as T, null)
+                    }
+                } else {
+                    val encryptedValue = EncryptionTool.encrypt(serializedValue)
+                    doCache(key, encryptedValue)
+                    withContext(Dispatchers.Main){
+                        callback.onDone(value as T, null)
+                    }
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main){
+                    callback.onDone(value as T, e)
+                }
             }
         }
     }
@@ -99,26 +151,72 @@ internal class StoreXInstance(
         objectType: Class<T>,
         callback: GetCallback<T>
     ) {
-        CoroutineScope(Dispatchers.Main).launch {
+        CoroutineScope(Dispatchers.IO).launch {
             try {
                 when (val value = getCache(key)) {
                     null -> {
-                        callback.onSuccess(null, NoStoreAbleObjectFound())
+                        withContext(Dispatchers.Main){
+                            callback.onSuccess(null, NoStoreAbleObjectFound())
+                        }
                     }
                     else -> {
                         when (StoreXCore.encryptionKey == StoreXCore.NO_ENCRYPTION) {
                             true -> {
-                                callback.onSuccess(serializer.fromJson(value, objectType))
+                                withContext(Dispatchers.Main){
+                                    callback.onSuccess(serializer.fromJson(value, objectType))
+                                }
                             }
                             else -> {
                                 val decryptedValue = EncryptionTool.decrypt(value)
-                                callback.onSuccess(serializer.fromJson(decryptedValue, objectType))
+                                withContext(Dispatchers.Main){
+                                    callback.onSuccess(serializer.fromJson(decryptedValue, objectType))
+                                }
                             }
                         }
                     }
                 }
             } catch (e: Exception) {
-                callback.onSuccess(null, e)
+                withContext(Dispatchers.Main){
+                    callback.onSuccess(null, e)
+                }
+            }
+        }
+    }
+
+    override fun <T : StoreAbleObject> get(
+        scope: CoroutineScope,
+        key: String,
+        objectType: Class<T>,
+        callback: GetCallback<T>,
+    ) {
+        scope.launch {
+            try {
+                when (val value = getCache(key)) {
+                    null -> {
+                        withContext(Dispatchers.Main){
+                            callback.onSuccess(null, NoStoreAbleObjectFound())
+                        }
+                    }
+                    else -> {
+                        when (StoreXCore.encryptionKey == StoreXCore.NO_ENCRYPTION) {
+                            true -> {
+                                withContext(Dispatchers.Main){
+                                    callback.onSuccess(serializer.fromJson(value, objectType))
+                                }
+                            }
+                            else -> {
+                                val decryptedValue = EncryptionTool.decrypt(value)
+                                withContext(Dispatchers.Main){
+                                    callback.onSuccess(serializer.fromJson(decryptedValue, objectType))
+                                }
+                            }
+                        }
+                    }
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main){
+                    callback.onSuccess(null, e)
+                }
             }
         }
     }
diff --git a/StoreX/src/main/java/com/rommansabbir/storex/StoreXState.kt b/StoreX/src/main/java/com/rommansabbir/storex/StoreXState.kt
@@ -0,0 +1,3 @@
+package com.rommansabbir.storex
+
+internal data class StoreXState(internal val storeXInstance: StoreXInstance, val config : StoreXConfig)
diff --git a/StoreX/src/main/java/com/rommansabbir/storex/execptions/DuplicateStoreXConfigException.kt b/StoreX/src/main/java/com/rommansabbir/storex/execptions/DuplicateStoreXConfigException.kt
@@ -0,0 +1,4 @@
+package com.rommansabbir.storex.execptions
+
+class DuplicateStoreXConfigException(@JvmField override val message: String = "Duplicate StoreXConfig found.") :
+    RuntimeException(message)
diff --git a/StoreX/src/main/java/com/rommansabbir/storex/execptions/NoConfigFoundException.kt b/StoreX/src/main/java/com/rommansabbir/storex/execptions/NoConfigFoundException.kt
@@ -0,0 +1,4 @@
+package com.rommansabbir.storex.execptions
+
+class NoConfigFoundException(@JvmField override val message: String = "No valid instance found for this StoreXConfig") :
+    RuntimeException(message)
diff --git a/app/src/main/java/com/rommansabbir/storexdemo/MainActivity.kt b/app/src/main/java/com/rommansabbir/storexdemo/MainActivity.kt
diff --git a/app/src/main/java/com/rommansabbir/storexdemo/MyApp.kt b/app/src/main/java/com/rommansabbir/storexdemo/MyApp.kt
diff --git a/app/src/main/java/com/rommansabbir/storexdemo/StoreXIdentifiers.kt b/app/src/main/java/com/rommansabbir/storexdemo/StoreXIdentifiers.kt

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,10 @@`
`1`	`1`	`package com.rommansabbir.storex`
`2`	`2`
	`3`	`+@Deprecated("Use new method StoreXCore.instance(config: StoreXConfig) to get specific instance", ReplaceWith("StoreXCore.instance(config: StoreXConfig)"))`
`3`	`4`	`fun storeXInstance(): StoreX = StoreXCore.instance()`
`4`	`5`
	`6`	`+fun storeXInstance(config: StoreXConfig): StoreX = StoreXCore.instance(config)`
	`7`	`+`
`5`	`8`	`internal fun Subscriber.getKey(): String {`
`6`	`9`	`return "${this.key}_${this.subscriberID}"`
`7`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+package com.rommansabbir.storex`
	`2`	`+`
	`3`	`+internal data class StoreXState(internal val storeXInstance: StoreXInstance, val config : StoreXConfig)`