From d3128c3bccc0e33008c5b5ac58e5584207e246b5 Mon Sep 17 00:00:00 2001
From: Krzysztof Borowy <krizzu.dev@gmail.com>
Date: Tue, 19 Jan 2021 23:36:34 +0100
Subject: [PATCH 01/17] initial

---
 android/build.gradle                          | 42 +++++++++++++------
 .../asyncstorage/AsyncStoragePackage.java     | 15 +++++--
 .../asyncstorage/next/StorageModule.kt        |  8 ++++
 example/android/build.gradle                  |  8 ++++
 example/android/gradle.properties             |  1 +
 5 files changed, 59 insertions(+), 15 deletions(-)
 create mode 100644 android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt

diff --git a/android/build.gradle b/android/build.gradle
index d1442125..7fc9fc06 100644
--- a/android/build.gradle
+++ b/android/build.gradle
@@ -21,18 +21,30 @@ def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 }
 
+def getFlagOrDefault(flagName, defaultValue) {
+    rootProject.hasProperty(flagName) ? rootProject.properties[flagName] == "true" : defaultValue
+}
+
 configurations {
     compileClasspath
 }
 
 buildscript {
-    if (project == rootProject) {
-        repositories {
-            google()
-            jcenter()
-        }
-        dependencies {
+    // kotlin version is dictated by rootProject extension or property in gradle.properties
+    ext.asyncStorageKtVersion = rootProject.ext.has('kotlinVersion')
+            ? rootProject.ext['kotlinVersion']
+            : rootProject.hasProperty('AsyncStorage_kotlinVersion')
+            ? rootProject.properties['AsyncStorage_kotlinVersion']
+            : '1.4.21'
+
+    repositories {
+        google()
+        jcenter()
+    }
+    dependencies {
+        if (project == rootProject) {
             classpath 'com.android.tools.build:gradle:3.6.4'
+            classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$asyncStorageKtVersion"
         }
     }
 }
@@ -42,19 +54,24 @@ buildscript {
 // This also protects the database from filling up the disk cache and becoming malformed.
 // If you really need bigger size, please keep in mind the potential consequences.
 long dbSizeInMB = 6L
-
 def newDbSize = rootProject.properties['AsyncStorage_db_size_in_MB']
-
 if( newDbSize != null && newDbSize.isLong()) {
     dbSizeInMB = newDbSize.toLong()
 }
 
-def useDedicatedExecutor = rootProject.hasProperty('AsyncStorage_dedicatedExecutor')
-        ? rootProject.properties['AsyncStorage_dedicatedExecutor']
-        : false
+// Instead of reusing AsyncTask thread pool, AsyncStorage can use its own executor
+def useDedicatedExecutor = getFlagOrDefault('AsyncStorage_dedicatedExecutor', false)
 
 apply plugin: 'com.android.library'
 
+// todo: decide the name
+def useRoomImplementation = getFlagOrDefault("AsyncStorage_useRoomLibrary", false)
+
+if(useRoomImplementation) {
+    apply plugin: 'kotlin-android'
+    apply plugin: 'kotlin-kapt'
+}
+
 android {
     compileSdkVersion safeExtGet('compileSdkVersion', 28)
     buildToolsVersion safeExtGet('buildToolsVersion', '28.0.3')
@@ -62,7 +79,8 @@ android {
         minSdkVersion safeExtGet('minSdkVersion', 19)
         targetSdkVersion safeExtGet('targetSdkVersion', 28)
         buildConfigField "Long", "AsyncStorage_db_size", "${dbSizeInMB}L"
-        buildConfigField("boolean", "AsyncStorage_useDedicatedExecutor", "${useDedicatedExecutor}")
+        buildConfigField "boolean", "AsyncStorage_useDedicatedExecutor", "${useDedicatedExecutor}"
+        buildConfigField "boolean", "AsyncStorage_useRoomLibrary", "${useRoomImplementation}"
     }
     lintOptions {
         abortOnError false
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java b/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java
index 25eb5a14..767f834d 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java
@@ -12,15 +12,24 @@
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.uimanager.ViewManager;
-
-import java.util.Arrays;
+import com.reactnativecommunity.asyncstorage.next.StorageModule;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
 public class AsyncStoragePackage implements ReactPackage {
     @Override
     public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
-      return Arrays.<NativeModule>asList(new AsyncStorageModule(reactContext));
+
+        List<NativeModule> moduleList = new ArrayList<>(1);
+
+        if(BuildConfig.AsyncStorage_useRoomLibrary) {
+            moduleList.add(new StorageModule(reactContext));
+        } else {
+            moduleList.add(new AsyncStorageModule(reactContext));
+        }
+
+      return moduleList;
     }
 
     // Deprecated in RN 0.47 
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
new file mode 100644
index 00000000..b04bbb93
--- /dev/null
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
@@ -0,0 +1,8 @@
+package com.reactnativecommunity.asyncstorage.next
+
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+
+class StorageModule(private val reactContext: ReactContext) : ReactContextBaseJavaModule() {
+    override fun getName() = "RNC_AsyncSQLiteDBStorage"
+}
\ No newline at end of file
diff --git a/example/android/build.gradle b/example/android/build.gradle
index ff15942c..7f94acfb 100644
--- a/example/android/build.gradle
+++ b/example/android/build.gradle
@@ -26,6 +26,13 @@ task fetchDependencies() {
 }
 
 buildscript {
+    /**
+     * Todo:
+     *  In order to use this feature, the end user will have to also include
+     *  Kotlin plugin. Add this info to docs.
+     */
+    ext.kotlinVersion = '1.4.21'
+
     repositories {
         google()
         jcenter()
@@ -33,6 +40,7 @@ buildscript {
     dependencies {
         // Needs to match `react-native-test-app/android/app/build.gradle`
         classpath "com.android.tools.build:gradle:4.0.2"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
     }
 }
 
diff --git a/example/android/gradle.properties b/example/android/gradle.properties
index 6f73824c..cf69923f 100644
--- a/example/android/gradle.properties
+++ b/example/android/gradle.properties
@@ -22,6 +22,7 @@
 
 # Enable dedicated thread pool executor
 AsyncStorage_dedicatedExecutor=true
+AsyncStorage_useRoomLibrary=true
 
 android.useAndroidX=true
 android.enableJetifier=true

From 7fb5376ee86a9336bc3358ab3eefef9773c82f26 Mon Sep 17 00:00:00 2001
From: Krzysztof Borowy <krizzu.dev@gmail.com>
Date: Thu, 21 Jan 2021 09:31:07 +0100
Subject: [PATCH 02/17] room deps

---
 android/build.gradle | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/android/build.gradle b/android/build.gradle
index 7fc9fc06..2408efb3 100644
--- a/android/build.gradle
+++ b/android/build.gradle
@@ -61,12 +61,9 @@ if( newDbSize != null && newDbSize.isLong()) {
 
 // Instead of reusing AsyncTask thread pool, AsyncStorage can use its own executor
 def useDedicatedExecutor = getFlagOrDefault('AsyncStorage_dedicatedExecutor', false)
-
-apply plugin: 'com.android.library'
-
-// todo: decide the name
 def useRoomImplementation = getFlagOrDefault("AsyncStorage_useRoomLibrary", false)
 
+apply plugin: 'com.android.library'
 if(useRoomImplementation) {
     apply plugin: 'kotlin-android'
     apply plugin: 'kotlin-kapt'
@@ -97,6 +94,16 @@ repositories {
 }
 
 dependencies {
+
+    if(useRoomImplementation) {
+        def room_version = "2.2.6"
+        def coroutines_version = "1.3.9"
+
+        implementation "androidx.room:room-runtime:$room_version"
+        implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutines_version"
+        kapt "androidx.room:room-compiler:$room_version"
+    }
+
     //noinspection GradleDynamicVersion
     implementation 'com.facebook.react:react-native:+'  // From node_modules
 }

From 37db93eb75721e078c9d3b85fc7beb4427cf871a Mon Sep 17 00:00:00 2001
From: Krzysztof Borowy <krizzu.dev@gmail.com>
Date: Sat, 23 Jan 2021 11:19:53 +0100
Subject: [PATCH 03/17] initial implementation

---
 .../asyncstorage/AsyncStoragePackage.java     |  25 +++-
 .../asyncstorage/next/StorageModule.kt        |  26 +++-
 .../asyncstorage/next/StorageSupplier.kt      | 115 ++++++++++++++++++
 example/android/build.gradle                  |   2 +
 example/examples/GetSetClear.js               |   4 +
 5 files changed, 165 insertions(+), 7 deletions(-)
 create mode 100644 android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt

diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java b/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java
index 767f834d..5db0d715 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java
@@ -7,12 +7,13 @@
 
 package com.reactnativecommunity.asyncstorage;
 
+import android.util.Log;
 import com.facebook.react.ReactPackage;
 import com.facebook.react.bridge.JavaScriptModule;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.uimanager.ViewManager;
-import com.reactnativecommunity.asyncstorage.next.StorageModule;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -23,23 +24,35 @@ public List<NativeModule> createNativeModules(ReactApplicationContext reactConte
 
         List<NativeModule> moduleList = new ArrayList<>(1);
 
-        if(BuildConfig.AsyncStorage_useRoomLibrary) {
-            moduleList.add(new StorageModule(reactContext));
+        if (BuildConfig.AsyncStorage_useRoomLibrary) {
+            try {
+                Class storageClass = Class.forName("com.reactnativecommunity.asyncstorage.next.StorageModule");
+                NativeModule inst = (NativeModule) storageClass.getDeclaredConstructor(new Class[]{ReactContext.class}).newInstance(reactContext);
+                moduleList.add(inst);
+            } catch (Exception e) {
+                // todo notify about potential issues
+                String message = "Something went wrong when initializing module:"
+                        + "\n"
+                        + e.getCause().getClass()
+                        + "\n"
+                        + "Cause:" + e.getCause().getLocalizedMessage();
+                Log.e("AsyncStorage_Next", message);
+            }
         } else {
             moduleList.add(new AsyncStorageModule(reactContext));
         }
 
-      return moduleList;
+        return moduleList;
     }
 
     // Deprecated in RN 0.47 
     public List<Class<? extends JavaScriptModule>> createJSModules() {
-      return Collections.emptyList();
+        return Collections.emptyList();
     }
 
     @Override
     @SuppressWarnings("rawtypes")
     public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
-      return Collections.emptyList();
+        return Collections.emptyList();
     }
 }
\ No newline at end of file
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
index b04bbb93..2a648a04 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
@@ -1,8 +1,32 @@
 package com.reactnativecommunity.asyncstorage.next
 
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Callback
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import kotlinx.coroutines.CoroutineName
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
 
-class StorageModule(private val reactContext: ReactContext) : ReactContextBaseJavaModule() {
+class StorageModule(reactContext: ReactContext) : ReactContextBaseJavaModule() {
     override fun getName() = "RNC_AsyncSQLiteDBStorage"
+
+    private val storage: AsyncStorageAccess = StorageSupplier.getInstance(reactContext)
+    private val scope = CoroutineScope(
+        Dispatchers.IO + CoroutineName("AsyncStorageCoroutine") + SupervisorJob()
+    )
+
+    @ReactMethod
+    fun getAllKeys(cb: Callback) {
+        scope.launch {
+            val keys = storage.getKeys()
+            val result = Arguments.createArray()
+            keys.forEach { result.pushString(it) }
+            cb.invoke(result)
+        }
+    }
 }
\ No newline at end of file
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt
new file mode 100644
index 00000000..a655e98e
--- /dev/null
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt
@@ -0,0 +1,115 @@
+package com.reactnativecommunity.asyncstorage.next
+
+import android.content.Context
+import androidx.room.ColumnInfo
+import androidx.room.Dao
+import androidx.room.Database
+import androidx.room.Entity
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import androidx.room.Room
+import androidx.room.RoomDatabase
+import androidx.room.Transaction
+import androidx.room.Update
+
+private const val DATABASE_NAME = "RKStorage"
+private const val DATABASE_VERSION = 1
+private const val TABLE_NAME = "catalystLocalStorage"
+private const val COLUMN_KEY = "key"
+private const val COLUMN_VALUE = "value"
+
+
+@Entity(tableName = TABLE_NAME, primaryKeys = ["key"])
+data class Entry(
+    @PrimaryKey @ColumnInfo(name = COLUMN_KEY) val key: String,
+    @ColumnInfo(name = COLUMN_VALUE) val value: String
+)
+
+@Dao
+private interface StorageDao {
+
+    // fun mergeValues() // todo
+
+    @Transaction
+    @Query("SELECT * FROM $TABLE_NAME WHERE `$COLUMN_KEY` IN (:keys)")
+    fun getValues(keys: List<String>): List<Entry>
+
+    @Transaction
+    fun setValues(entries: List<Entry>) {
+        val insertResult = insert(entries)
+        with(entries.filterIndexed { i, _ -> insertResult[i] == -1L }) {
+            update(this)
+        }
+    }
+
+    @Transaction
+    @Query("DELETE FROM $TABLE_NAME WHERE `$COLUMN_KEY` in (:keys)")
+    fun removeValues(keys: List<String>)
+
+    @Transaction
+    @Query("SELECT `$COLUMN_KEY` FROM $TABLE_NAME")
+    fun getKeys(): List<String>
+
+    @Transaction
+    @Query("DELETE FROM $TABLE_NAME")
+    fun clear()
+
+
+    // insert and update are components of setValues - not to be used separately
+    @Insert(onConflict = OnConflictStrategy.IGNORE)
+    fun insert(entries: List<Entry>): List<Long>
+    @Update
+    fun update(entries: List<Entry>)
+}
+
+@Database(entities = [Entry::class], version = DATABASE_VERSION, exportSchema = false)
+private abstract class StorageDb : RoomDatabase() {
+    abstract fun storage(): StorageDao
+
+    companion object {
+        private var instance: StorageDb? = null
+
+        fun getDatabase(context: Context): StorageDb {
+            var inst = instance
+            if (inst != null) {
+                return inst
+            }
+
+            synchronized(this) {
+                inst = Room.databaseBuilder(
+                    context, StorageDb::class.java, DATABASE_NAME
+                ).build()
+
+                instance = inst
+                return instance!!
+            }
+        }
+    }
+}
+
+interface AsyncStorageAccess {
+    suspend fun getValue(keys: List<String>): List<Entry>
+    suspend fun setValues(entries: List<Entry>)
+    suspend fun removeValues(keys: List<String>)
+    suspend fun getKeys(): List<String>
+    suspend fun clear()
+    // suspend fun mergeValues() // todo
+}
+
+class StorageSupplier private constructor(db: StorageDb) : AsyncStorageAccess {
+    companion object {
+        fun getInstance(ctx: Context): AsyncStorageAccess {
+            return StorageSupplier(StorageDb.getDatabase(ctx))
+        }
+    }
+
+    private val access = db.storage()
+
+    override suspend fun getValue(keys: List<String>) = access.getValues(keys)
+    override suspend fun setValues(entries: List<Entry>) = access.setValues(entries)
+    override suspend fun removeValues(keys: List<String>) = access.removeValues(keys)
+    override suspend fun getKeys() = access.getKeys()
+    override suspend fun clear() = access.clear()
+}
\ No newline at end of file
diff --git a/example/android/build.gradle b/example/android/build.gradle
index 7f94acfb..2b4b2955 100644
--- a/example/android/build.gradle
+++ b/example/android/build.gradle
@@ -40,6 +40,8 @@ buildscript {
     dependencies {
         // Needs to match `react-native-test-app/android/app/build.gradle`
         classpath "com.android.tools.build:gradle:4.0.2"
+
+        // todo: remember to document this as well
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
     }
 }
diff --git a/example/examples/GetSetClear.js b/example/examples/GetSetClear.js
index 6cc1853c..fe1904d0 100644
--- a/example/examples/GetSetClear.js
+++ b/example/examples/GetSetClear.js
@@ -16,6 +16,7 @@ import AsyncStorage from '@react-native-async-storage/async-storage';
 export default function GetSet() {
   const [storedNumber, setStoredNumber] = React.useState('');
   const [needsRestart, setNeedsRestart] = React.useState(false);
+  const [keys, setKeys] = React.useState([]);
 
   React.useEffect(() => {
     AsyncStorage.getItem(STORAGE_KEY).then((value) => {
@@ -23,6 +24,7 @@ export default function GetSet() {
         setStoredNumber(value);
       }
     });
+    AsyncStorage.getAllKeys().then(setKeys);
   }, []);
 
   const increaseByTen = React.useCallback(async () => {
@@ -54,6 +56,8 @@ export default function GetSet() {
 
       <Button testID="clear_button" title="Clear item" onPress={clearItem} />
 
+      <Text>Keys: {keys.join(', ')}</Text>
+
       {needsRestart ? <Text>Hit restart to see effect</Text> : null}
     </View>
   );

From 5d2e64fe9208948ca821943d901f0cae69e7de73 Mon Sep 17 00:00:00 2001
From: Krzysztof Borowy <krizzu.dev@gmail.com>
Date: Thu, 28 Jan 2021 10:27:33 +0100
Subject: [PATCH 04/17] implement storage functionality

Functionality to persist data, new example, error handling
---
 .../asyncstorage/next/ArgumentHelpers.kt      |  50 +++++++
 .../asyncstorage/next/ErrorHelpers.kt         |  36 +++++
 .../asyncstorage/next/StorageModule.kt        |  55 +++++++-
 .../asyncstorage/next/StorageSupplier.kt      |  63 +++++++--
 example/App.js                                |  13 ++
 example/examples/Basic.js                     | 128 ++++++++++++++++++
 example/examples/GetSetClear.js               |   4 -
 7 files changed, 328 insertions(+), 21 deletions(-)
 create mode 100644 android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt
 create mode 100644 android/src/main/java/com/reactnativecommunity/asyncstorage/next/ErrorHelpers.kt
 create mode 100644 example/examples/Basic.js

diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt
new file mode 100644
index 00000000..a01fb70a
--- /dev/null
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt
@@ -0,0 +1,50 @@
+package com.reactnativecommunity.asyncstorage.next
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+
+fun ReadableArray.toEntryList(): List<Entry> {
+    val list = mutableListOf<Entry>()
+    for (keyValue in this.toArrayList()) {
+        if (keyValue !is ArrayList<*>) {
+            throw AsyncStorageError.invalidKeyValueFormat()
+        }
+        val key = keyValue[0]
+        val value = keyValue[1]
+
+        if (key == null || key !is String) {
+            throw AsyncStorageError.keyIsNull()
+        }
+
+        if (value !is String) {
+            throw AsyncStorageError.valueNotString(key)
+        }
+
+        list.add(Entry(key, value))
+    }
+    return list
+}
+
+fun ReadableArray.toKeyList(): List<String> {
+    val list = this.toArrayList().toList()
+
+    for (item in list) {
+        if (item !is String) {
+            throw AsyncStorageError.keyIsNull()
+        }
+    }
+    return list as List<String>
+}
+
+fun List<Entry>.toKeyValueArgument(): ReadableArray {
+    val args = Arguments.createArray()
+
+    for (entry in this) {
+        val keyValue = Arguments.createArray()
+        keyValue.pushString(entry.key)
+        keyValue.pushString(entry.value)
+        args.pushArray(keyValue)
+    }
+
+    return args
+}
\ No newline at end of file
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ErrorHelpers.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ErrorHelpers.kt
new file mode 100644
index 00000000..3f7b12b0
--- /dev/null
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ErrorHelpers.kt
@@ -0,0 +1,36 @@
+package com.reactnativecommunity.asyncstorage.next
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Callback
+import kotlinx.coroutines.CoroutineExceptionHandler
+
+internal fun createExceptionHandler(cb: Callback): CoroutineExceptionHandler {
+    return CoroutineExceptionHandler { _, throwable ->
+        val error = Arguments.createMap()
+        if (throwable !is AsyncStorageError) {
+            error.putString(
+                "message", "Unexpected AsyncStorage error: ${throwable.localizedMessage}"
+            )
+        } else {
+            error.putString("message", throwable.errorMessage)
+        }
+
+        cb(error)
+    }
+}
+
+internal class AsyncStorageError private constructor(val errorMessage: String) :
+    Throwable(errorMessage) {
+
+    companion object {
+        fun keyIsNull() = AsyncStorageError("Key cannot be null")
+
+        fun invalidKeyValueFormat() =
+            AsyncStorageError("Invalid key-value format. Expected a list of [key, value] list.")
+
+        fun valueNotString(key: String?): AsyncStorageError {
+            val detail = if (key == null) "Provided value" else "Value for key \"$key\""
+            return AsyncStorageError("$detail is not of type String")
+        }
+    }
+}
\ No newline at end of file
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
index 2a648a04..d8b9a1c3 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
@@ -12,21 +12,62 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
 
-class StorageModule(reactContext: ReactContext) : ReactContextBaseJavaModule() {
+class StorageModule(reactContext: ReactContext) : ReactContextBaseJavaModule(), CoroutineScope {
     override fun getName() = "RNC_AsyncSQLiteDBStorage"
 
-    private val storage: AsyncStorageAccess = StorageSupplier.getInstance(reactContext)
-    private val scope = CoroutineScope(
-        Dispatchers.IO + CoroutineName("AsyncStorageCoroutine") + SupervisorJob()
-    )
+    override val coroutineContext =
+        Dispatchers.IO + CoroutineName("AsyncStorageScope") + SupervisorJob()
+
+    private val storage = StorageSupplier.getInstance(reactContext)
+
+    /**
+     * Todo:
+     *  - MultiMerge
+     */
+
+    @ReactMethod
+    fun multiGet(keys: ReadableArray, cb: Callback) {
+        launch(createExceptionHandler(cb)) {
+            val entries = storage.getValues(keys.toKeyList())
+            cb(null, entries.toKeyValueArgument())
+        }
+    }
+
+    @ReactMethod
+    fun multiSet(keyValueArray: ReadableArray, cb: Callback) {
+        launch(createExceptionHandler(cb)) {
+            val entries = keyValueArray.toEntryList()
+            storage.setValues(entries)
+            cb(null)
+        }
+    }
+
+    @ReactMethod
+    fun multiRemove(keys: ReadableArray, cb: Callback) {
+        launch(createExceptionHandler(cb)) {
+            storage.removeValues(keys.toKeyList())
+            cb(null)
+        }
+    }
+
+    // @ReactMethod
+    // fun multiMerge(val keyValueArray: ReadableArray, cb: Callback) {}
 
     @ReactMethod
     fun getAllKeys(cb: Callback) {
-        scope.launch {
+        launch(createExceptionHandler(cb)) {
             val keys = storage.getKeys()
             val result = Arguments.createArray()
             keys.forEach { result.pushString(it) }
-            cb.invoke(result)
+            cb.invoke(null, result)
+        }
+    }
+
+    @ReactMethod
+    fun clear(cb: Callback) {
+        launch(createExceptionHandler(cb)) {
+            storage.clear()
+            cb(null)
         }
     }
 }
\ No newline at end of file
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt
index a655e98e..38e9f88e 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt
@@ -13,18 +13,20 @@ import androidx.room.Room
 import androidx.room.RoomDatabase
 import androidx.room.Transaction
 import androidx.room.Update
+import androidx.room.migration.Migration
+import androidx.sqlite.db.SupportSQLiteDatabase
 
-private const val DATABASE_NAME = "RKStorage"
-private const val DATABASE_VERSION = 1
-private const val TABLE_NAME = "catalystLocalStorage"
+private const val DATABASE_VERSION = 2
+private const val DATABASE_NAME = "AsyncStorage"
+private const val TABLE_NAME = "Storage"
 private const val COLUMN_KEY = "key"
 private const val COLUMN_VALUE = "value"
 
 
-@Entity(tableName = TABLE_NAME, primaryKeys = ["key"])
+@Entity(tableName = TABLE_NAME)
 data class Entry(
     @PrimaryKey @ColumnInfo(name = COLUMN_KEY) val key: String,
-    @ColumnInfo(name = COLUMN_VALUE) val value: String
+    @ColumnInfo(name = COLUMN_VALUE) val value: String?
 )
 
 @Dao
@@ -60,11 +62,45 @@ private interface StorageDao {
     // insert and update are components of setValues - not to be used separately
     @Insert(onConflict = OnConflictStrategy.IGNORE)
     fun insert(entries: List<Entry>): List<Long>
+
     @Update
     fun update(entries: List<Entry>)
 }
 
-@Database(entities = [Entry::class], version = DATABASE_VERSION, exportSchema = false)
+
+/**
+ * Previous version of AsyncStorage is violating the SQL standard (based on bug in SQLite),
+ * where PrimaryKey ('key' column) should never be null (https://www.sqlite.org/lang_createtable.html#the_primary_key).
+ * Because of that, we cannot reuse the old DB, because ROOM is guarded against that case (won't compile).
+ *
+ * In order to work around this, two steps are necessary:
+ *  - Room DB pre-population from the old database file (https://developer.android.com/training/data-storage/room/prepopulate#from-asset)
+ *  - Version migration, so that we can mark 'key' column as NOT-NULL
+ *
+ * This migration will happens only once, when developer enable this feature (when DB is still not created).
+ */
+@Suppress("ClassName")
+private object MIGRATION_TO_NEXT : Migration(1, 2) {
+    override fun migrate(database: SupportSQLiteDatabase) {
+        val oldTableName = "catalystLocalStorage" // from ReactDatabaseSupplier
+
+        database.execSQL("CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`${COLUMN_KEY}` TEXT NOT NULL, `${COLUMN_VALUE}` TEXT, PRIMARY KEY(`${COLUMN_KEY}`));")
+
+        // even if the old AsyncStorage has checks for not nullable keys
+        // make sure we don't copy any, to not fail migration
+        database.execSQL("DELETE FROM $oldTableName WHERE `${COLUMN_KEY}` IS NULL")
+
+        database.execSQL(
+            """
+            INSERT INTO $TABLE_NAME (`${COLUMN_KEY}`, `${COLUMN_VALUE}`)
+            SELECT `${COLUMN_KEY}`, `${COLUMN_VALUE}`
+            FROM $oldTableName;
+        """.trimIndent()
+        )
+    }
+}
+
+@Database(entities = [Entry::class], version = DATABASE_VERSION, exportSchema = true)
 private abstract class StorageDb : RoomDatabase() {
     abstract fun storage(): StorageDao
 
@@ -78,10 +114,17 @@ private abstract class StorageDb : RoomDatabase() {
             }
 
             synchronized(this) {
-                inst = Room.databaseBuilder(
+                val oldDbFile = context.getDatabasePath("RKStorage")
+                val db = Room.databaseBuilder(
                     context, StorageDb::class.java, DATABASE_NAME
-                ).build()
+                )
+
+                if (oldDbFile.exists()) {
+                    // migrate data from old database, if it exists
+                    db.createFromFile(oldDbFile).addMigrations(MIGRATION_TO_NEXT)
+                }
 
+                inst = db.build()
                 instance = inst
                 return instance!!
             }
@@ -90,7 +133,7 @@ private abstract class StorageDb : RoomDatabase() {
 }
 
 interface AsyncStorageAccess {
-    suspend fun getValue(keys: List<String>): List<Entry>
+    suspend fun getValues(keys: List<String>): List<Entry>
     suspend fun setValues(entries: List<Entry>)
     suspend fun removeValues(keys: List<String>)
     suspend fun getKeys(): List<String>
@@ -107,7 +150,7 @@ class StorageSupplier private constructor(db: StorageDb) : AsyncStorageAccess {
 
     private val access = db.storage()
 
-    override suspend fun getValue(keys: List<String>) = access.getValues(keys)
+    override suspend fun getValues(keys: List<String>) = access.getValues(keys)
     override suspend fun setValues(entries: List<Entry>) = access.setValues(entries)
     override suspend fun removeValues(keys: List<String>) = access.removeValues(keys)
     override suspend fun getKeys() = access.getKeys()
diff --git a/example/App.js b/example/App.js
index efdd2cc9..f998abb2 100644
--- a/example/App.js
+++ b/example/App.js
@@ -21,6 +21,7 @@ import {
 
 import GetSetClear from './examples/GetSetClear';
 import MergeItem from './examples/MergeItem';
+import BasicExample from './examples/Basic';
 
 const TESTS = {
   GetSetClear: {
@@ -39,6 +40,14 @@ const TESTS = {
       return <MergeItem />;
     },
   },
+  Basic: {
+    title: 'Basic',
+    testId: 'basic',
+    description: 'Basic functionality test',
+    render() {
+      return <BasicExample />;
+    },
+  },
 };
 
 type Props = {};
@@ -87,6 +96,10 @@ export default class App extends Component<Props, State> {
             title="Merge Item"
             onPress={() => this._changeTest('MergeItem')}
           />
+          <Button
+            title={TESTS.Basic.title}
+            onPress={() => this._changeTest('Basic')}
+          />
         </View>
 
         {restarting ? null : (
diff --git a/example/examples/Basic.js b/example/examples/Basic.js
new file mode 100644
index 00000000..041cc3b1
--- /dev/null
+++ b/example/examples/Basic.js
@@ -0,0 +1,128 @@
+import React from 'react';
+import {View, Text, Button, StyleSheet, ScrollView, TextInput, NativeModules} from 'react-native';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+const RCTAsyncStorage = NativeModules.RNC_AsyncSQLiteDBStorage ||
+  NativeModules.RNCAsyncStorage;
+
+
+function NextExample() {
+  const [keys, setKeys] = React.useState([]);
+  const [error, setError] = React.useState(null);
+  const [inputKey, setInputKey] = React.useState();
+  const [inputValue, setInputValue] = React.useState();
+  const [value, setValue] = React.useState();
+
+
+  function runWithCatch(block) {
+    return async () => {
+      try {
+        setError(null);
+        await block();
+      } catch (e) {
+        setError('Caught: ' + e.message || e);
+      }
+    };
+  }
+
+  async function getAllKeys() {
+    const allKeys = await AsyncStorage.getAllKeys();
+    setKeys(allKeys);
+  }
+
+  async function readValue() {
+    const v = await AsyncStorage.getItem(inputKey);
+    setValue(v);
+  }
+
+  async function saveValue() {
+    await AsyncStorage.setItem(inputKey, inputValue);
+  }
+
+  async function crashValueType() {
+    await AsyncStorage.setItem('CRASH', 435345);
+  }
+
+  async function crashKeyNull() {
+    await AsyncStorage.setItem(null, 435345);
+  }
+
+  function unknownCrash() {
+    // very unlikely to happen, unless module used directly
+    return new Promise((res, rej) => {
+      RCTAsyncStorage.multiSet(['key', 'crash'], function(errors) {
+        if (errors) {
+          const message = Array.isArray(errors) ? errors[0].message : errors.message;
+          rej(new Error(message));
+        } else {
+          res();
+        }
+      });
+    });
+  }
+
+  async function removeValue() {
+    await AsyncStorage.removeItem(inputKey);
+  }
+
+  async function clearDb() {
+    await AsyncStorage.clear();
+  }
+
+  return <ScrollView contentContainerStyle={{flexGrow: 1}}>
+
+    {error ? <Text style={{fontSize: 18, color: 'red'}}>{error}</Text> : null}
+
+    <View style={styles.example}>
+      <TextInput onChangeText={setInputKey} value={inputKey} style={styles.input} placeholder="key"/>
+      <TextInput onChangeText={setInputValue} value={inputValue} style={styles.input} placeholder="value"/>
+      <View style={{flexDirection: 'row', justifyContent: 'space-around'}}>
+        <Button title="Read" onPress={runWithCatch(readValue)}/>
+        <Button title="Save" onPress={runWithCatch(saveValue)}/>
+        <Button title="Delete" onPress={runWithCatch(removeValue)}/>
+      </View>
+      <Text>Value for {inputKey}: {value}</Text>
+    </View>
+
+    <View style={styles.example}>
+      <Text style={{fontSize: 16, fontWeight: '700'}}>Crash scenarios</Text>
+      <View style={{flexDirection: 'row', justifyContent: 'space-around'}}>
+        <Button title="Key null" onPress={runWithCatch(crashKeyNull)}/>
+        <Button title="Wrong value type" onPress={runWithCatch(crashValueType)}/>
+        <Button title="Other crash" onPress={runWithCatch(unknownCrash)}/>
+      </View>
+    </View>
+
+    <View style={styles.example}>
+      <View style={{flexDirection: 'row', justifyContent: 'space-around'}}>
+        <Button title="Get all keys" onPress={runWithCatch(getAllKeys)}/>
+      </View>
+      <Text style={{fontWeight: '700'}}>Keys:</Text>
+      <Text>{keys.join(', ')}</Text>
+    </View>
+
+    <View style={styles.example}>
+      <Text style={{fontSize: 16}}>Clear database entries</Text>
+      <Button title="clear" onPress={runWithCatch(clearDb)}/>
+    </View>
+  </ScrollView>;
+}
+
+
+const styles = StyleSheet.create({
+  example: {
+    paddingVertical: 24,
+    borderBottomWidth: 1,
+    borderBottomColor: '#e3e3e3',
+    borderStyle: 'solid',
+    justifyContent: 'space-between',
+  },
+  input: {
+    borderWidth: 1,
+    borderColor: '#eee',
+    borderStyle: 'solid',
+  },
+});
+
+
+export default NextExample;
diff --git a/example/examples/GetSetClear.js b/example/examples/GetSetClear.js
index fe1904d0..6cc1853c 100644
--- a/example/examples/GetSetClear.js
+++ b/example/examples/GetSetClear.js
@@ -16,7 +16,6 @@ import AsyncStorage from '@react-native-async-storage/async-storage';
 export default function GetSet() {
   const [storedNumber, setStoredNumber] = React.useState('');
   const [needsRestart, setNeedsRestart] = React.useState(false);
-  const [keys, setKeys] = React.useState([]);
 
   React.useEffect(() => {
     AsyncStorage.getItem(STORAGE_KEY).then((value) => {
@@ -24,7 +23,6 @@ export default function GetSet() {
         setStoredNumber(value);
       }
     });
-    AsyncStorage.getAllKeys().then(setKeys);
   }, []);
 
   const increaseByTen = React.useCallback(async () => {
@@ -56,8 +54,6 @@ export default function GetSet() {
 
       <Button testID="clear_button" title="Clear item" onPress={clearItem} />
 
-      <Text>Keys: {keys.join(', ')}</Text>
-
       {needsRestart ? <Text>Hit restart to see effect</Text> : null}
     </View>
   );

From 0bc83db85ec3dacde8f58081fa5a1ff1d276d09e Mon Sep 17 00:00:00 2001
From: Krzysztof Borowy <krizzu.dev@gmail.com>
Date: Fri, 29 Jan 2021 09:31:44 +0100
Subject: [PATCH 05/17] more error handling

---
 .../asyncstorage/next/ArgumentHelpers.kt       |  9 ++++++---
 .../asyncstorage/next/ErrorHelpers.kt          | 11 +++++++----
 .../asyncstorage/next/StorageModule.kt         |  1 +
 example/examples/Basic.js                      | 18 ++++--------------
 4 files changed, 18 insertions(+), 21 deletions(-)

diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt
index a01fb70a..d416b650 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt
@@ -6,14 +6,17 @@ import com.facebook.react.bridge.ReadableArray
 fun ReadableArray.toEntryList(): List<Entry> {
     val list = mutableListOf<Entry>()
     for (keyValue in this.toArrayList()) {
-        if (keyValue !is ArrayList<*>) {
+        if (keyValue !is ArrayList<*> || keyValue.size != 2) {
             throw AsyncStorageError.invalidKeyValueFormat()
         }
         val key = keyValue[0]
         val value = keyValue[1]
 
         if (key == null || key !is String) {
-            throw AsyncStorageError.keyIsNull()
+            when (key) {
+                null -> throw AsyncStorageError.keyIsNull()
+                !is String -> throw AsyncStorageError.keyNotString()
+            }
         }
 
         if (value !is String) {
@@ -26,7 +29,7 @@ fun ReadableArray.toEntryList(): List<Entry> {
 }
 
 fun ReadableArray.toKeyList(): List<String> {
-    val list = this.toArrayList().toList()
+    val list = this.toArrayList()
 
     for (item in list) {
         if (item !is String) {
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ErrorHelpers.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ErrorHelpers.kt
index 3f7b12b0..59549b37 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ErrorHelpers.kt
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ErrorHelpers.kt
@@ -23,14 +23,17 @@ internal class AsyncStorageError private constructor(val errorMessage: String) :
     Throwable(errorMessage) {
 
     companion object {
-        fun keyIsNull() = AsyncStorageError("Key cannot be null")
+        fun keyIsNull() = AsyncStorageError("Key cannot be null.")
 
-        fun invalidKeyValueFormat() =
-            AsyncStorageError("Invalid key-value format. Expected a list of [key, value] list.")
+        fun keyNotString() = AsyncStorageError("Provided key is not string. Only strings are supported as storage key.")
 
         fun valueNotString(key: String?): AsyncStorageError {
             val detail = if (key == null) "Provided value" else "Value for key \"$key\""
-            return AsyncStorageError("$detail is not of type String")
+            return AsyncStorageError("$detail is not a string. Only strings are supported as a value.")
         }
+
+        fun invalidKeyValueFormat() =
+            AsyncStorageError("Invalid key-value format. Expected a list of [key, value] list.")
+
     }
 }
\ No newline at end of file
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
index d8b9a1c3..47df07b8 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
@@ -23,6 +23,7 @@ class StorageModule(reactContext: ReactContext) : ReactContextBaseJavaModule(),
     /**
      * Todo:
      *  - MultiMerge
+     *  - Documenting the migration, access from Brownfield and error handling
      */
 
     @ReactMethod
diff --git a/example/examples/Basic.js b/example/examples/Basic.js
index 041cc3b1..113d3a30 100644
--- a/example/examples/Basic.js
+++ b/example/examples/Basic.js
@@ -44,21 +44,11 @@ function NextExample() {
   }
 
   async function crashKeyNull() {
-    await AsyncStorage.setItem(null, 435345);
+    await AsyncStorage.setItem(null, '435345');
   }
 
-  function unknownCrash() {
-    // very unlikely to happen, unless module used directly
-    return new Promise((res, rej) => {
-      RCTAsyncStorage.multiSet(['key', 'crash'], function(errors) {
-        if (errors) {
-          const message = Array.isArray(errors) ? errors[0].message : errors.message;
-          rej(new Error(message));
-        } else {
-          res();
-        }
-      });
-    });
+  async function crashKeyNotString() {
+    await AsyncStorage.setItem(432, '435345');
   }
 
   async function removeValue() {
@@ -88,8 +78,8 @@ function NextExample() {
       <Text style={{fontSize: 16, fontWeight: '700'}}>Crash scenarios</Text>
       <View style={{flexDirection: 'row', justifyContent: 'space-around'}}>
         <Button title="Key null" onPress={runWithCatch(crashKeyNull)}/>
+        <Button title="Key not string" onPress={runWithCatch(crashKeyNotString)}/>
         <Button title="Wrong value type" onPress={runWithCatch(crashValueType)}/>
-        <Button title="Other crash" onPress={runWithCatch(unknownCrash)}/>
       </View>
     </View>
 

From a545d0a6569feb9537060223c090f8ee68f491e3 Mon Sep 17 00:00:00 2001
From: Krzysztof Borowy <krizzu.dev@gmail.com>
Date: Wed, 3 Feb 2021 09:57:04 +0100
Subject: [PATCH 06/17] merging values

---
 .../asyncstorage/AsyncStoragePackage.java     |   1 -
 .../asyncstorage/next/ArgumentHelpers.kt      |  33 +++++
 .../asyncstorage/next/StorageModule.kt        |  14 +-
 .../asyncstorage/next/StorageSupplier.kt      |  24 +++-
 example/App.js                                |   2 +-
 example/examples/Basic.js                     | 126 ++++++++++++++++--
 6 files changed, 181 insertions(+), 19 deletions(-)

diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java b/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java
index 5db0d715..52d53c15 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java
@@ -30,7 +30,6 @@ public List<NativeModule> createNativeModules(ReactApplicationContext reactConte
                 NativeModule inst = (NativeModule) storageClass.getDeclaredConstructor(new Class[]{ReactContext.class}).newInstance(reactContext);
                 moduleList.add(inst);
             } catch (Exception e) {
-                // todo notify about potential issues
                 String message = "Something went wrong when initializing module:"
                         + "\n"
                         + e.getCause().getClass()
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt
index d416b650..081cb519 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt
@@ -2,6 +2,8 @@ package com.reactnativecommunity.asyncstorage.next
 
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReadableArray
+import org.json.JSONException
+import org.json.JSONObject
 
 fun ReadableArray.toEntryList(): List<Entry> {
     val list = mutableListOf<Entry>()
@@ -50,4 +52,35 @@ fun List<Entry>.toKeyValueArgument(): ReadableArray {
     }
 
     return args
+}
+
+fun String?.isValidJson(): Boolean {
+    if (this == null) return false
+
+    return try {
+        JSONObject(this)
+        true
+    } catch (e: JSONException) {
+        false
+    }
+}
+
+fun JSONObject.mergeWith(newObject: JSONObject): JSONObject {
+
+    val keys = newObject.keys()
+    val mergedObject = JSONObject(this.toString())
+
+    while (keys.hasNext()) {
+        val key = keys.next()
+        val curValue = this.optJSONObject(key)
+        val newValue = newObject.optJSONObject(key)
+
+        if (curValue != null && newValue != null) {
+            val merged = curValue.mergeWith(newValue)
+            mergedObject.put(key, merged)
+        } else {
+            mergedObject.put(key, newObject.get(key))
+        }
+    }
+    return mergedObject
 }
\ No newline at end of file
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
index 47df07b8..b8e4f0f2 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
@@ -22,8 +22,8 @@ class StorageModule(reactContext: ReactContext) : ReactContextBaseJavaModule(),
 
     /**
      * Todo:
-     *  - MultiMerge
-     *  - Documenting the migration, access from Brownfield and error handling
+     *  - Documenting the migration,
+     *  - access from Native (Java interop)
      */
 
     @ReactMethod
@@ -51,8 +51,14 @@ class StorageModule(reactContext: ReactContext) : ReactContextBaseJavaModule(),
         }
     }
 
-    // @ReactMethod
-    // fun multiMerge(val keyValueArray: ReadableArray, cb: Callback) {}
+    @ReactMethod
+    fun multiMerge(keyValueArray: ReadableArray, cb: Callback) {
+        launch(createExceptionHandler(cb)) {
+            val entries = keyValueArray.toEntryList()
+            storage.mergeValues(entries)
+            cb(null)
+        }
+    }
 
     @ReactMethod
     fun getAllKeys(cb: Callback) {
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt
index 38e9f88e..b610b6b7 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt
@@ -15,6 +15,7 @@ import androidx.room.Transaction
 import androidx.room.Update
 import androidx.room.migration.Migration
 import androidx.sqlite.db.SupportSQLiteDatabase
+import org.json.JSONObject
 
 private const val DATABASE_VERSION = 2
 private const val DATABASE_NAME = "AsyncStorage"
@@ -32,7 +33,25 @@ data class Entry(
 @Dao
 private interface StorageDao {
 
-    // fun mergeValues() // todo
+    @Transaction
+    fun mergeValues(entries: List<Entry>) {
+        val currentDbEntries = getValues(entries.map { it.key })
+        val newEntries = mutableListOf<Entry>()
+
+        entries.forEach { newEntry ->
+            val oldEntry = currentDbEntries.find { it.key == newEntry.key }
+            if (oldEntry?.value == null) {
+                newEntries.add(newEntry)
+            } else if (!oldEntry.value.isValidJson() || !newEntry.value.isValidJson()) {
+                newEntries.add(newEntry)
+            } else {
+                val newValue =
+                    JSONObject(oldEntry.value).mergeWith(JSONObject(newEntry.value)).toString()
+                newEntries.add(newEntry.copy(value = newValue))
+            }
+        }
+        setValues(newEntries)
+    }
 
     @Transaction
     @Query("SELECT * FROM $TABLE_NAME WHERE `$COLUMN_KEY` IN (:keys)")
@@ -138,7 +157,7 @@ interface AsyncStorageAccess {
     suspend fun removeValues(keys: List<String>)
     suspend fun getKeys(): List<String>
     suspend fun clear()
-    // suspend fun mergeValues() // todo
+    suspend fun mergeValues(entries: List<Entry>)
 }
 
 class StorageSupplier private constructor(db: StorageDb) : AsyncStorageAccess {
@@ -153,6 +172,7 @@ class StorageSupplier private constructor(db: StorageDb) : AsyncStorageAccess {
     override suspend fun getValues(keys: List<String>) = access.getValues(keys)
     override suspend fun setValues(entries: List<Entry>) = access.setValues(entries)
     override suspend fun removeValues(keys: List<String>) = access.removeValues(keys)
+    override suspend fun mergeValues(entries: List<Entry>) = access.mergeValues(entries)
     override suspend fun getKeys() = access.getKeys()
     override suspend fun clear() = access.clear()
 }
\ No newline at end of file
diff --git a/example/App.js b/example/App.js
index f998abb2..b2fe194f 100644
--- a/example/App.js
+++ b/example/App.js
@@ -128,7 +128,7 @@ const styles = StyleSheet.create({
     padding: 8,
   },
   exampleContainer: {
-    padding: 16,
+    padding: 4,
     backgroundColor: '#FFF',
     borderColor: '#EEE',
     borderTopWidth: 1,
diff --git a/example/examples/Basic.js b/example/examples/Basic.js
index 113d3a30..81e03ce5 100644
--- a/example/examples/Basic.js
+++ b/example/examples/Basic.js
@@ -1,10 +1,20 @@
 import React from 'react';
-import {View, Text, Button, StyleSheet, ScrollView, TextInput, NativeModules} from 'react-native';
+import {View, Text, Button, StyleSheet, ScrollView, TextInput} from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 
-const RCTAsyncStorage = NativeModules.RNC_AsyncSQLiteDBStorage ||
-  NativeModules.RNCAsyncStorage;
 
+const mergeInitialValue = {
+  initial: 'keep',
+  override1: 'override',
+  nested: {
+    nestedValue: 'keep',
+    override2: 'override',
+    deeper: {
+      deeperValue: 'keep',
+      override3: 'override',
+    },
+  },
+};
 
 function NextExample() {
   const [keys, setKeys] = React.useState([]);
@@ -12,6 +22,12 @@ function NextExample() {
   const [inputKey, setInputKey] = React.useState();
   const [inputValue, setInputValue] = React.useState();
   const [value, setValue] = React.useState();
+  const [mergedValue, setMergedValue] = React.useState();
+  const [overrideValue, setOverrideValue] = React.useState({
+    override1: '',
+    override2: '',
+    override3: '',
+  });
 
 
   function runWithCatch(block) {
@@ -59,14 +75,58 @@ function NextExample() {
     await AsyncStorage.clear();
   }
 
+  async function resetMergedValue() {
+    await AsyncStorage.setItem('MERGER', JSON.stringify(mergeInitialValue));
+    const saved = await AsyncStorage.getItem('MERGER');
+    setMergedValue(JSON.parse(saved));
+  }
+
+  async function readMergedValue() {
+    const saved = await AsyncStorage.getItem('MERGER');
+    setMergedValue(saved ? JSON.parse(saved) : {});
+  }
+
+  async function mergeValues() {
+    const {override1, override2, override3} = overrideValue;
+
+    // leave out empty inputs
+    const toMerge = {};
+    if (override1) {
+      toMerge.override1 = override1;
+    }
+    if (override2) {
+      toMerge.nested = {
+        override2: override2,
+      };
+    }
+    if (override3) {
+      if (!toMerge.nested) {
+        toMerge.nested = {
+          deeper: {
+            override3: override3,
+          },
+        };
+      } else {
+        toMerge.nested.deeper = {
+          override3: override3,
+        };
+      }
+    }
+
+
+    await AsyncStorage.mergeItem('MERGER', JSON.stringify(toMerge));
+  }
+
+
   return <ScrollView contentContainerStyle={{flexGrow: 1}}>
 
-    {error ? <Text style={{fontSize: 18, color: 'red'}}>{error}</Text> : null}
+    {error ? <Text style={styles.error}>{error}</Text> : null}
 
     <View style={styles.example}>
+      <Text style={styles.title}>Basic operations</Text>
       <TextInput onChangeText={setInputKey} value={inputKey} style={styles.input} placeholder="key"/>
       <TextInput onChangeText={setInputValue} value={inputValue} style={styles.input} placeholder="value"/>
-      <View style={{flexDirection: 'row', justifyContent: 'space-around'}}>
+      <View style={styles.row}>
         <Button title="Read" onPress={runWithCatch(readValue)}/>
         <Button title="Save" onPress={runWithCatch(saveValue)}/>
         <Button title="Delete" onPress={runWithCatch(removeValue)}/>
@@ -75,8 +135,8 @@ function NextExample() {
     </View>
 
     <View style={styles.example}>
-      <Text style={{fontSize: 16, fontWeight: '700'}}>Crash scenarios</Text>
-      <View style={{flexDirection: 'row', justifyContent: 'space-around'}}>
+      <Text style={styles.title}>Crash scenarios</Text>
+      <View style={styles.row}>
         <Button title="Key null" onPress={runWithCatch(crashKeyNull)}/>
         <Button title="Key not string" onPress={runWithCatch(crashKeyNotString)}/>
         <Button title="Wrong value type" onPress={runWithCatch(crashValueType)}/>
@@ -84,15 +144,45 @@ function NextExample() {
     </View>
 
     <View style={styles.example}>
-      <View style={{flexDirection: 'row', justifyContent: 'space-around'}}>
+      <Text style={styles.title}>Merging</Text>
+      <View style={styles.row}>
+        <Text>{`Value:\n\n${JSON.stringify(mergedValue, null, 2)}`}</Text>
+        <Text>{`Merge with:\n\n${JSON.stringify(overrideValue, null, 2)}`}</Text>
+      </View>
+      <View style={styles.row}>
+        <Button title="Read" onPress={runWithCatch(readMergedValue)}/>
+        <Button title="Reset" onPress={runWithCatch(resetMergedValue)}/>
+        <Button title="Merge" onPress={runWithCatch(mergeValues)}/>
+      </View>
+      <View>
+        <TextInput
+          onChangeText={t => setOverrideValue(c => ({...c, override1: t}))}
+          value={overrideValue.override1}
+          style={styles.input} placeholder="override1"
+        />
+        <TextInput
+          onChangeText={t => setOverrideValue(c => ({...c, override2: t}))}
+          value={overrideValue.override2}
+          style={styles.input} placeholder="override2"
+        />
+        <TextInput
+          onChangeText={t => setOverrideValue(c => ({...c, override3: t}))}
+          value={overrideValue.override3}
+          style={styles.input} placeholder="override3"
+        />
+      </View>
+    </View>
+
+    <View style={styles.example}>
+      <Text style={styles.title}>Display all keys</Text>
+      <View style={styles.row}>
         <Button title="Get all keys" onPress={runWithCatch(getAllKeys)}/>
       </View>
-      <Text style={{fontWeight: '700'}}>Keys:</Text>
       <Text>{keys.join(', ')}</Text>
     </View>
 
     <View style={styles.example}>
-      <Text style={{fontSize: 16}}>Clear database entries</Text>
+      <Text style={styles.title}>Clear database entries</Text>
       <Button title="clear" onPress={runWithCatch(clearDb)}/>
     </View>
   </ScrollView>;
@@ -101,7 +191,8 @@ function NextExample() {
 
 const styles = StyleSheet.create({
   example: {
-    paddingVertical: 24,
+    paddingBottom: 24,
+    paddingTop: 8,
     borderBottomWidth: 1,
     borderBottomColor: '#e3e3e3',
     borderStyle: 'solid',
@@ -112,6 +203,19 @@ const styles = StyleSheet.create({
     borderColor: '#eee',
     borderStyle: 'solid',
   },
+  error: {
+    fontSize: 18,
+    color: 'red',
+  },
+  row: {
+    flexDirection: 'row',
+    justifyContent: 'space-around',
+  },
+  title: {
+    fontSize: 16,
+    fontWeight: '700',
+    paddingBottom: 12,
+  },
 });
 
 

From 4946614afbf8098f0786e97268ccd049cf6755d1 Mon Sep 17 00:00:00 2001
From: Krzysztof Borowy <krizzu.dev@gmail.com>
Date: Wed, 3 Feb 2021 10:40:56 +0100
Subject: [PATCH 07/17] change flag name

---
 android/build.gradle                                      | 8 ++++----
 .../asyncstorage/AsyncStoragePackage.java                 | 2 +-
 example/android/gradle.properties                         | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/android/build.gradle b/android/build.gradle
index 2408efb3..9b308df1 100644
--- a/android/build.gradle
+++ b/android/build.gradle
@@ -61,10 +61,10 @@ if( newDbSize != null && newDbSize.isLong()) {
 
 // Instead of reusing AsyncTask thread pool, AsyncStorage can use its own executor
 def useDedicatedExecutor = getFlagOrDefault('AsyncStorage_dedicatedExecutor', false)
-def useRoomImplementation = getFlagOrDefault("AsyncStorage_useRoomLibrary", false)
+def useNext = getFlagOrDefault("AsyncStorage_useNext", false)
 
 apply plugin: 'com.android.library'
-if(useRoomImplementation) {
+if(useNext) {
     apply plugin: 'kotlin-android'
     apply plugin: 'kotlin-kapt'
 }
@@ -77,7 +77,7 @@ android {
         targetSdkVersion safeExtGet('targetSdkVersion', 28)
         buildConfigField "Long", "AsyncStorage_db_size", "${dbSizeInMB}L"
         buildConfigField "boolean", "AsyncStorage_useDedicatedExecutor", "${useDedicatedExecutor}"
-        buildConfigField "boolean", "AsyncStorage_useRoomLibrary", "${useRoomImplementation}"
+        buildConfigField "boolean", "AsyncStorage_useNext", "${useNext}"
     }
     lintOptions {
         abortOnError false
@@ -95,7 +95,7 @@ repositories {
 
 dependencies {
 
-    if(useRoomImplementation) {
+    if(useNext) {
         def room_version = "2.2.6"
         def coroutines_version = "1.3.9"
 
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java b/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java
index 52d53c15..7245da04 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java
@@ -24,7 +24,7 @@ public List<NativeModule> createNativeModules(ReactApplicationContext reactConte
 
         List<NativeModule> moduleList = new ArrayList<>(1);
 
-        if (BuildConfig.AsyncStorage_useRoomLibrary) {
+        if (BuildConfig.AsyncStorage_useNext) {
             try {
                 Class storageClass = Class.forName("com.reactnativecommunity.asyncstorage.next.StorageModule");
                 NativeModule inst = (NativeModule) storageClass.getDeclaredConstructor(new Class[]{ReactContext.class}).newInstance(reactContext);
diff --git a/example/android/gradle.properties b/example/android/gradle.properties
index cf69923f..20a76170 100644
--- a/example/android/gradle.properties
+++ b/example/android/gradle.properties
@@ -22,7 +22,7 @@
 
 # Enable dedicated thread pool executor
 AsyncStorage_dedicatedExecutor=true
-AsyncStorage_useRoomLibrary=true
+AsyncStorage_useNext=true
 
 android.useAndroidX=true
 android.enableJetifier=true

From d8b235cc75ef5384045577c69c5dc507230641b8 Mon Sep 17 00:00:00 2001
From: Krzysztof Borowy <krizzu.dev@gmail.com>
Date: Wed, 10 Feb 2021 21:27:22 +0100
Subject: [PATCH 08/17] change flag name, expose storage for brownfield

---
 android/build.gradle                                  |  8 ++++----
 .../asyncstorage/AsyncStoragePackage.java             |  2 +-
 .../asyncstorage/next/StorageModule.kt                | 11 +++++++++--
 3 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/android/build.gradle b/android/build.gradle
index 9b308df1..a7f32168 100644
--- a/android/build.gradle
+++ b/android/build.gradle
@@ -61,10 +61,10 @@ if( newDbSize != null && newDbSize.isLong()) {
 
 // Instead of reusing AsyncTask thread pool, AsyncStorage can use its own executor
 def useDedicatedExecutor = getFlagOrDefault('AsyncStorage_dedicatedExecutor', false)
-def useNext = getFlagOrDefault("AsyncStorage_useNext", false)
+def useNextStorage = getFlagOrDefault("AsyncStorage_useNextStorage", false)
 
 apply plugin: 'com.android.library'
-if(useNext) {
+if(useNextStorage) {
     apply plugin: 'kotlin-android'
     apply plugin: 'kotlin-kapt'
 }
@@ -77,7 +77,7 @@ android {
         targetSdkVersion safeExtGet('targetSdkVersion', 28)
         buildConfigField "Long", "AsyncStorage_db_size", "${dbSizeInMB}L"
         buildConfigField "boolean", "AsyncStorage_useDedicatedExecutor", "${useDedicatedExecutor}"
-        buildConfigField "boolean", "AsyncStorage_useNext", "${useNext}"
+        buildConfigField "boolean", "AsyncStorage_useNextStorage", "${useNextStorage}"
     }
     lintOptions {
         abortOnError false
@@ -95,7 +95,7 @@ repositories {
 
 dependencies {
 
-    if(useNext) {
+    if(useNextStorage) {
         def room_version = "2.2.6"
         def coroutines_version = "1.3.9"
 
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java b/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java
index 7245da04..c110122c 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStoragePackage.java
@@ -24,7 +24,7 @@ public List<NativeModule> createNativeModules(ReactApplicationContext reactConte
 
         List<NativeModule> moduleList = new ArrayList<>(1);
 
-        if (BuildConfig.AsyncStorage_useNext) {
+        if (BuildConfig.AsyncStorage_useNextStorage) {
             try {
                 Class storageClass = Class.forName("com.reactnativecommunity.asyncstorage.next.StorageModule");
                 NativeModule inst = (NativeModule) storageClass.getDeclaredConstructor(new Class[]{ReactContext.class}).newInstance(reactContext);
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
index b8e4f0f2..f215d8e2 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
@@ -1,5 +1,6 @@
 package com.reactnativecommunity.asyncstorage.next
 
+import android.content.Context
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Callback
 import com.facebook.react.bridge.ReactContext
@@ -20,10 +21,16 @@ class StorageModule(reactContext: ReactContext) : ReactContextBaseJavaModule(),
 
     private val storage = StorageSupplier.getInstance(reactContext)
 
+    companion object {
+        @JvmStatic
+        fun getStorageInstance(ctx: Context): AsyncStorageAccess {
+            return StorageSupplier.getInstance(ctx)
+        }
+    }
+
     /**
      * Todo:
-     *  - Documenting the migration,
-     *  - access from Native (Java interop)
+     *  - DB tests
      */
 
     @ReactMethod

From 0c2ca344398f8362e6bc2401e67990df08685132 Mon Sep 17 00:00:00 2001
From: Krzysztof Borowy <krizzu.dev@gmail.com>
Date: Wed, 10 Feb 2021 21:27:54 +0100
Subject: [PATCH 09/17] docs: document feature, brownfield integration

---
 website/docs/Linking.md                       |   1 -
 .../docs/advanced/BrownfieldIntegration.md    | 119 ++++++++++++++++++
 website/docs/advanced/DedicatedExecutor.md    |   4 +-
 website/docs/advanced/IncreaseDbSize.md       |   6 +-
 website/docs/advanced/Next.md                 |  85 +++++++++++++
 website/sidebars.js                           |   2 +-
 6 files changed, 213 insertions(+), 4 deletions(-)
 create mode 100644 website/docs/advanced/Next.md

diff --git a/website/docs/Linking.md b/website/docs/Linking.md
index 51010804..f70c1c46 100644
--- a/website/docs/Linking.md
+++ b/website/docs/Linking.md
@@ -5,7 +5,6 @@ sidebar_label: Manual linking
 ---
 
 
-
 ## iOS
 
 #### Project linking
diff --git a/website/docs/advanced/BrownfieldIntegration.md b/website/docs/advanced/BrownfieldIntegration.md
index ee40df01..49707602 100644
--- a/website/docs/advanced/BrownfieldIntegration.md
+++ b/website/docs/advanced/BrownfieldIntegration.md
@@ -7,9 +7,12 @@ import PlatformSupport from "../../src/components/Platform.js"
 
 **Supported platforms:**
 <PlatformSupport title="iOS/MacOS" platformIcon="icon_ios.svg"></PlatformSupport>
+<PlatformSupport title="Android" platformIcon="icon_android.svg"></PlatformSupport>
 
 ---
 
+# iOS
+
 If you're embedding React Native into native application, you can also integrate
 Async Storage module, so that both worlds will use one storage solution.
 
@@ -110,3 +113,119 @@ Called by `getItem` and `multiGet` in JS.
 **Optional:** Returns whether the delegate should be treated as a passthrough.
 This is useful for monitoring storage usage among other things. Returns `NO` by
 default.
+
+---
+
+# Android
+
+The recommended approach here is to use Kotlin language to leverage coroutines when accessing the storage.
+Java is also supported (through Kotlin interop), but the approach is more cumbersome.
+
+
+## Prerequisites
+
+1. [Next storage feature](Next.md) enabled.
+2. Add dependency on `coroutines-android` in your app's `build.gradle`
+
+```diff
+
+dependencies {
+  // other dependencies
+
+
+  // will work with coroutines 1.3.0 and up
++ implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.9"
+
+}
+```
+
+3. Your library of choice for parsing JSON storage values (since there are strings only)
+
+
+## Access storage
+
+### Kotlin (recommended)
+
+We use Coroutines to handle asynchronous code. Each method on storage is `suspend` method, so you need to
+call it from within a coroutine.
+
+
+#### Reading value
+
+```kotlin
+suspend fun readValue(ctx: Context, keys: List<String>) {
+    // get instance of the Storage by providing context object
+    val asyncStorage = StorageModule.getStorageInstance(ctx)
+
+    val entries: List<Entry> = asyncStorage.getValues(keys)
+    doSomethingWithValues(entries)
+}
+```
+
+#### Saving value
+
+```kotlin
+suspend fun saveValue(ctx: Context) {
+    val asyncStorage = StorageModule.getStorageInstance(ctx)
+
+    val entries = listOf(
+        Entry("myKey", "myValue")
+    )
+    asyncStorage.setValues(entries)
+}
+```
+
+
+### Java
+
+You can access AsyncStorage form Java, but you're still required to add Kotlin dependencies.
+There's no one way of accessing the data and there's more than one way to parse it.
+
+
+#### Reading from storage
+
+```java
+void readStorageValue(Context ctx, String key) {
+    AsyncStorageAccess asyncStorage = StorageModule.getStorageInstance(ctx);
+
+    BuildersKt.launch(GlobalScope.INSTANCE,
+            Dispatchers.getIO(),
+            CoroutineStart.DEFAULT,
+            (scope, continuation) -> {
+                List<String> keys = new ArrayList<>();
+                keys.add(key);
+
+                List<Entry> entries = (List<Entry>) asyncStorage.getValues(keys, (Continuation<? super List<? extends Entry>>) continuation);
+                doSomethingWithValues(entries);
+
+                return Unit.INSTANCE;
+            });
+
+}
+```
+
+
+#### Saving to storage
+
+```java
+void saveStorageValue(Context ctx, String key, String value) {
+  AsyncStorageAccess asyncStorage = StorageModule.getStorageInstance(ctx);
+
+  BuildersKt.launch(GlobalScope.INSTANCE,
+          Dispatchers.getIO(),
+          CoroutineStart.DEFAULT,
+          (scope, continuation) -> {
+
+            List<Entry> entries = new ArrayList<>();
+            Entry entry = new Entry(key, value);
+            entries.add(entry);
+
+            asyncStorage.setValues(entries, continuation);
+
+            return Unit.INSTANCE;
+          });
+}
+```
+
+
+
diff --git a/website/docs/advanced/DedicatedExecutor.md b/website/docs/advanced/DedicatedExecutor.md
index db92afcb..23b09233 100644
--- a/website/docs/advanced/DedicatedExecutor.md
+++ b/website/docs/advanced/DedicatedExecutor.md
@@ -10,10 +10,12 @@ import PlatformSupport from "../../src/components/Platform.js"
 
 ---
 
-This feature would be mostly used in brownfield apps and [in edge cases with some android devices.](https://github.com/react-native-async-storage/async-storage/issues/159)
+**Note**: This feature is obsolete when [Next storage feature is enabled](Next.md).
+
 
 ## Motivation
 
+This feature would be mostly used in brownfield apps and [in edge cases with some android devices.](https://github.com/react-native-async-storage/async-storage/issues/159)
 Dedicated thread pool executor makes `AsyncStorage` use separate thread pool for its tasks execution.
 
 Use this feature if `THREAD_POOL_EXECUTOR` from `AsyncTasks`:
diff --git a/website/docs/advanced/IncreaseDbSize.md b/website/docs/advanced/IncreaseDbSize.md
index 4ffadb05..129c49b3 100644
--- a/website/docs/advanced/IncreaseDbSize.md
+++ b/website/docs/advanced/IncreaseDbSize.md
@@ -10,9 +10,13 @@ import PlatformSupport from "../../src/components/Platform.js"
 
 ---
 
+**Note**: This feature is obsolete when [Next storage feature is enabled](Next.md).
+
+## Motivation
+
 Current Async Storage's size is set to 6MB. Going over this limit causes `database or disk is full` error. This 6MB limit is a sane limit to protect the user from the app storing too much data in the database. This also protects the database from filling up the disk cache and becoming malformed (endTransaction() calls will throw an exception, not rollback, and leave the db malformed). You have to be aware of that risk when increasing the database size. We recommend to ensure that your app does not write more data to AsyncStorage than space is left on disk. Since AsyncStorage is based on SQLite on Android you also have to be aware of the [SQLite limits](https://www.sqlite.org/limits.html).
 
-### Increase limit
+## Increase limit
 
 Add a `AsyncStorage_db_size_in_MB` property to your `android/gradle.properties`:
 
diff --git a/website/docs/advanced/Next.md b/website/docs/advanced/Next.md
new file mode 100644
index 00000000..c01e3009
--- /dev/null
+++ b/website/docs/advanced/Next.md
@@ -0,0 +1,85 @@
+---
+id: next
+title: Next storage implementation
+sidebar_label: Next storage implementation
+---
+import PlatformSupport from "../../src/components/Platform.js"
+
+**Supported platforms:**
+<PlatformSupport title="Android" platformIcon="icon_android.svg"></PlatformSupport>
+
+---
+
+### Motivation
+
+Current implementation of persistence layer is created using [SQLiteOpenHelper](https://developer.android.com/reference/android/database/sqlite/SQLiteOpenHelper), 
+a helper class that manages database creation and migrations. Even if this approach is powerful, the lack of compile time query verification and a big boilerplate of mapping SQLite queries  to actual values make this implementation prone to many errors.
+
+This Async Storage feature improves the persistence layer, using modern approaches to access SQLite (using [Room](https://developer.android.com/training/data-storage/room)), to reduce possible anomalies to the minimum. 
+On top of that, it allows to access Async Storage from the native side, useful in [Brownfield integration.](BrownfieldIntegration.md#android)
+
+### Migration
+
+This feature requires no migration from the developer perspective - the current database will be recreated (based on the current one), meaning user won't lose any data if you decide to opt in.
+There's a small drawback to know - the database "recreation" happens **only once**. Unless you want to disable the feature in the future, there's nothing to worry about.
+
+#### How it works
+
+The new database (the one used by this feature) will be created based on the current database file, if the new one does not exist yet. 
+If we detect that there's already the new database on the device, recreation will not kick in.
+
+
+#### Why is it important
+
+Let's say you enabled the feature for the first time - recreation kicks in and the old database file is untouched.
+If you decide to disable the feature, your users will be back using old database. No data migrations is happening from new to old database file.
+When you enable the feature again, the new database is **not** recreated, because it already exists, and no data is copied over.
+
+
+### Enabling
+
+1. In your project's `android` directory, locate root `build.gradle` file. Add Kotlin dependency to the `buildscript`:
+
+```diff
+buildscript {
+    ext {
+        // other extensions
++        kotlinVersion = '1.4.21'
+    }
+    
+    dependencies {
+        // other dependencies
++        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
+    }
+}
+
+```
+
+2. In the same directory (normally `android`) locate `gradle.properties` file (if does not exists, create one) and add the line:
+
+```groovy
+AsyncStorage_useNextStorage=true
+```
+
+**How to specifying Kotlin version**
+
+Supported Kotlin versions are `1.4.x`. You can specify which one to use in two ways:
+
+- having an `kotlinVersion` extension on the `rootProject` (recommended):
+
+```groovy
+rootProject.ext.kotlinVersion = '1.4.21'
+```
+
+- specify `AsyncStorage_kotlinVersion` in `gradle.properties`:
+
+```groovy
+AsyncStorage_kotlinVersion=1.4.21
+```
+
+### Notable changes
+
+Alongside of a warning regarding `key`/`value`, errors are thrown when:
+
+- Your `key` is `null` or `not a string`
+- You provide value that is `not a string` 
diff --git a/website/sidebars.js b/website/sidebars.js
index 3646e727..dfcd614e 100644
--- a/website/sidebars.js
+++ b/website/sidebars.js
@@ -1,7 +1,7 @@
 module.exports = {
   docs: {
     'Getting started': ['install', 'usage', 'link', 'api'],
-    Advanced: ['advanced/jest', 'advanced/brownfield', 'advanced/backup', 'advanced/executor', 'advanced/db_size'],
+    Advanced: ['advanced/next', 'advanced/jest', 'advanced/brownfield', 'advanced/backup', 'advanced/executor', 'advanced/db_size'],
     Help: ['help/troubleshooting'],
   },
 };

From ff4391898b33e541f12aa5dd62abab1d3376d737 Mon Sep 17 00:00:00 2001
From: Krzysztof Borowy <krizzu.dev@gmail.com>
Date: Sat, 13 Feb 2021 22:54:39 +0100
Subject: [PATCH 10/17] tests

---
 android/build.gradle                          |  28 +++-
 android/gradle.properties                     |   1 +
 .../asyncstorage/next/ArgumentHelpers.kt      |   2 +-
 .../asyncstorage/next/StorageSupplier.kt      |  42 ++---
 .../asyncstorage/next/ArgumentHelpersTest.kt  |  88 ++++++++++
 .../asyncstorage/next/StorageTest.kt          | 152 ++++++++++++++++++
 .../asyncstorage/next/TestUtils.kt            |  84 ++++++++++
 android/testresults.gradle                    |  38 +++++
 example/android/build.gradle                  |   7 -
 example/android/gradle.properties             |   2 +-
 10 files changed, 404 insertions(+), 40 deletions(-)
 create mode 100644 android/gradle.properties
 create mode 100644 android/src/test/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpersTest.kt
 create mode 100644 android/src/test/java/com/reactnativecommunity/asyncstorage/next/StorageTest.kt
 create mode 100644 android/src/test/java/com/reactnativecommunity/asyncstorage/next/TestUtils.kt
 create mode 100644 android/testresults.gradle

diff --git a/android/build.gradle b/android/build.gradle
index a7f32168..8c4e1e0b 100644
--- a/android/build.gradle
+++ b/android/build.gradle
@@ -55,7 +55,7 @@ buildscript {
 // If you really need bigger size, please keep in mind the potential consequences.
 long dbSizeInMB = 6L
 def newDbSize = rootProject.properties['AsyncStorage_db_size_in_MB']
-if( newDbSize != null && newDbSize.isLong()) {
+if (newDbSize != null && newDbSize.isLong()) {
     dbSizeInMB = newDbSize.toLong()
 }
 
@@ -64,9 +64,10 @@ def useDedicatedExecutor = getFlagOrDefault('AsyncStorage_dedicatedExecutor', fa
 def useNextStorage = getFlagOrDefault("AsyncStorage_useNextStorage", false)
 
 apply plugin: 'com.android.library'
-if(useNextStorage) {
+if (useNextStorage) {
     apply plugin: 'kotlin-android'
     apply plugin: 'kotlin-kapt'
+    apply from: './testresults.gradle'
 }
 
 android {
@@ -82,6 +83,12 @@ android {
     lintOptions {
         abortOnError false
     }
+
+    if (useNextStorage) {
+        testOptions {
+            unitTests.returnDefaultValues = true
+        }
+    }
 }
 
 repositories {
@@ -95,13 +102,26 @@ repositories {
 
 dependencies {
 
-    if(useNextStorage) {
+    if (useNextStorage) {
         def room_version = "2.2.6"
-        def coroutines_version = "1.3.9"
+        def coroutines_version = "1.4.2"
+        def junit_version = "4.12"
+        def robolectric_version = "4.2.1"
+        def truth_version = "1.1.2"
+        def androidxtest_version = "1.1.0"
+        def coroutinesTest_version = "1.4.2"
 
         implementation "androidx.room:room-runtime:$room_version"
         implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutines_version"
         kapt "androidx.room:room-compiler:$room_version"
+
+        testImplementation "junit:junit:$junit_version"
+        testImplementation "androidx.test:runner:$androidxtest_version"
+        testImplementation "androidx.test:rules:$androidxtest_version"
+        testImplementation "androidx.test.ext:junit:$androidxtest_version"
+        testImplementation "org.robolectric:robolectric:$robolectric_version"
+        testImplementation "com.google.truth:truth:$truth_version"
+        testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:$coroutinesTest_version"
     }
 
     //noinspection GradleDynamicVersion
diff --git a/android/gradle.properties b/android/gradle.properties
new file mode 100644
index 00000000..2d8d1e4d
--- /dev/null
+++ b/android/gradle.properties
@@ -0,0 +1 @@
+android.useAndroidX=true
\ No newline at end of file
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt
index 081cb519..bb03e5da 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt
@@ -35,7 +35,7 @@ fun ReadableArray.toKeyList(): List<String> {
 
     for (item in list) {
         if (item !is String) {
-            throw AsyncStorageError.keyIsNull()
+            throw AsyncStorageError.keyNotString()
         }
     }
     return list as List<String>
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt
index b610b6b7..e3e5c130 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt
@@ -31,7 +31,19 @@ data class Entry(
 )
 
 @Dao
-private interface StorageDao {
+internal interface StorageDao {
+
+    @Transaction
+    @Query("SELECT * FROM $TABLE_NAME WHERE `$COLUMN_KEY` IN (:keys)")
+    fun getValues(keys: List<String>): List<Entry>
+
+    @Transaction
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    fun setValues(entries: List<Entry>)
+
+    @Transaction
+    @Query("DELETE FROM $TABLE_NAME WHERE `$COLUMN_KEY` in (:keys)")
+    fun removeValues(keys: List<String>)
 
     @Transaction
     fun mergeValues(entries: List<Entry>) {
@@ -53,22 +65,6 @@ private interface StorageDao {
         setValues(newEntries)
     }
 
-    @Transaction
-    @Query("SELECT * FROM $TABLE_NAME WHERE `$COLUMN_KEY` IN (:keys)")
-    fun getValues(keys: List<String>): List<Entry>
-
-    @Transaction
-    fun setValues(entries: List<Entry>) {
-        val insertResult = insert(entries)
-        with(entries.filterIndexed { i, _ -> insertResult[i] == -1L }) {
-            update(this)
-        }
-    }
-
-    @Transaction
-    @Query("DELETE FROM $TABLE_NAME WHERE `$COLUMN_KEY` in (:keys)")
-    fun removeValues(keys: List<String>)
-
     @Transaction
     @Query("SELECT `$COLUMN_KEY` FROM $TABLE_NAME")
     fun getKeys(): List<String>
@@ -76,14 +72,6 @@ private interface StorageDao {
     @Transaction
     @Query("DELETE FROM $TABLE_NAME")
     fun clear()
-
-
-    // insert and update are components of setValues - not to be used separately
-    @Insert(onConflict = OnConflictStrategy.IGNORE)
-    fun insert(entries: List<Entry>): List<Long>
-
-    @Update
-    fun update(entries: List<Entry>)
 }
 
 
@@ -120,7 +108,7 @@ private object MIGRATION_TO_NEXT : Migration(1, 2) {
 }
 
 @Database(entities = [Entry::class], version = DATABASE_VERSION, exportSchema = true)
-private abstract class StorageDb : RoomDatabase() {
+internal abstract class StorageDb : RoomDatabase() {
     abstract fun storage(): StorageDao
 
     companion object {
@@ -160,7 +148,7 @@ interface AsyncStorageAccess {
     suspend fun mergeValues(entries: List<Entry>)
 }
 
-class StorageSupplier private constructor(db: StorageDb) : AsyncStorageAccess {
+class StorageSupplier internal constructor(db: StorageDb) : AsyncStorageAccess {
     companion object {
         fun getInstance(ctx: Context): AsyncStorageAccess {
             return StorageSupplier(StorageDb.getDatabase(ctx))
diff --git a/android/src/test/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpersTest.kt b/android/src/test/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpersTest.kt
new file mode 100644
index 00000000..bd79b1a3
--- /dev/null
+++ b/android/src/test/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpersTest.kt
@@ -0,0 +1,88 @@
+package com.reactnativecommunity.asyncstorage.next
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.Assert.assertThrows
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.BlockJUnit4ClassRunner
+
+@RunWith(BlockJUnit4ClassRunner::class)
+class ArgumentHelpersTest {
+
+    @Test
+    fun transformsArgumentsToEntryList() {
+        val keyValue1 = arrayListOf("key1", "value1")
+        val keyValue2 = arrayListOf("key2", "value2")
+        val keyValue3 = arrayListOf("key3", "value3")
+
+        val args = createNativeCallArguments(keyValue1, keyValue2, keyValue3)
+
+        assertThat(args.toEntryList()).isEqualTo(
+            listOf(
+                Entry("key1", "value1"),
+                Entry("key2", "value2"),
+                Entry("key3", "value3"),
+            )
+        )
+    }
+
+    @Test
+    fun transfersArgumentsToKeyList() {
+        val keyList = listOf("key1", "key2", "key3")
+
+        val args = createNativeCallArguments("key1", "key2", "key3")
+
+        assertThat(args.toKeyList()).isEqualTo(keyList)
+    }
+
+    @Test
+    fun throwsIfArgumentsNotValidFormat() {
+        val invalid = arrayListOf("invalid")
+        val args = createNativeCallArguments(invalid)
+
+        val error = assertThrows(AsyncStorageError::class.java) {
+            args.toEntryList()
+        }
+
+        assertThat(error is AsyncStorageError).isTrue()
+        assertThat(error).hasMessageThat()
+            .isEqualTo("Invalid key-value format. Expected a list of [key, value] list.")
+    }
+
+    @Test
+    fun throwsIfArgumentKeyIsNullOrNotString() {
+        val argsInvalidNull = createNativeCallArguments(arrayListOf(null, "invalid"))
+
+        val errorArgsInvalidNull = assertThrows(AsyncStorageError::class.java) {
+            argsInvalidNull.toEntryList()
+        }
+        assertThat(errorArgsInvalidNull is AsyncStorageError).isTrue()
+        assertThat(errorArgsInvalidNull).hasMessageThat().isEqualTo("Key cannot be null.")
+
+
+        val notStringArgs = createNativeCallArguments(arrayListOf(123, "invalid"))
+
+        val errorNotString = assertThrows(AsyncStorageError::class.java) {
+            notStringArgs.toEntryList()
+        }
+        assertThat(errorNotString is AsyncStorageError).isTrue()
+        assertThat(errorNotString).hasMessageThat()
+            .isEqualTo("Provided key is not string. Only strings are supported as storage key.")
+    }
+
+    @Test
+    fun throwsIfArgumentValueNotString() {
+        val invalidArgs = createNativeCallArguments(arrayListOf("my_key", 666))
+
+        val error = assertThrows(AsyncStorageError::class.java) {
+            invalidArgs.toEntryList()
+        }
+
+        assertThat(error is AsyncStorageError).isTrue()
+        assertThat(error).hasMessageThat()
+            .isEqualTo("Value for key \"my_key\" is not a string. Only strings are supported as a value.")
+    }
+}
+
+
+
diff --git a/android/src/test/java/com/reactnativecommunity/asyncstorage/next/StorageTest.kt b/android/src/test/java/com/reactnativecommunity/asyncstorage/next/StorageTest.kt
new file mode 100644
index 00000000..a8a8fa35
--- /dev/null
+++ b/android/src/test/java/com/reactnativecommunity/asyncstorage/next/StorageTest.kt
@@ -0,0 +1,152 @@
+package com.reactnativecommunity.asyncstorage.next
+
+import androidx.room.Room
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runBlockingTest
+import org.json.JSONObject
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import kotlin.random.Random
+
+@ExperimentalCoroutinesApi
+@RunWith(AndroidJUnit4::class)
+class AsyncStorageAccessTest {
+
+    private lateinit var asyncStorage: AsyncStorageAccess
+    private lateinit var database: StorageDb
+
+    @Before
+    fun setup() {
+        database = Room.inMemoryDatabaseBuilder(
+            InstrumentationRegistry.getInstrumentation().context, StorageDb::class.java
+        ).allowMainThreadQueries().build()
+
+        asyncStorage = StorageSupplier(database)
+    }
+
+    @After
+    fun tearDown() {
+        database.close()
+    }
+
+    @Test
+    fun performsBasicGetSetRemoveOperations() = runBlockingTest {
+        val entriesCount = 10
+        val entries = createRandomEntries(entriesCount)
+        val keys = entries.map { it.key }
+
+        assertThat(asyncStorage.getValues(keys)).hasSize(0)
+        asyncStorage.setValues(entries)
+        assertThat(asyncStorage.getValues(keys)).hasSize(entriesCount)
+
+        val indicesToRemove = (1..4).map { Random.nextInt(0, entriesCount) }.distinct()
+        val toRemove = entries.filterIndexed { index, _ -> indicesToRemove.contains(index) }
+
+        asyncStorage.removeValues(toRemove.map { it.key })
+        val currentEntries = asyncStorage.getValues(keys)
+        assertThat(currentEntries).hasSize(entriesCount - toRemove.size)
+    }
+
+    @Test
+    fun readsAllKeysAndClearsDb() = runBlockingTest {
+        val entries = createRandomEntries(8)
+        val keys = entries.map { it.key }
+        asyncStorage.setValues(entries)
+        val dbKeys = asyncStorage.getKeys()
+        assertThat(dbKeys).isEqualTo(keys)
+        asyncStorage.clear()
+        assertThat(asyncStorage.getValues(keys)).hasSize(0)
+    }
+
+    @Test
+    fun mergesDeeplyTwoValues() = runBlockingTest {
+        val initialEntry = Entry("key", VALUE_INITIAL)
+        val overrideEntry = Entry("key", VALUE_OVERRIDES)
+
+        asyncStorage.setValues(listOf(initialEntry))
+        asyncStorage.mergeValues(listOf(overrideEntry))
+
+        val current = asyncStorage.getValues(listOf("key"))[0]
+
+        assertThat(current.value).isEqualTo(VALUE_MERGED)
+    }
+
+    @Test
+    fun updatesExistingValues() = runBlockingTest {
+        val key = "test_key"
+        val value = "test_value"
+        val entries = listOf(Entry(key, value))
+
+        assertThat(asyncStorage.getValues(listOf(key))).hasSize(0)
+        asyncStorage.setValues(entries)
+        assertThat(asyncStorage.getValues(listOf(key))).isEqualTo(entries)
+
+        val modifiedEntries = listOf(Entry(key, "updatedValue"))
+
+        asyncStorage.setValues(modifiedEntries)
+        assertThat(asyncStorage.getValues(listOf(key))).isEqualTo(modifiedEntries)
+    }
+
+
+    // Test Helpers
+    private fun createRandomEntries(count: Int = Random.nextInt(10)): List<Entry> {
+        val entries = mutableListOf<Entry>()
+        for (i in 0 until count) {
+            entries.add(Entry("key$i", "value$i"))
+        }
+        return entries
+    }
+
+    private val VALUE_INITIAL = JSONObject(
+        """
+    {
+       "key":"value",
+       "key2":"override",
+       "key3":{
+          "key4":"value4",
+          "key6":{
+             "key7":"value7",
+             "key8":"override"
+          }
+       }
+    }
+""".trimMargin()
+    ).toString()
+
+    private val VALUE_OVERRIDES = JSONObject(
+        """
+    {
+       "key2":"value2",
+       "key3":{
+          "key5":"value5",
+          "key6":{
+             "key8":"value8"
+          }
+       }
+    }
+"""
+    ).toString()
+
+
+    private val VALUE_MERGED = JSONObject(
+        """
+    {
+       "key":"value",
+       "key2":"value2",
+       "key3":{
+          "key4":"value4",
+          "key5":"value5",
+          "key6":{
+             "key7":"value7",
+             "key8":"value8"
+          }
+       }
+    }
+""".trimMargin()
+    ).toString()
+}
\ No newline at end of file
diff --git a/android/src/test/java/com/reactnativecommunity/asyncstorage/next/TestUtils.kt b/android/src/test/java/com/reactnativecommunity/asyncstorage/next/TestUtils.kt
new file mode 100644
index 00000000..37ce839c
--- /dev/null
+++ b/android/src/test/java/com/reactnativecommunity/asyncstorage/next/TestUtils.kt
@@ -0,0 +1,84 @@
+package com.reactnativecommunity.asyncstorage.next
+
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableArray
+
+fun <T : Any> createNativeCallArguments(vararg list: T): ReadableArray {
+    val args = ArrayList(list.toList())
+    return TestingArguments(args)
+}
+
+internal class TestingArguments<T : Any>(initBackingArray: ArrayList<T> = arrayListOf()) :
+    WritableArray {
+    private val backArray: ArrayList<T> = initBackingArray
+    override fun size() = backArray.size
+
+    override fun toArrayList(): ArrayList<Any> = backArray as ArrayList<Any>
+
+    override fun isNull(index: Int): Boolean {
+        TODO("ignored")
+    }
+
+    override fun getBoolean(index: Int): Boolean {
+        TODO("ignored")
+    }
+
+    override fun getDouble(index: Int): Double {
+        TODO("ignored")
+    }
+
+    override fun getInt(index: Int): Int {
+        TODO("ignored")
+    }
+
+    override fun getString(index: Int): String? {
+        TODO("ignored")
+    }
+
+    override fun getArray(index: Int): ReadableArray? {
+        TODO("ignored")
+    }
+
+    override fun getMap(index: Int): ReadableMap? {
+        TODO("ignored")
+    }
+
+    override fun getDynamic(index: Int): Dynamic {
+        TODO("ignored")
+    }
+
+    override fun getType(index: Int): ReadableType {
+        TODO("ignored")
+    }
+
+    override fun pushNull() {
+        TODO("ignored")
+    }
+
+    override fun pushBoolean(value: Boolean) {
+        TODO("ignored")
+    }
+
+    override fun pushDouble(value: Double) {
+        TODO("ignored")
+    }
+
+    override fun pushInt(value: Int) {
+        TODO("ignored")
+    }
+
+    override fun pushString(value: String?) {
+        TODO("ignored")
+    }
+
+    override fun pushArray(array: ReadableArray?) {
+        TODO("ignore")
+    }
+
+    override fun pushMap(map: ReadableMap?) {
+        TODO("ignored")
+    }
+}
\ No newline at end of file
diff --git a/android/testresults.gradle b/android/testresults.gradle
new file mode 100644
index 00000000..50ad3e8d
--- /dev/null
+++ b/android/testresults.gradle
@@ -0,0 +1,38 @@
+
+// pretty print test results
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+import org.gradle.api.tasks.testing.logging.TestLogEvent
+tasks.withType(Test) {
+    testLogging {
+
+        events TestLogEvent.FAILED,
+                TestLogEvent.PASSED,
+                TestLogEvent.SKIPPED,
+                TestLogEvent.STANDARD_OUT
+        exceptionFormat TestExceptionFormat.FULL
+        showExceptions true
+        showCauses true
+        showStackTraces true
+
+        debug {
+            events TestLogEvent.STARTED,
+                    TestLogEvent.FAILED,
+                    TestLogEvent.PASSED,
+                    TestLogEvent.SKIPPED,
+                    TestLogEvent.STANDARD_ERROR,
+                    TestLogEvent.STANDARD_OUT
+            exceptionFormat TestExceptionFormat.FULL
+        }
+        info.events = debug.events
+        info.exceptionFormat = debug.exceptionFormat
+
+        afterSuite { desc, result ->
+            if (!desc.parent) { // will match the outermost suite
+                def output = "Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} passed, ${result.failedTestCount} failed, ${result.skippedTestCount} skipped)"
+                def startItem = '|  ', endItem = '  |'
+                def repeatLength = startItem.length() + output.length() + endItem.length()
+                println('\n' + ('-' * repeatLength) + '\n' + startItem + output + endItem + '\n' + ('-' * repeatLength))
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/example/android/build.gradle b/example/android/build.gradle
index 2b4b2955..f34c8f4c 100644
--- a/example/android/build.gradle
+++ b/example/android/build.gradle
@@ -26,11 +26,6 @@ task fetchDependencies() {
 }
 
 buildscript {
-    /**
-     * Todo:
-     *  In order to use this feature, the end user will have to also include
-     *  Kotlin plugin. Add this info to docs.
-     */
     ext.kotlinVersion = '1.4.21'
 
     repositories {
@@ -40,8 +35,6 @@ buildscript {
     dependencies {
         // Needs to match `react-native-test-app/android/app/build.gradle`
         classpath "com.android.tools.build:gradle:4.0.2"
-
-        // todo: remember to document this as well
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
     }
 }
diff --git a/example/android/gradle.properties b/example/android/gradle.properties
index 20a76170..e04534df 100644
--- a/example/android/gradle.properties
+++ b/example/android/gradle.properties
@@ -22,7 +22,7 @@
 
 # Enable dedicated thread pool executor
 AsyncStorage_dedicatedExecutor=true
-AsyncStorage_useNext=true
+AsyncStorage_useNextStorage=true
 
 android.useAndroidX=true
 android.enableJetifier=true

From 292b0872edf6fbe9b1205a90466864908e87cb50 Mon Sep 17 00:00:00 2001
From: Krzysztof Borowy <krizzu.dev@gmail.com>
Date: Sat, 13 Feb 2021 23:37:14 +0100
Subject: [PATCH 11/17] circle job

---
 .circleci/config.yml | 47 +++++++++++++++++++++++++++++++++-----------
 1 file changed, 36 insertions(+), 11 deletions(-)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index b9fc50ef..87cc5f7a 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -151,6 +151,26 @@ jobs:
           name: Flow check
           command: yarn test:flow
 
+  "Test: Android unit":
+    <<: *android_defaults
+    steps:
+      - *addWorkspace
+      - restore-cache: *cache_restore_yarn
+      - run:
+          name: Installing Yarn dependencies
+          command: yarn --pure-lockfile --non-interactive --cache-folder ~/.cache/yarn
+      - save-cache: *cache_save_yarn
+      - restore-cache: *cache_restore_gradle
+      - run:
+          name: Downloading Gradle dependencies
+          working_directory: example/android
+          command: ./gradlew --max-workers 2 fetchDependencies
+      - save-cache: *cache_save_gradle
+      - run:
+          name: Next storage tests
+          working_directory: example/android
+          command: ./gradlew react-native-async-storage_async-storage:test
+
   "Test: iOS e2e":
     <<: *macos_defaults
     steps:
@@ -188,21 +208,22 @@ jobs:
           name: Run e2e tests
           command: yarn test:e2e:ios
 
+
   "Build: Android release apk":
     <<: *android_defaults
     steps:
       - *addWorkspace
-      - restore-cache: *cache_restore_yarn
-      - run:
-          name: Installing Yarn dependencies
-          command: yarn --pure-lockfile --non-interactive --cache-folder ~/.cache/yarn
-      - save-cache: *cache_save_yarn
-      - restore-cache: *cache_restore_gradle
-      - run:
-          name: Downloading Gradle dependencies
-          working_directory: example/android
-          command: ./gradlew --max-workers 2 fetchDependencies
-      - save-cache: *cache_save_gradle
+#      - restore-cache: *cache_restore_yarn
+#      - run:
+#          name: Installing Yarn dependencies
+#          command: yarn --pure-lockfile --non-interactive --cache-folder ~/.cache/yarn
+#      - save-cache: *cache_save_yarn
+#      - restore-cache: *cache_restore_gradle
+#      - run:
+#          name: Downloading Gradle dependencies
+#          working_directory: example/android
+#          command: ./gradlew --max-workers 2 fetchDependencies
+#      - save-cache: *cache_save_gradle
       - run:
           name: Bundle JS
           command: yarn bundle:android --dev false
@@ -306,6 +327,9 @@ workflows:
       - "Test: flow":
           requires:
             - "Setup environment"
+      - "Test: Android unit":
+          requires:
+            - "Setup environment"
       - "Test: iOS e2e":
           requires:
             - "Test: lint"
@@ -314,6 +338,7 @@ workflows:
           requires:
             - "Test: lint"
             - "Test: flow"
+            - "Test: Android unit"
       - "Test: Android e2e":
           requires:
             - "Build: Android release apk"

From 942a88532129f9ae3c2cf70fc8a7f6f60bbb1f22 Mon Sep 17 00:00:00 2001
From: Krzysztof Borowy <krizzu.dev@gmail.com>
Date: Mon, 15 Feb 2021 10:19:06 +0100
Subject: [PATCH 12/17] cleanup

---
 .circleci/config.yml                          | 14 +-------------
 android/build.gradle                          |  2 ++
 .../asyncstorage/next/StorageModule.kt        |  5 -----
 .../asyncstorage/next/StorageSupplier.kt      |  7 -------
 .../asyncstorage/next/ArgumentHelpersTest.kt  | 19 +++++--------------
 .../asyncstorage/next/StorageTest.kt          | 10 ----------
 example/examples/Basic.js                     |  2 --
 7 files changed, 8 insertions(+), 51 deletions(-)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index 87cc5f7a..e5e93d65 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -208,22 +208,10 @@ jobs:
           name: Run e2e tests
           command: yarn test:e2e:ios
 
-
   "Build: Android release apk":
     <<: *android_defaults
     steps:
       - *addWorkspace
-#      - restore-cache: *cache_restore_yarn
-#      - run:
-#          name: Installing Yarn dependencies
-#          command: yarn --pure-lockfile --non-interactive --cache-folder ~/.cache/yarn
-#      - save-cache: *cache_save_yarn
-#      - restore-cache: *cache_restore_gradle
-#      - run:
-#          name: Downloading Gradle dependencies
-#          working_directory: example/android
-#          command: ./gradlew --max-workers 2 fetchDependencies
-#      - save-cache: *cache_save_gradle
       - run:
           name: Bundle JS
           command: yarn bundle:android --dev false
@@ -293,7 +281,7 @@ jobs:
                 -no-snapshot \
                 -no-boot-anim \
                 -no-window \
-                -logcat '*:W' | grep -i "ReactNative"
+                -logcat '*:E ReactNative:W ReactNativeJS:*'
       - run:
           name: Wait for emulator to boot
           command: ./scripts/android_e2e.sh 'wait_for_emulator'
diff --git a/android/build.gradle b/android/build.gradle
index 8c4e1e0b..282dd6a6 100644
--- a/android/build.gradle
+++ b/android/build.gradle
@@ -61,6 +61,8 @@ if (newDbSize != null && newDbSize.isLong()) {
 
 // Instead of reusing AsyncTask thread pool, AsyncStorage can use its own executor
 def useDedicatedExecutor = getFlagOrDefault('AsyncStorage_dedicatedExecutor', false)
+
+// Use next storage implementation
 def useNextStorage = getFlagOrDefault("AsyncStorage_useNextStorage", false)
 
 apply plugin: 'com.android.library'
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
index f215d8e2..47575fc7 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
@@ -28,11 +28,6 @@ class StorageModule(reactContext: ReactContext) : ReactContextBaseJavaModule(),
         }
     }
 
-    /**
-     * Todo:
-     *  - DB tests
-     */
-
     @ReactMethod
     fun multiGet(keys: ReadableArray, cb: Callback) {
         launch(createExceptionHandler(cb)) {
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt
index e3e5c130..3074979e 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt
@@ -90,13 +90,10 @@ internal interface StorageDao {
 private object MIGRATION_TO_NEXT : Migration(1, 2) {
     override fun migrate(database: SupportSQLiteDatabase) {
         val oldTableName = "catalystLocalStorage" // from ReactDatabaseSupplier
-
         database.execSQL("CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`${COLUMN_KEY}` TEXT NOT NULL, `${COLUMN_VALUE}` TEXT, PRIMARY KEY(`${COLUMN_KEY}`));")
-
         // even if the old AsyncStorage has checks for not nullable keys
         // make sure we don't copy any, to not fail migration
         database.execSQL("DELETE FROM $oldTableName WHERE `${COLUMN_KEY}` IS NULL")
-
         database.execSQL(
             """
             INSERT INTO $TABLE_NAME (`${COLUMN_KEY}`, `${COLUMN_VALUE}`)
@@ -119,18 +116,15 @@ internal abstract class StorageDb : RoomDatabase() {
             if (inst != null) {
                 return inst
             }
-
             synchronized(this) {
                 val oldDbFile = context.getDatabasePath("RKStorage")
                 val db = Room.databaseBuilder(
                     context, StorageDb::class.java, DATABASE_NAME
                 )
-
                 if (oldDbFile.exists()) {
                     // migrate data from old database, if it exists
                     db.createFromFile(oldDbFile).addMigrations(MIGRATION_TO_NEXT)
                 }
-
                 inst = db.build()
                 instance = inst
                 return instance!!
@@ -154,7 +148,6 @@ class StorageSupplier internal constructor(db: StorageDb) : AsyncStorageAccess {
             return StorageSupplier(StorageDb.getDatabase(ctx))
         }
     }
-
     private val access = db.storage()
 
     override suspend fun getValues(keys: List<String>) = access.getValues(keys)
diff --git a/android/src/test/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpersTest.kt b/android/src/test/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpersTest.kt
index bd79b1a3..34238ea7 100644
--- a/android/src/test/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpersTest.kt
+++ b/android/src/test/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpersTest.kt
@@ -11,12 +11,11 @@ class ArgumentHelpersTest {
 
     @Test
     fun transformsArgumentsToEntryList() {
-        val keyValue1 = arrayListOf("key1", "value1")
-        val keyValue2 = arrayListOf("key2", "value2")
-        val keyValue3 = arrayListOf("key3", "value3")
-
-        val args = createNativeCallArguments(keyValue1, keyValue2, keyValue3)
-
+        val args = createNativeCallArguments(
+            arrayListOf("key1", "value1"),
+            arrayListOf("key2", "value2"),
+            arrayListOf("key3", "value3")
+        )
         assertThat(args.toEntryList()).isEqualTo(
             listOf(
                 Entry("key1", "value1"),
@@ -29,9 +28,7 @@ class ArgumentHelpersTest {
     @Test
     fun transfersArgumentsToKeyList() {
         val keyList = listOf("key1", "key2", "key3")
-
         val args = createNativeCallArguments("key1", "key2", "key3")
-
         assertThat(args.toKeyList()).isEqualTo(keyList)
     }
 
@@ -39,7 +36,6 @@ class ArgumentHelpersTest {
     fun throwsIfArgumentsNotValidFormat() {
         val invalid = arrayListOf("invalid")
         val args = createNativeCallArguments(invalid)
-
         val error = assertThrows(AsyncStorageError::class.java) {
             args.toEntryList()
         }
@@ -52,16 +48,13 @@ class ArgumentHelpersTest {
     @Test
     fun throwsIfArgumentKeyIsNullOrNotString() {
         val argsInvalidNull = createNativeCallArguments(arrayListOf(null, "invalid"))
-
         val errorArgsInvalidNull = assertThrows(AsyncStorageError::class.java) {
             argsInvalidNull.toEntryList()
         }
         assertThat(errorArgsInvalidNull is AsyncStorageError).isTrue()
         assertThat(errorArgsInvalidNull).hasMessageThat().isEqualTo("Key cannot be null.")
 
-
         val notStringArgs = createNativeCallArguments(arrayListOf(123, "invalid"))
-
         val errorNotString = assertThrows(AsyncStorageError::class.java) {
             notStringArgs.toEntryList()
         }
@@ -73,11 +66,9 @@ class ArgumentHelpersTest {
     @Test
     fun throwsIfArgumentValueNotString() {
         val invalidArgs = createNativeCallArguments(arrayListOf("my_key", 666))
-
         val error = assertThrows(AsyncStorageError::class.java) {
             invalidArgs.toEntryList()
         }
-
         assertThat(error is AsyncStorageError).isTrue()
         assertThat(error).hasMessageThat()
             .isEqualTo("Value for key \"my_key\" is not a string. Only strings are supported as a value.")
diff --git a/android/src/test/java/com/reactnativecommunity/asyncstorage/next/StorageTest.kt b/android/src/test/java/com/reactnativecommunity/asyncstorage/next/StorageTest.kt
index a8a8fa35..296cf39f 100644
--- a/android/src/test/java/com/reactnativecommunity/asyncstorage/next/StorageTest.kt
+++ b/android/src/test/java/com/reactnativecommunity/asyncstorage/next/StorageTest.kt
@@ -16,7 +16,6 @@ import kotlin.random.Random
 @ExperimentalCoroutinesApi
 @RunWith(AndroidJUnit4::class)
 class AsyncStorageAccessTest {
-
     private lateinit var asyncStorage: AsyncStorageAccess
     private lateinit var database: StorageDb
 
@@ -39,14 +38,11 @@ class AsyncStorageAccessTest {
         val entriesCount = 10
         val entries = createRandomEntries(entriesCount)
         val keys = entries.map { it.key }
-
         assertThat(asyncStorage.getValues(keys)).hasSize(0)
         asyncStorage.setValues(entries)
         assertThat(asyncStorage.getValues(keys)).hasSize(entriesCount)
-
         val indicesToRemove = (1..4).map { Random.nextInt(0, entriesCount) }.distinct()
         val toRemove = entries.filterIndexed { index, _ -> indicesToRemove.contains(index) }
-
         asyncStorage.removeValues(toRemove.map { it.key })
         val currentEntries = asyncStorage.getValues(keys)
         assertThat(currentEntries).hasSize(entriesCount - toRemove.size)
@@ -67,12 +63,9 @@ class AsyncStorageAccessTest {
     fun mergesDeeplyTwoValues() = runBlockingTest {
         val initialEntry = Entry("key", VALUE_INITIAL)
         val overrideEntry = Entry("key", VALUE_OVERRIDES)
-
         asyncStorage.setValues(listOf(initialEntry))
         asyncStorage.mergeValues(listOf(overrideEntry))
-
         val current = asyncStorage.getValues(listOf("key"))[0]
-
         assertThat(current.value).isEqualTo(VALUE_MERGED)
     }
 
@@ -81,13 +74,10 @@ class AsyncStorageAccessTest {
         val key = "test_key"
         val value = "test_value"
         val entries = listOf(Entry(key, value))
-
         assertThat(asyncStorage.getValues(listOf(key))).hasSize(0)
         asyncStorage.setValues(entries)
         assertThat(asyncStorage.getValues(listOf(key))).isEqualTo(entries)
-
         val modifiedEntries = listOf(Entry(key, "updatedValue"))
-
         asyncStorage.setValues(modifiedEntries)
         assertThat(asyncStorage.getValues(listOf(key))).isEqualTo(modifiedEntries)
     }
diff --git a/example/examples/Basic.js b/example/examples/Basic.js
index 81e03ce5..4dc2375e 100644
--- a/example/examples/Basic.js
+++ b/example/examples/Basic.js
@@ -112,8 +112,6 @@ function NextExample() {
         };
       }
     }
-
-
     await AsyncStorage.mergeItem('MERGER', JSON.stringify(toMerge));
   }
 

From 993a2621fdbc924d939ceed3ca45c01c1acaf28a Mon Sep 17 00:00:00 2001
From: Krzysztof Borowy <krizzu.dev@gmail.com>
Date: Mon, 15 Feb 2021 10:23:27 +0100
Subject: [PATCH 13/17] room ktx extension

---
 android/build.gradle                               |  3 ++-
 .../asyncstorage/next/StorageSupplier.kt           | 14 +++++++-------
 .../asyncstorage/next/StorageTest.kt               | 11 +++++------
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/android/build.gradle b/android/build.gradle
index 282dd6a6..e806b778 100644
--- a/android/build.gradle
+++ b/android/build.gradle
@@ -108,12 +108,13 @@ dependencies {
         def room_version = "2.2.6"
         def coroutines_version = "1.4.2"
         def junit_version = "4.12"
-        def robolectric_version = "4.2.1"
+        def robolectric_version = "4.5.1"
         def truth_version = "1.1.2"
         def androidxtest_version = "1.1.0"
         def coroutinesTest_version = "1.4.2"
 
         implementation "androidx.room:room-runtime:$room_version"
+        implementation "androidx.room:room-ktx:$room_version"
         implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutines_version"
         kapt "androidx.room:room-compiler:$room_version"
 
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt
index 3074979e..e4bdc866 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt
@@ -12,7 +12,6 @@ import androidx.room.Query
 import androidx.room.Room
 import androidx.room.RoomDatabase
 import androidx.room.Transaction
-import androidx.room.Update
 import androidx.room.migration.Migration
 import androidx.sqlite.db.SupportSQLiteDatabase
 import org.json.JSONObject
@@ -35,18 +34,18 @@ internal interface StorageDao {
 
     @Transaction
     @Query("SELECT * FROM $TABLE_NAME WHERE `$COLUMN_KEY` IN (:keys)")
-    fun getValues(keys: List<String>): List<Entry>
+    suspend fun getValues(keys: List<String>): List<Entry>
 
     @Transaction
     @Insert(onConflict = OnConflictStrategy.REPLACE)
-    fun setValues(entries: List<Entry>)
+    suspend fun setValues(entries: List<Entry>)
 
     @Transaction
     @Query("DELETE FROM $TABLE_NAME WHERE `$COLUMN_KEY` in (:keys)")
-    fun removeValues(keys: List<String>)
+    suspend fun removeValues(keys: List<String>)
 
     @Transaction
-    fun mergeValues(entries: List<Entry>) {
+    suspend fun mergeValues(entries: List<Entry>) {
         val currentDbEntries = getValues(entries.map { it.key })
         val newEntries = mutableListOf<Entry>()
 
@@ -67,11 +66,11 @@ internal interface StorageDao {
 
     @Transaction
     @Query("SELECT `$COLUMN_KEY` FROM $TABLE_NAME")
-    fun getKeys(): List<String>
+    suspend fun getKeys(): List<String>
 
     @Transaction
     @Query("DELETE FROM $TABLE_NAME")
-    fun clear()
+    suspend fun clear()
 }
 
 
@@ -148,6 +147,7 @@ class StorageSupplier internal constructor(db: StorageDb) : AsyncStorageAccess {
             return StorageSupplier(StorageDb.getDatabase(ctx))
         }
     }
+
     private val access = db.storage()
 
     override suspend fun getValues(keys: List<String>) = access.getValues(keys)
diff --git a/android/src/test/java/com/reactnativecommunity/asyncstorage/next/StorageTest.kt b/android/src/test/java/com/reactnativecommunity/asyncstorage/next/StorageTest.kt
index 296cf39f..fa943d20 100644
--- a/android/src/test/java/com/reactnativecommunity/asyncstorage/next/StorageTest.kt
+++ b/android/src/test/java/com/reactnativecommunity/asyncstorage/next/StorageTest.kt
@@ -5,7 +5,7 @@ import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.platform.app.InstrumentationRegistry
 import com.google.common.truth.Truth.assertThat
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.test.runBlockingTest
+import kotlinx.coroutines.runBlocking
 import org.json.JSONObject
 import org.junit.After
 import org.junit.Before
@@ -24,7 +24,6 @@ class AsyncStorageAccessTest {
         database = Room.inMemoryDatabaseBuilder(
             InstrumentationRegistry.getInstrumentation().context, StorageDb::class.java
         ).allowMainThreadQueries().build()
-
         asyncStorage = StorageSupplier(database)
     }
 
@@ -34,7 +33,7 @@ class AsyncStorageAccessTest {
     }
 
     @Test
-    fun performsBasicGetSetRemoveOperations() = runBlockingTest {
+    fun performsBasicGetSetRemoveOperations() = runBlocking {
         val entriesCount = 10
         val entries = createRandomEntries(entriesCount)
         val keys = entries.map { it.key }
@@ -49,7 +48,7 @@ class AsyncStorageAccessTest {
     }
 
     @Test
-    fun readsAllKeysAndClearsDb() = runBlockingTest {
+    fun readsAllKeysAndClearsDb() = runBlocking {
         val entries = createRandomEntries(8)
         val keys = entries.map { it.key }
         asyncStorage.setValues(entries)
@@ -60,7 +59,7 @@ class AsyncStorageAccessTest {
     }
 
     @Test
-    fun mergesDeeplyTwoValues() = runBlockingTest {
+    fun mergesDeeplyTwoValues() = runBlocking {
         val initialEntry = Entry("key", VALUE_INITIAL)
         val overrideEntry = Entry("key", VALUE_OVERRIDES)
         asyncStorage.setValues(listOf(initialEntry))
@@ -70,7 +69,7 @@ class AsyncStorageAccessTest {
     }
 
     @Test
-    fun updatesExistingValues() = runBlockingTest {
+    fun updatesExistingValues() = runBlocking {
         val key = "test_key"
         val value = "test_value"
         val entries = listOf(Entry(key, value))

From 38c7c15a15495ffd01a84bd293ec722653e14892 Mon Sep 17 00:00:00 2001
From: Krzysztof Borowy <krizzu.dev@gmail.com>
Date: Wed, 17 Feb 2021 10:18:18 +0100
Subject: [PATCH 14/17] please detox

---
 .../asyncstorage/AsyncStorageModule.java      | 31 ----------------
 .../asyncstorage/SerialExecutor.java          | 35 +++++++++++++++++++
 .../asyncstorage/next/StorageModule.kt        |  8 +++++
 3 files changed, 43 insertions(+), 31 deletions(-)
 create mode 100644 android/src/main/java/com/reactnativecommunity/asyncstorage/SerialExecutor.java

diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStorageModule.java b/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStorageModule.java
index 9936ee50..cee4b82b 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStorageModule.java
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/AsyncStorageModule.java
@@ -46,37 +46,6 @@ public final class AsyncStorageModule
   private ReactDatabaseSupplier mReactDatabaseSupplier;
   private boolean mShuttingDown = false;
 
-  // Adapted from https://android.googlesource.com/platform/frameworks/base.git/+/1488a3a19d4681a41fb45570c15e14d99db1cb66/core/java/android/os/AsyncTask.java#237
-  private class SerialExecutor implements Executor {
-    private final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
-    private Runnable mActive;
-    private final Executor executor;
-
-    SerialExecutor(Executor executor) {
-      this.executor = executor;
-    }
-
-    public synchronized void execute(final Runnable r) {
-      mTasks.offer(new Runnable() {
-        public void run() {
-          try {
-            r.run();
-          } finally {
-            scheduleNext();
-          }
-        }
-      });
-      if (mActive == null) {
-        scheduleNext();
-      }
-    }
-    synchronized void scheduleNext() {
-      if ((mActive = mTasks.poll()) != null) {
-        executor.execute(mActive);
-      }
-    }
-  }
-
   private final SerialExecutor executor;
 
   public AsyncStorageModule(ReactApplicationContext reactContext) {
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/SerialExecutor.java b/android/src/main/java/com/reactnativecommunity/asyncstorage/SerialExecutor.java
new file mode 100644
index 00000000..227dbe9f
--- /dev/null
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/SerialExecutor.java
@@ -0,0 +1,35 @@
+package com.reactnativecommunity.asyncstorage;
+
+import java.util.ArrayDeque;
+import java.util.concurrent.Executor;
+
+// Adapted from https://android.googlesource.com/platform/frameworks/base.git/+/1488a3a19d4681a41fb45570c15e14d99db1cb66/core/java/android/os/AsyncTask.java#237
+public class SerialExecutor implements Executor {
+    private final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
+    private Runnable mActive;
+    private final Executor executor;
+
+    public SerialExecutor(Executor executor) {
+        this.executor = executor;
+    }
+
+    public synchronized void execute(final Runnable r) {
+        mTasks.offer(new Runnable() {
+            public void run() {
+                try {
+                    r.run();
+                } finally {
+                    scheduleNext();
+                }
+            }
+        });
+        if (mActive == null) {
+            scheduleNext();
+        }
+    }
+    synchronized void scheduleNext() {
+        if ((mActive = mTasks.poll()) != null) {
+            executor.execute(mActive);
+        }
+    }
+}
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
index 47575fc7..be6cbb51 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
@@ -1,21 +1,29 @@
 package com.reactnativecommunity.asyncstorage.next
 
 import android.content.Context
+import androidx.annotation.VisibleForTesting
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Callback
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableArray
+import com.reactnativecommunity.asyncstorage.SerialExecutor
 import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.asExecutor
 import kotlinx.coroutines.launch
 
 class StorageModule(reactContext: ReactContext) : ReactContextBaseJavaModule(), CoroutineScope {
     override fun getName() = "RNC_AsyncSQLiteDBStorage"
 
+    // this executor is here only to please detox, which relies on internal implementation
+    // of current Async Storage
+    @VisibleForTesting
+    private val executor = SerialExecutor(Dispatchers.Main.asExecutor())
+
     override val coroutineContext =
         Dispatchers.IO + CoroutineName("AsyncStorageScope") + SupervisorJob()
 

From baa5e6cc05743b79e98134697e63a8f32cb56ee4 Mon Sep 17 00:00:00 2001
From: Krzysztof Borowy <krizzu.dev@gmail.com>
Date: Fri, 26 Feb 2021 09:43:04 +0100
Subject: [PATCH 15/17] address comments, e2e for next

---
 .circleci/config.yml                             | 11 +++++++++--
 .../asyncstorage/SerialExecutor.java             |  7 ++++++-
 .../asyncstorage/next/ArgumentHelpers.kt         |  4 ++--
 .../asyncstorage/next/StorageModule.kt           |  4 ++--
 example/android/build.gradle                     | 16 +++++++++++++++-
 package.json                                     |  8 ++++++++
 scripts/android_e2e.sh                           |  2 +-
 7 files changed, 43 insertions(+), 9 deletions(-)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index e5e93d65..a9e79432 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -52,7 +52,7 @@ cache keys:
   brew ios: &key_brew_ios cache-brew-ios-v4-{{ arch }}
   brew android: &key_brew_android cache-brew-android-v4-{{ arch }}
   yarn: &key_yarn cache-yarn-{{ checksum "package.json" }}-{{ arch }}
-  gradle: &key_gradle cache-gradle-{{ checksum "example/android/gradle/wrapper/gradle-wrapper.properties" }}-{{ checksum "package.json" }}-{{ arch }}
+  gradle: &key_gradle cache-gradle-v1-{{ checksum "example/android/gradle/wrapper/gradle-wrapper.properties" }}-{{ checksum "package.json" }}-{{ arch }}
   pods: &key_pods cache-pods-v1-{{ checksum "example/ios/Podfile" }}-{{ checksum "package.json" }}-{{ arch }}
 
 cache:
@@ -216,8 +216,12 @@ jobs:
           name: Bundle JS
           command: yarn bundle:android --dev false
       - run:
-          name: Build APK
+          name: Build APKs
           command: yarn build:e2e:android
+      - run:
+          name: Build APK with Next storage
+          working_directory: example/android
+          command: ./gradlew assembleNext --max-workers 2
       - persist_to_workspace:
           root: ~/async_storage
           paths:
@@ -292,6 +296,9 @@ jobs:
       - run:
           name: Run e2e tests
           command: yarn test:e2e:android
+      - run:
+          name: Run e2e tests for Next storage
+          command: yarn detox test -c android.emu.release.next --maxConcurrency 1
 
   Release:
     <<: *js_defaults
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/SerialExecutor.java b/android/src/main/java/com/reactnativecommunity/asyncstorage/SerialExecutor.java
index 227dbe9f..bf46c1e7 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/SerialExecutor.java
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/SerialExecutor.java
@@ -3,7 +3,12 @@
 import java.util.ArrayDeque;
 import java.util.concurrent.Executor;
 
-// Adapted from https://android.googlesource.com/platform/frameworks/base.git/+/1488a3a19d4681a41fb45570c15e14d99db1cb66/core/java/android/os/AsyncTask.java#237
+/**
+ * Detox is using this implementation detail in its environment setup,
+ * so in order for Next storage to work, this class has been made public
+ *
+ * Adapted from https://android.googlesource.com/platform/frameworks/base.git/+/1488a3a19d4681a41fb45570c15e14d99db1cb66/core/java/android/os/AsyncTask.java#237
+ */
 public class SerialExecutor implements Executor {
     private final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
     private Runnable mActive;
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt
index bb03e5da..bb613774 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt
@@ -14,10 +14,10 @@ fun ReadableArray.toEntryList(): List<Entry> {
         val key = keyValue[0]
         val value = keyValue[1]
 
-        if (key == null || key !is String) {
+        if (key !is String) {
             when (key) {
                 null -> throw AsyncStorageError.keyIsNull()
-                !is String -> throw AsyncStorageError.keyNotString()
+                else -> throw AsyncStorageError.keyNotString()
             }
         }
 
diff --git a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
index be6cbb51..ade13167 100644
--- a/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
+++ b/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt
@@ -19,8 +19,8 @@ import kotlinx.coroutines.launch
 class StorageModule(reactContext: ReactContext) : ReactContextBaseJavaModule(), CoroutineScope {
     override fun getName() = "RNC_AsyncSQLiteDBStorage"
 
-    // this executor is here only to please detox, which relies on internal implementation
-    // of current Async Storage
+    // this executor is not used by the module, but it must exists here due to
+    // Detox relying on this implementation detail to run
     @VisibleForTesting
     private val executor = SerialExecutor(Dispatchers.Main.asExecutor())
 
diff --git a/example/android/build.gradle b/example/android/build.gradle
index f34c8f4c..49cf9ec9 100644
--- a/example/android/build.gradle
+++ b/example/android/build.gradle
@@ -28,6 +28,14 @@ task fetchDependencies() {
 buildscript {
     ext.kotlinVersion = '1.4.21'
 
+    // Mainly for Detox testing for using Next Storage
+    // when building next, force using next storage
+    if(gradle.startParameter.getTaskNames().contains("assembleNext")) {
+        rootProject.setProperty("AsyncStorage_useNextStorage", "true")
+    }
+    Boolean nextStorageFlag = rootProject.hasProperty("AsyncStorage_useNextStorage") ? rootProject.properties["AsyncStorage_useNextStorage"] == "true" : false
+    println("[Async Storage] Using Next storage: " + nextStorageFlag)
+
     repositories {
         google()
         jcenter()
@@ -64,8 +72,14 @@ allprojects {
                     keyPassword 'android'
                 }
             }
-
             androidExtension.buildTypes.release.signingConfig = androidExtension.signingConfigs.test
+            androidExtension.buildTypes {
+                next {
+                    initWith release
+                    matchingFallbacks = ["debug", "release"]
+                }
+            }
+
             androidExtension.testBuildType = 'release'
 
             androidExtension.sourceSets.androidTest.java.srcDirs += "$rootDir/app/src/androidTest/java"
diff --git a/package.json b/package.json
index e745fdd7..b54560dc 100644
--- a/package.json
+++ b/package.json
@@ -128,6 +128,14 @@
         "device": {
           "avdName": "Emu_E2E"
         }
+      },
+      "android.emu.release.next": {
+        "binaryPath": "example/android/app/build/outputs/apk/next/app-next.apk",
+        "testBinaryPath": "example/android/app/build/outputs/apk/androidTest/release/app-release-androidTest.apk",
+        "type": "android.emulator",
+        "device": {
+          "avdName": "Emu_E2E"
+        }
       }
     }
   },
diff --git a/scripts/android_e2e.sh b/scripts/android_e2e.sh
index f2cfb218..b63d9eb2 100755
--- a/scripts/android_e2e.sh
+++ b/scripts/android_e2e.sh
@@ -6,7 +6,7 @@ MAX_RETRIES=60 # wait max 5 minutes for emu to boot
 build_apk() {
   echo
   echo "[Detox e2e] Building APK"
-  (cd example/android; ./gradlew assembleRelease assembleAndroidTest -DtestBuildType=release --max-workers 2)
+  (cd example/android; ./gradlew assembleRelease assembleAndroidTest -PAsyncStorage_useNextStorage=false -DtestBuildType=release --max-workers 2)
 }
 
 bundle_js() {

From dd21b80445658340b3d165fe3a4b60874227fe86 Mon Sep 17 00:00:00 2001
From: Krzysztof Borowy <krizzu.dev@gmail.com>
Date: Sat, 6 Mar 2021 18:19:47 +0100
Subject: [PATCH 16/17] apply ndk version for ci

---
 example/android/build.gradle | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/example/android/build.gradle b/example/android/build.gradle
index 49cf9ec9..16b87d89 100644
--- a/example/android/build.gradle
+++ b/example/android/build.gradle
@@ -79,11 +79,12 @@ allprojects {
                     matchingFallbacks = ["debug", "release"]
                 }
             }
-
             androidExtension.testBuildType = 'release'
-
             androidExtension.sourceSets.androidTest.java.srcDirs += "$rootDir/app/src/androidTest/java"
-
+            if(System.getenv("CIRCLECI") == "true") {
+                // explicitly apply NDK version available in CI image
+                androidExtension.ndkVersion = "20.1.5948944"
+            }
             project.dependencies {
                 androidTestImplementation('com.wix:detox:+')
             }

From 70de3b081d0d177a058299704721c0df7e1423ca Mon Sep 17 00:00:00 2001
From: Krzysztof Borowy <krizzu.dev@gmail.com>
Date: Sun, 7 Mar 2021 15:06:06 +0100
Subject: [PATCH 17/17] test next storage through e2e

---
 .circleci/config.yml         | 3 +++
 example/android/build.gradle | 4 ++++
 2 files changed, 7 insertions(+)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index a9e79432..3d552901 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -296,6 +296,9 @@ jobs:
       - run:
           name: Run e2e tests
           command: yarn test:e2e:android
+      - run:
+          name: Clear previous app from device
+          command: adb uninstall com.microsoft.reacttestapp
       - run:
           name: Run e2e tests for Next storage
           command: yarn detox test -c android.emu.release.next --maxConcurrency 1
diff --git a/example/android/build.gradle b/example/android/build.gradle
index 16b87d89..8e4de365 100644
--- a/example/android/build.gradle
+++ b/example/android/build.gradle
@@ -75,6 +75,7 @@ allprojects {
             androidExtension.buildTypes.release.signingConfig = androidExtension.signingConfigs.test
             androidExtension.buildTypes {
                 next {
+                    // this build type is used on CI (to have app with and without nextStorage)
                     initWith release
                     matchingFallbacks = ["debug", "release"]
                 }
@@ -87,6 +88,9 @@ allprojects {
             }
             project.dependencies {
                 androidTestImplementation('com.wix:detox:+')
+
+                def hermesDir = file('../../node_modules/hermes-engine/android').absolutePath
+                nextImplementation files("$hermesDir/hermes-release.aar")
             }
         }
     }