@onekeyfe/react-native-async-storage 3.0.7 → 3.0.8

package/android/src/main/java/com/asyncstorage/RNCAsyncStorageModule.kt

@@ -1,132 +1,368 @@
 package com.asyncstorage
 
-import android.content.Context
-import android.content.SharedPreferences
+import android.database.Cursor
+import android.database.sqlite.SQLiteStatement
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.bridge.WritableArray
 import com.facebook.react.module.annotations.ReactModule
+import org.json.JSONObject
+import java.util.concurrent.Executor
+import java.util.concurrent.Executors
 
+/**
+ * Ported from upstream @react-native-async-storage/async-storage AsyncStorageModule.java
+ * Adapted to use Promise (TurboModule) instead of Callback.
+ * Uses SQLite via ReactDatabaseSupplier (same as upstream).
+ */
 @ReactModule(name = RNCAsyncStorageModule.NAME)
 class RNCAsyncStorageModule(reactContext: ReactApplicationContext) :
     NativeRNCAsyncStorageSpec(reactContext) {
 
     companion object {
         const val NAME = "RNCAsyncStorage"
-        private const val PREFS_NAME = "RNCAsyncStorage"
+        // SQL variable number limit, defined by SQLITE_LIMIT_VARIABLE_NUMBER
+        private const val MAX_SQL_KEYS = 999
     }
 
-    private fun getPrefs(): SharedPreferences {
-        return reactApplicationContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
-    }
+    private val dbSupplier: ReactDatabaseSupplier = ReactDatabaseSupplier.getInstance(reactContext)
+    private val executor: Executor = SerialExecutor(Executors.newSingleThreadExecutor())
+    @Volatile
+    private var shuttingDown = false
 
     override fun getName(): String = NAME
 
+    override fun initialize() {
+        super.initialize()
+        shuttingDown = false
+    }
+
+    override fun invalidate() {
+        shuttingDown = true
+        dbSupplier.closeDatabase()
+    }
+
     override fun multiGet(keys: ReadableArray, promise: Promise) {
-        Thread {
+        executor.execute {
             try {
-                val prefs = getPrefs()
-                val result = WritableNativeArray()
-                for (i in 0 until keys.size()) {
-                    val key = keys.getString(i)
-                    val pair = WritableNativeArray()
-                    pair.pushString(key)
-                    if (prefs.contains(key)) {
-                        pair.pushString(prefs.getString(key, null))
-                    } else {
-                        pair.pushNull()
+                if (!ensureDatabase()) {
+                    promise.reject("ASYNC_STORAGE_ERROR", "Database Error")
+                    return@execute
+                }
+
+                val columns = arrayOf(ReactDatabaseSupplier.KEY_COLUMN, ReactDatabaseSupplier.VALUE_COLUMN)
+                val keysRemaining = HashSet<String>()
+                val data: WritableArray = Arguments.createArray()
+
+                var keyStart = 0
+                while (keyStart < keys.size()) {
+                    val keyCount = Math.min(keys.size() - keyStart, MAX_SQL_KEYS)
+                    val cursor: Cursor = dbSupplier.get().query(
+                        ReactDatabaseSupplier.TABLE_CATALYST,
+                        columns,
+                        buildKeySelection(keyCount),
+                        buildKeySelectionArgs(keys, keyStart, keyCount),
+                        null, null, null
+                    )
+
+                    keysRemaining.clear()
+                    try {
+                        if (cursor.count != keys.size()) {
+                            for (keyIndex in keyStart until keyStart + keyCount) {
+                                keysRemaining.add(keys.getString(keyIndex))
+                            }
+                        }
+                        if (cursor.moveToFirst()) {
+                            do {
+                                val row = Arguments.createArray()
+                                row.pushString(cursor.getString(0))
+                                row.pushString(cursor.getString(1))
+                                data.pushArray(row)
+                                keysRemaining.remove(cursor.getString(0))
+                            } while (cursor.moveToNext())
+                        }
+                    } finally {
+                        cursor.close()
                     }
-                    result.pushArray(pair)
+
+                    for (key in keysRemaining) {
+                        val row = Arguments.createArray()
+                        row.pushString(key)
+                        row.pushNull()
+                        data.pushArray(row)
+                    }
+                    keysRemaining.clear()
+                    keyStart += MAX_SQL_KEYS
                 }
-                promise.resolve(result)
+
+                promise.resolve(data)
             } catch (e: Exception) {
                 promise.reject("ASYNC_STORAGE_ERROR", e.message, e)
             }
-        }.start()
+        }
     }
 
     override fun multiSet(keyValuePairs: ReadableArray, promise: Promise) {
-        Thread {
+        if (keyValuePairs.size() == 0) {
+            promise.resolve(null)
+            return
+        }
+
+        executor.execute {
             try {
-                val editor = getPrefs().edit()
-                for (i in 0 until keyValuePairs.size()) {
-                    val pair = keyValuePairs.getArray(i)
-                    if (pair != null && pair.size() >= 2) {
+                if (!ensureDatabase()) {
+                    promise.reject("ASYNC_STORAGE_ERROR", "Database Error")
+                    return@execute
+                }
+
+                val sql = "INSERT OR REPLACE INTO ${ReactDatabaseSupplier.TABLE_CATALYST} VALUES (?, ?);"
+                val statement: SQLiteStatement = dbSupplier.get().compileStatement(sql)
+                try {
+                    dbSupplier.get().beginTransaction()
+                    for (idx in 0 until keyValuePairs.size()) {
+                        val pair = keyValuePairs.getArray(idx)
+                        if (pair == null || pair.size() != 2) {
+                            promise.reject("ASYNC_STORAGE_ERROR", "Invalid Value")
+                            return@execute
+                        }
                         val key = pair.getString(0)
                         val value = pair.getString(1)
-                        editor.putString(key, value)
+                        if (key == null) {
+                            promise.reject("ASYNC_STORAGE_ERROR", "Invalid key")
+                            return@execute
+                        }
+                        if (value == null) {
+                            promise.reject("ASYNC_STORAGE_ERROR", "Invalid Value")
+                            return@execute
+                        }
+                        statement.clearBindings()
+                        statement.bindString(1, key)
+                        statement.bindString(2, value)
+                        statement.execute()
+                    }
+                    dbSupplier.get().setTransactionSuccessful()
+                } finally {
+                    try {
+                        dbSupplier.get().endTransaction()
+                    } catch (e: Exception) {
+                        promise.reject("ASYNC_STORAGE_ERROR", e.message, e)
+                        return@execute
                     }
                 }
-                editor.apply()
                 promise.resolve(null)
             } catch (e: Exception) {
                 promise.reject("ASYNC_STORAGE_ERROR", e.message, e)
             }
-        }.start()
+        }
     }
 
     override fun multiRemove(keys: ReadableArray, promise: Promise) {
-        Thread {
+        if (keys.size() == 0) {
+            promise.resolve(null)
+            return
+        }
+
+        executor.execute {
             try {
-                val editor = getPrefs().edit()
-                for (i in 0 until keys.size()) {
-                    editor.remove(keys.getString(i))
+                if (!ensureDatabase()) {
+                    promise.reject("ASYNC_STORAGE_ERROR", "Database Error")
+                    return@execute
+                }
+
+                try {
+                    dbSupplier.get().beginTransaction()
+                    var keyStart = 0
+                    while (keyStart < keys.size()) {
+                        val keyCount = Math.min(keys.size() - keyStart, MAX_SQL_KEYS)
+                        dbSupplier.get().delete(
+                            ReactDatabaseSupplier.TABLE_CATALYST,
+                            buildKeySelection(keyCount),
+                            buildKeySelectionArgs(keys, keyStart, keyCount)
+                        )
+                        keyStart += MAX_SQL_KEYS
+                    }
+                    dbSupplier.get().setTransactionSuccessful()
+                } finally {
+                    try {
+                        dbSupplier.get().endTransaction()
+                    } catch (e: Exception) {
+                        promise.reject("ASYNC_STORAGE_ERROR", e.message, e)
+                        return@execute
+                    }
                 }
-                editor.apply()
                 promise.resolve(null)
             } catch (e: Exception) {
                 promise.reject("ASYNC_STORAGE_ERROR", e.message, e)
             }
-        }.start()
+        }
     }
 
     override fun multiMerge(keyValuePairs: ReadableArray, promise: Promise) {
-        Thread {
+        executor.execute {
             try {
-                val prefs = getPrefs()
-                val editor = prefs.edit()
-                for (i in 0 until keyValuePairs.size()) {
-                    val pair = keyValuePairs.getArray(i)
-                    if (pair != null && pair.size() >= 2) {
+                if (!ensureDatabase()) {
+                    promise.reject("ASYNC_STORAGE_ERROR", "Database Error")
+                    return@execute
+                }
+
+                try {
+                    dbSupplier.get().beginTransaction()
+                    for (idx in 0 until keyValuePairs.size()) {
+                        val pair = keyValuePairs.getArray(idx)
+                        if (pair == null || pair.size() != 2) {
+                            promise.reject("ASYNC_STORAGE_ERROR", "Invalid Value")
+                            return@execute
+                        }
                         val key = pair.getString(0)
                         val value = pair.getString(1)
-                        // For merge, if key exists and both are JSON objects, deep merge.
-                        // For simplicity, we overwrite (shallow merge by replacing value).
-                        editor.putString(key, value)
+                        if (key == null) {
+                            promise.reject("ASYNC_STORAGE_ERROR", "Invalid key")
+                            return@execute
+                        }
+                        if (value == null) {
+                            promise.reject("ASYNC_STORAGE_ERROR", "Invalid Value")
+                            return@execute
+                        }
+                        if (!mergeImpl(key, value)) {
+                            promise.reject("ASYNC_STORAGE_ERROR", "Database Error")
+                            return@execute
+                        }
+                    }
+                    dbSupplier.get().setTransactionSuccessful()
+                } finally {
+                    try {
+                        dbSupplier.get().endTransaction()
+                    } catch (e: Exception) {
+                        promise.reject("ASYNC_STORAGE_ERROR", e.message, e)
+                        return@execute
                     }
                 }
-                editor.apply()
                 promise.resolve(null)
             } catch (e: Exception) {
                 promise.reject("ASYNC_STORAGE_ERROR", e.message, e)
             }
-        }.start()
+        }
     }
 
     override fun getAllKeys(promise: Promise) {
-        Thread {
+        executor.execute {
             try {
-                val prefs = getPrefs()
-                val result = WritableNativeArray()
-                for (key in prefs.all.keys) {
-                    result.pushString(key)
+                if (!ensureDatabase()) {
+                    promise.reject("ASYNC_STORAGE_ERROR", "Database Error")
+                    return@execute
+                }
+
+                val columns = arrayOf(ReactDatabaseSupplier.KEY_COLUMN)
+                val cursor: Cursor = dbSupplier.get().query(
+                    ReactDatabaseSupplier.TABLE_CATALYST,
+                    columns, null, null, null, null, null
+                )
+
+                val data: WritableArray = Arguments.createArray()
+                try {
+                    if (cursor.moveToFirst()) {
+                        do {
+                            data.pushString(cursor.getString(0))
+                        } while (cursor.moveToNext())
+                    }
+                } finally {
+                    cursor.close()
                 }
-                promise.resolve(result)
+                promise.resolve(data)
             } catch (e: Exception) {
                 promise.reject("ASYNC_STORAGE_ERROR", e.message, e)
             }
-        }.start()
+        }
     }
 
     override fun clear(promise: Promise) {
-        Thread {
+        executor.execute {
             try {
-                getPrefs().edit().clear().apply()
+                if (!dbSupplier.ensureDatabase()) {
+                    promise.reject("ASYNC_STORAGE_ERROR", "Database Error")
+                    return@execute
+                }
+                dbSupplier.clear()
                 promise.resolve(null)
             } catch (e: Exception) {
                 promise.reject("ASYNC_STORAGE_ERROR", e.message, e)
             }
-        }.start()
+        }
+    }
+
+    // --- Private helpers (ported from AsyncLocalStorageUtil.java) ---
+
+    private fun ensureDatabase(): Boolean {
+        return !shuttingDown && dbSupplier.ensureDatabase()
+    }
+
+    private fun buildKeySelection(count: Int): String {
+        val list = Array(count) { "?" }
+        return "${ReactDatabaseSupplier.KEY_COLUMN} IN (${list.joinToString(", ")})"
+    }
+
+    private fun buildKeySelectionArgs(keys: ReadableArray, start: Int, count: Int): Array<String> {
+        return Array(count) { keys.getString(start + it) }
+    }
+
+    private fun getItemImpl(key: String): String? {
+        val columns = arrayOf(ReactDatabaseSupplier.VALUE_COLUMN)
+        val selectionArgs = arrayOf(key)
+        val cursor = dbSupplier.get().query(
+            ReactDatabaseSupplier.TABLE_CATALYST,
+            columns,
+            "${ReactDatabaseSupplier.KEY_COLUMN}=?",
+            selectionArgs,
+            null, null, null
+        )
+        try {
+            return if (!cursor.moveToFirst()) null else cursor.getString(0)
+        } finally {
+            cursor.close()
+        }
+    }
+
+    private fun setItemImpl(key: String, value: String): Boolean {
+        val contentValues = android.content.ContentValues()
+        contentValues.put(ReactDatabaseSupplier.KEY_COLUMN, key)
+        contentValues.put(ReactDatabaseSupplier.VALUE_COLUMN, value)
+        val inserted = dbSupplier.get().insertWithOnConflict(
+            ReactDatabaseSupplier.TABLE_CATALYST,
+            null,
+            contentValues,
+            android.database.sqlite.SQLiteDatabase.CONFLICT_REPLACE
+        )
+        return inserted != -1L
+    }
+
+    private fun mergeImpl(key: String, value: String): Boolean {
+        val oldValue = getItemImpl(key)
+        val newValue: String
+        if (oldValue == null) {
+            newValue = value
+        } else {
+            val oldJSON = JSONObject(oldValue)
+            val newJSON = JSONObject(value)
+            deepMergeInto(oldJSON, newJSON)
+            newValue = oldJSON.toString()
+        }
+        return setItemImpl(key, newValue)
+    }
+
+    private fun deepMergeInto(oldJSON: JSONObject, newJSON: JSONObject) {
+        val keys = newJSON.keys()
+        while (keys.hasNext()) {
+            val key = keys.next()
+            val newJSONObject = newJSON.optJSONObject(key)
+            val oldJSONObject = oldJSON.optJSONObject(key)
+            if (newJSONObject != null && oldJSONObject != null) {
+                deepMergeInto(oldJSONObject, newJSONObject)
+                oldJSON.put(key, oldJSONObject)
+            } else {
+                oldJSON.put(key, newJSON.get(key))
+            }
+        }
     }
 }

package/android/src/main/java/com/asyncstorage/ReactDatabaseSupplier.java

@@ -0,0 +1,140 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.asyncstorage;
+
+import android.content.Context;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteException;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.util.Log;
+import javax.annotation.Nullable;
+
+/**
+ * Database supplier of the database used by react native async storage.
+ * Ported from upstream @react-native-async-storage/async-storage ReactDatabaseSupplier.java.
+ */
+public class ReactDatabaseSupplier extends SQLiteOpenHelper {
+
+    public static final String DATABASE_NAME = "RKStorage";
+
+    private static final int DATABASE_VERSION = 1;
+    private static final int SLEEP_TIME_MS = 30;
+
+    static final String TABLE_CATALYST = "catalystLocalStorage";
+    static final String KEY_COLUMN = "key";
+    static final String VALUE_COLUMN = "value";
+
+    static final String VERSION_TABLE_CREATE =
+        "CREATE TABLE " + TABLE_CATALYST + " (" +
+            KEY_COLUMN + " TEXT PRIMARY KEY, " +
+            VALUE_COLUMN + " TEXT NOT NULL" +
+            ")";
+
+    private static @Nullable ReactDatabaseSupplier sReactDatabaseSupplierInstance;
+
+    private Context mContext;
+    private @Nullable SQLiteDatabase mDb;
+    private long mMaximumDatabaseSize = 6L * 1024L * 1024L;
+
+    private ReactDatabaseSupplier(Context context) {
+        super(context, DATABASE_NAME, null, DATABASE_VERSION);
+        mContext = context;
+    }
+
+    public static ReactDatabaseSupplier getInstance(Context context) {
+        if (sReactDatabaseSupplierInstance == null) {
+            sReactDatabaseSupplierInstance = new ReactDatabaseSupplier(context.getApplicationContext());
+        }
+        return sReactDatabaseSupplierInstance;
+    }
+
+    @Override
+    public void onCreate(SQLiteDatabase db) {
+        db.execSQL(VERSION_TABLE_CREATE);
+    }
+
+    @Override
+    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+        if (oldVersion != newVersion) {
+            deleteDatabase();
+            onCreate(db);
+        }
+    }
+
+    synchronized boolean ensureDatabase() {
+        if (mDb != null && mDb.isOpen()) {
+            return true;
+        }
+        SQLiteException lastSQLiteException = null;
+        for (int tries = 0; tries < 2; tries++) {
+            try {
+                if (tries > 0) {
+                    deleteDatabase();
+                }
+                mDb = getWritableDatabase();
+                break;
+            } catch (SQLiteException e) {
+                lastSQLiteException = e;
+            }
+            try {
+                Thread.sleep(SLEEP_TIME_MS);
+            } catch (InterruptedException ie) {
+                Thread.currentThread().interrupt();
+            }
+        }
+        if (mDb == null) {
+            throw lastSQLiteException;
+        }
+        mDb.setMaximumSize(mMaximumDatabaseSize);
+        return true;
+    }
+
+    public synchronized SQLiteDatabase get() {
+        ensureDatabase();
+        return mDb;
+    }
+
+    public synchronized void clearAndCloseDatabase() throws RuntimeException {
+        try {
+            clear();
+            closeDatabase();
+        } catch (Exception e) {
+            if (deleteDatabase()) {
+                return;
+            }
+            throw new RuntimeException("Clearing and deleting database " + DATABASE_NAME + " failed");
+        }
+    }
+
+    synchronized void clear() {
+        get().delete(TABLE_CATALYST, null, null);
+    }
+
+    public synchronized void setMaximumSize(long size) {
+        mMaximumDatabaseSize = size;
+        if (mDb != null) {
+            mDb.setMaximumSize(mMaximumDatabaseSize);
+        }
+    }
+
+    private synchronized boolean deleteDatabase() {
+        closeDatabase();
+        return mContext.deleteDatabase(DATABASE_NAME);
+    }
+
+    public synchronized void closeDatabase() {
+        if (mDb != null && mDb.isOpen()) {
+            mDb.close();
+            mDb = null;
+        }
+    }
+
+    public static void deleteInstance() {
+        sReactDatabaseSupplierInstance = null;
+    }
+}

package/android/src/main/java/com/asyncstorage/SerialExecutor.java

@@ -0,0 +1,38 @@
+package com.asyncstorage;
+
+import java.util.ArrayDeque;
+import java.util.concurrent.Executor;
+
+/**
+ * Ported from upstream @react-native-async-storage/async-storage SerialExecutor.java.
+ */
+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);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-async-storage",
-  "version": "3.0.7",
+  "version": "3.0.8",
   "description": "react-native-async-storage",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",