react-native-nitro-storage 0.10.3 → 0.11.0

package/android/src/main/cpp/AndroidStorageAdapterCpp.cpp

@@ -1,5 +1,8 @@
 #include "AndroidStorageAdapterCpp.hpp"
 
+#include <limits>
+#include <stdexcept>
+
 namespace NitroStorage {
 
 using namespace facebook::jni;
@@ -7,10 +10,25 @@ using JavaStringArray = JArrayClass<jstring>;
 
 namespace {
 
+local_ref<JString> toJavaString(const std::string& value) {
+    // fbjni's std::string overload uses c_str(), which truncates embedded NUL.
+    if (value.find('\0') == std::string::npos) return make_jstring(value);
+    if (value.size() > static_cast<size_t>(std::numeric_limits<jsize>::max())) {
+        throw std::length_error("Storage string exceeds the Java array limit");
+    }
+    const auto size = static_cast<jsize>(value.size());
+    auto bytes = JArrayByte::newArray(size);
+    bytes->setRegion(0, size, reinterpret_cast<const jbyte*>(value.data()));
+    static auto constructor = JString::javaClassStatic()->getConstructor<
+        jstring(jbyteArray, jstring)>();
+    auto charset = make_jstring("UTF-8");
+    return JString::javaClassStatic()->newObject(constructor, bytes.get(), charset.get());
+}
+
 local_ref<JavaStringArray> toJavaStringArray(const std::vector<std::string>& values) {
     auto javaArray = JavaStringArray::newArray(static_cast<jsize>(values.size()));
     for (size_t i = 0; i < values.size(); ++i) {
-        auto javaValue = make_jstring(values[i]);
+        auto javaValue = toJavaString(values[i]);
         javaArray->setElement(static_cast<jsize>(i), javaValue.get());
     }
     return javaArray;
@@ -51,35 +69,32 @@ std::vector<std::string> fromJavaStringArray(alias_ref<JavaStringArray> values)
 
 } // namespace
 
-AndroidStorageAdapterCpp::AndroidStorageAdapterCpp(alias_ref<JObject> /*context*/) {
-    // Context is validated by AndroidStorageAdapter.getContext() on the Java side.
-    // The adapter calls static Java methods directly via fbjni.
-}
+AndroidStorageAdapterCpp::AndroidStorageAdapterCpp() = default;
 
 AndroidStorageAdapterCpp::~AndroidStorageAdapterCpp() = default;
 
 // --- Disk ---
 
 void AndroidStorageAdapterCpp::setDisk(const std::string& key, const std::string& value) {
-    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(std::string, std::string)>("setDisk");
-    method(AndroidStorageAdapterJava::javaClassStatic(), key, value);
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(alias_ref<JString>, alias_ref<JString>)>("setDisk");
+    method(AndroidStorageAdapterJava::javaClassStatic(), toJavaString(key), toJavaString(value));
 }
 
 std::optional<std::string> AndroidStorageAdapterCpp::getDisk(const std::string& key) {
-    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jstring(std::string)>("getDisk");
-    auto result = method(AndroidStorageAdapterJava::javaClassStatic(), key);
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jstring(alias_ref<JString>)>("getDisk");
+    auto result = method(AndroidStorageAdapterJava::javaClassStatic(), toJavaString(key));
     if (!result) return std::nullopt;
     return result->toStdString();
 }
 
 void AndroidStorageAdapterCpp::deleteDisk(const std::string& key) {
-    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(std::string)>("deleteDisk");
-    method(AndroidStorageAdapterJava::javaClassStatic(), key);
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(alias_ref<JString>)>("deleteDisk");
+    method(AndroidStorageAdapterJava::javaClassStatic(), toJavaString(key));
 }
 
 bool AndroidStorageAdapterCpp::hasDisk(const std::string& key) {
-    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jboolean(std::string)>("hasDisk");
-    return method(AndroidStorageAdapterJava::javaClassStatic(), key);
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jboolean(alias_ref<JString>)>("hasDisk");
+    return method(AndroidStorageAdapterJava::javaClassStatic(), toJavaString(key));
 }
 
 std::vector<std::string> AndroidStorageAdapterCpp::getAllKeysDisk() {
@@ -92,9 +107,9 @@ std::vector<std::string> AndroidStorageAdapterCpp::getAllKeysDisk() {
 
 std::vector<std::string> AndroidStorageAdapterCpp::getKeysByPrefixDisk(const std::string& prefix) {
     static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
-        local_ref<JavaStringArray>(std::string)
+        local_ref<JavaStringArray>(alias_ref<JString>)
     >("getKeysByPrefixDisk");
-    auto keys = method(AndroidStorageAdapterJava::javaClassStatic(), prefix);
+    auto keys = method(AndroidStorageAdapterJava::javaClassStatic(), toJavaString(prefix));
     return fromJavaStringArray(keys);
 }
 
@@ -145,25 +160,25 @@ void AndroidStorageAdapterCpp::clearDisk() {
 // --- Secure ---
 
 void AndroidStorageAdapterCpp::setSecure(const std::string& key, const std::string& value) {
-    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(std::string, std::string)>("setSecure");
-    method(AndroidStorageAdapterJava::javaClassStatic(), key, value);
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(alias_ref<JString>, alias_ref<JString>)>("setSecure");
+    method(AndroidStorageAdapterJava::javaClassStatic(), toJavaString(key), toJavaString(value));
 }
 
 std::optional<std::string> AndroidStorageAdapterCpp::getSecure(const std::string& key) {
-    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jstring(std::string)>("getSecure");
-    auto result = method(AndroidStorageAdapterJava::javaClassStatic(), key);
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jstring(alias_ref<JString>)>("getSecure");
+    auto result = method(AndroidStorageAdapterJava::javaClassStatic(), toJavaString(key));
     if (!result) return std::nullopt;
     return result->toStdString();
 }
 
 void AndroidStorageAdapterCpp::deleteSecure(const std::string& key) {
-    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(std::string)>("deleteSecure");
-    method(AndroidStorageAdapterJava::javaClassStatic(), key);
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(alias_ref<JString>)>("deleteSecure");
+    method(AndroidStorageAdapterJava::javaClassStatic(), toJavaString(key));
 }
 
 bool AndroidStorageAdapterCpp::hasSecure(const std::string& key) {
-    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jboolean(std::string)>("hasSecure");
-    return method(AndroidStorageAdapterJava::javaClassStatic(), key);
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jboolean(alias_ref<JString>)>("hasSecure");
+    return method(AndroidStorageAdapterJava::javaClassStatic(), toJavaString(key));
 }
 
 std::vector<std::string> AndroidStorageAdapterCpp::getAllKeysSecure() {
@@ -176,9 +191,9 @@ std::vector<std::string> AndroidStorageAdapterCpp::getAllKeysSecure() {
 
 std::vector<std::string> AndroidStorageAdapterCpp::getKeysByPrefixSecure(const std::string& prefix) {
     static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
-        local_ref<JavaStringArray>(std::string)
+        local_ref<JavaStringArray>(alias_ref<JString>)
     >("getKeysByPrefixSecure");
-    auto keys = method(AndroidStorageAdapterJava::javaClassStatic(), prefix);
+    auto keys = method(AndroidStorageAdapterJava::javaClassStatic(), toJavaString(prefix));
     return fromJavaStringArray(keys);
 }
 
@@ -242,25 +257,25 @@ void AndroidStorageAdapterCpp::setSecureBiometric(const std::string& key, const
 }
 
 void AndroidStorageAdapterCpp::setSecureBiometricWithLevel(const std::string& key, const std::string& value, int level) {
-    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(std::string, std::string, jint)>("setSecureBiometricWithLevel");
-    method(AndroidStorageAdapterJava::javaClassStatic(), key, value, level);
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(alias_ref<JString>, alias_ref<JString>, jint)>("setSecureBiometricWithLevel");
+    method(AndroidStorageAdapterJava::javaClassStatic(), toJavaString(key), toJavaString(value), level);
 }
 
 std::optional<std::string> AndroidStorageAdapterCpp::getSecureBiometric(const std::string& key) {
-    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jstring(std::string)>("getSecureBiometric");
-    auto result = method(AndroidStorageAdapterJava::javaClassStatic(), key);
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jstring(alias_ref<JString>)>("getSecureBiometric");
+    auto result = method(AndroidStorageAdapterJava::javaClassStatic(), toJavaString(key));
     if (!result) return std::nullopt;
     return result->toStdString();
 }
 
 void AndroidStorageAdapterCpp::deleteSecureBiometric(const std::string& key) {
-    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(std::string)>("deleteSecureBiometric");
-    method(AndroidStorageAdapterJava::javaClassStatic(), key);
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(alias_ref<JString>)>("deleteSecureBiometric");
+    method(AndroidStorageAdapterJava::javaClassStatic(), toJavaString(key));
 }
 
 bool AndroidStorageAdapterCpp::hasSecureBiometric(const std::string& key) {
-    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jboolean(std::string)>("hasSecureBiometric");
-    return method(AndroidStorageAdapterJava::javaClassStatic(), key);
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jboolean(alias_ref<JString>)>("hasSecureBiometric");
+    return method(AndroidStorageAdapterJava::javaClassStatic(), toJavaString(key));
 }
 
 void AndroidStorageAdapterCpp::clearSecureBiometric() {

package/android/src/main/cpp/AndroidStorageAdapterCpp.hpp

@@ -9,16 +9,16 @@ namespace NitroStorage {
 struct AndroidStorageAdapterJava : facebook::jni::JavaClass<AndroidStorageAdapterJava> {
   static constexpr auto kJavaDescriptor = "Lcom/nitrostorage/AndroidStorageAdapter;";
   
-  static facebook::jni::alias_ref<facebook::jni::JObject> getContext() {
+  static void ensureInitialized() {
      static auto method = javaClassStatic()->getStaticMethod<facebook::jni::JObject()>("getContext", "()Landroid/content/Context;");
-     return method(javaClassStatic());
+     method(javaClassStatic());
   }
 
 };
 
 class AndroidStorageAdapterCpp : public NativeStorageAdapter {
 public:
-    explicit AndroidStorageAdapterCpp(facebook::jni::alias_ref<facebook::jni::JObject> context);
+    AndroidStorageAdapterCpp();
     ~AndroidStorageAdapterCpp() override;
     
     void setDisk(const std::string& key, const std::string& value) override;

package/android/src/main/java/com/nitrostorage/AndroidStorageAdapter.kt

@@ -65,20 +65,44 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
 
     private val masterKeyAlias = "${context.packageName}.nitro_storage.master_key"
 
-    private val masterKey: MasterKey = try {
-        MasterKey.Builder(context, masterKeyAlias)
-            .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
-            .build()
-    } catch (e: Exception) {
-        throw RuntimeException("NitroStorage: Cannot create encryption key. Device may not support AES256-GCM.", e)
+    private val masterKey: MasterKey by lazy {
+        try {
+            createDefaultMasterKey()
+        } catch (e: Exception) {
+            throw permanentSecureStoreError(
+                "NitroStorage: Cannot create the Secure encryption key.",
+                e,
+            )
+        }
     }
 
-    private val encryptedPreferences: SharedPreferences = initializeEncryptedPreferences(
-        "NitroStorageSecure",
-        masterKey,
-        masterKeyAlias,
-        ::createDefaultMasterKey,
-    )
+    private val encryptedPreferences: SharedPreferences by lazy {
+        try {
+            initializeEncryptedPreferences(
+                "NitroStorageSecure",
+                masterKey,
+                masterKeyAlias,
+                ::createDefaultMasterKey,
+            )
+        } catch (e: Exception) {
+            throw permanentSecureStoreError(
+                "NitroStorage: Cannot open Secure storage.",
+                e,
+            )
+        }
+    }
+
+    private fun permanentSecureStoreError(message: String, cause: Exception): RuntimeException {
+        if (cause.message?.contains("[nitro-error:storage_corruption]") == true &&
+            cause is RuntimeException
+        ) {
+            return cause
+        }
+        return RuntimeException(
+            "[nitro-error:storage_corruption] $message ${cause.message ?: ""}".trimEnd(),
+            cause,
+        )
+    }
 
     private val biometricMasterKeyAlias = "${context.packageName}.nitro_storage.biometric_key"
     private val biometricOrPasscodeMasterKeyAlias =
@@ -273,25 +297,55 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
 
     private fun existingBiometricPreferences(): List<SharedPreferences> {
         val stores = mutableListOf<SharedPreferences>()
+        if (
+            biometricOrPasscodeInitialized ||
+            preferencesFileExists("NitroStorageBiometricOrPasscode")
+        ) {
+            stores.add(biometricOrPasscodePreferences)
+        }
+        if (
+            legacyBiometricInitialized ||
+            preferencesFileExists("NitroStorageBiometric")
+        ) {
+            stores.add(legacyBiometricPreferences)
+        }
         if (
             biometricOnlyInitialized ||
             preferencesFileExists("NitroStorageBiometricOnly")
         ) {
             stores.add(biometricOnlyPreferences)
         }
+        return stores
+    }
+
+    private fun <T : Any> firstInExistingBiometricPreferences(
+        lookup: (SharedPreferences) -> T?,
+    ): T? {
         if (
             biometricOrPasscodeInitialized ||
             preferencesFileExists("NitroStorageBiometricOrPasscode")
         ) {
-            stores.add(biometricOrPasscodePreferences)
+            lookup(biometricOrPasscodePreferences)?.let { return it }
         }
         if (
             legacyBiometricInitialized ||
             preferencesFileExists("NitroStorageBiometric")
         ) {
-            stores.add(legacyBiometricPreferences)
+            lookup(legacyBiometricPreferences)?.let { return it }
         }
-        return stores
+        if (
+            biometricOnlyInitialized ||
+            preferencesFileExists("NitroStorageBiometricOnly")
+        ) {
+            lookup(biometricOnlyPreferences)?.let { return it }
+        }
+        return null
+    }
+
+    private fun biometricPreferencesContain(key: String): Boolean {
+        return firstInExistingBiometricPreferences { preferences ->
+            if (preferences.contains(key)) true else null
+        } ?: false
     }
 
     private fun biometricPreferencesForLevel(level: Int): SharedPreferences {
@@ -663,7 +717,7 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
             if (inst.encryptedPreferences.contains(key)) {
                 return true
             }
-            return inst.existingBiometricPreferences().any { it.contains(key) }
+            return inst.biometricPreferencesContain(key)
         }
 
         @JvmStatic
@@ -776,13 +830,9 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         fun getSecureBiometric(key: String): String? {
             val inst = getInstanceOrThrow()
             return try {
-                for (preferences in inst.existingBiometricPreferences()) {
-                    val value = inst.getSecureSafe(preferences, key)
-                    if (value != null) {
-                        return value
-                    }
+                inst.firstInExistingBiometricPreferences { preferences ->
+                    inst.getSecureSafe(preferences, key)
                 }
-                null
             } catch (e: Exception) {
                 throw e.wrapStorageException(
                     "NitroStorage: Failed to read biometric storage: ${e.message}",
@@ -809,7 +859,7 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         fun hasSecureBiometric(key: String): Boolean {
             val inst = getInstanceOrThrow()
             return try {
-                inst.existingBiometricPreferences().any { it.contains(key) }
+                inst.biometricPreferencesContain(key)
             } catch (e: Exception) {
                 throw e.wrapStorageException(
                     "NitroStorage: Failed to inspect biometric storage: ${e.message}",

package/android/src/main/java/com/nitrostorage/DiskSqliteStore.kt

@@ -44,6 +44,7 @@ internal class DiskSqliteStore(
     @Synchronized
     fun remove(key: String) {
         db.execSQL("DELETE FROM kv WHERE key = ?", arrayOf(key))
+        removeLegacyKeys(listOf(key))
     }
 
     @Synchronized
@@ -86,6 +87,7 @@ internal class DiskSqliteStore(
         } finally {
             db.endTransaction()
         }
+        removeLegacyKeys(keys.asIterable())
     }
 
     @Synchronized
@@ -103,9 +105,9 @@ internal class DiskSqliteStore(
     fun getKeysByPrefix(prefix: String): Array<String> {
         val pattern = buildString {
             for (character in prefix) {
-                if (character == '%' || character == '_' || character == '\\') {
-                    append('\\')
-                }
+                // LIKE stops at NUL; startsWith below checks the complete prefix.
+                if (character == '\u0000') break
+                if (character == '%' || character == '_' || character == '\\') append('\\')
                 append(character)
             }
             append('%')
@@ -116,7 +118,10 @@ internal class DiskSqliteStore(
         ).use { cursor ->
             val keys = ArrayList<String>(cursor.count)
             while (cursor.moveToNext()) {
-                keys.add(cursor.getString(0))
+                val key = cursor.getString(0)
+                if (key.startsWith(prefix)) {
+                    keys.add(key)
+                }
             }
             return keys.toTypedArray()
         }
@@ -132,6 +137,9 @@ internal class DiskSqliteStore(
     @Synchronized
     fun clear() {
         db.execSQL("DELETE FROM kv")
+        if (legacyPreferences.all.isNotEmpty()) {
+            legacyPreferences.edit().clear().apply()
+        }
     }
 
     private fun migrateLegacyPreferences() {
@@ -164,6 +172,16 @@ internal class DiskSqliteStore(
         }
     }
 
+    private fun removeLegacyKeys(keys: Iterable<String>) {
+        val present = keys.filter { legacyPreferences.contains(it) }
+        if (present.isEmpty()) {
+            return
+        }
+        val editor = legacyPreferences.edit()
+        present.forEach { editor.remove(it) }
+        editor.apply()
+    }
+
     private companion object {
         const val DATABASE_NAME = "nitro-storage-disk.sqlite"
         const val PREFS_MIGRATION_KEY = "prefs_v1"

package/app.plugin.js

@@ -1,11 +1,11 @@
+const fs = require("fs");
+const path = require("path");
 const {
   withInfoPlist,
   withAndroidManifest,
   withDangerousMod,
   createRunOncePlugin,
-} = require("@expo/config-plugins");
-const fs = require("fs");
-const path = require("path");
+} = require("expo/config-plugins");
 const pkg = require("./package.json");
 
 const DATA_EXTRACTION_RULES_RESOURCE =
@@ -84,63 +84,61 @@ function writeAndroidBackupFiles(projectRoot) {
   );
 }
 
-const withNitroStorage = (config, props = {}) => {
-  const defaultFaceIDPermission =
-    "Allow $(PRODUCT_NAME) to use Face ID for secure authentication";
-  const {
-    faceIDPermission,
-    addBiometricPermissions = false,
-    configureAndroidBackup = true,
-  } = props;
-
-  config = withInfoPlist(config, (config) => {
-    if (
-      typeof faceIDPermission === "string" &&
-      faceIDPermission.trim() !== ""
-    ) {
-      config.modResults.NSFaceIDUsageDescription = faceIDPermission;
-    } else if (!config.modResults.NSFaceIDUsageDescription) {
-      config.modResults.NSFaceIDUsageDescription = defaultFaceIDPermission;
-    }
-    return config;
-  });
+const DEFAULT_FACE_ID_PERMISSION =
+  "Allow $(PRODUCT_NAME) to use Face ID for secure authentication";
 
-  config = withAndroidManifest(config, (config) => {
-    if (configureAndroidBackup) {
-      ensureBackupAttributes(config.modResults);
-    }
+const BIOMETRIC_PERMISSIONS = [
+  "android.permission.USE_BIOMETRIC",
+  "android.permission.USE_FINGERPRINT",
+];
 
-    if (!addBiometricPermissions) {
-      return config;
-    }
+function applyInfoPlist(infoPlist, props = {}) {
+  const { faceIDPermission } = props;
+  if (typeof faceIDPermission === "string" && faceIDPermission.trim() !== "") {
+    infoPlist.NSFaceIDUsageDescription = faceIDPermission;
+  } else if (!infoPlist.NSFaceIDUsageDescription) {
+    infoPlist.NSFaceIDUsageDescription = DEFAULT_FACE_ID_PERMISSION;
+  }
+  return infoPlist;
+}
 
-    if (!config.modResults.manifest["uses-permission"]) {
-      config.modResults.manifest["uses-permission"] = [];
-    }
+function applyAndroidManifest(androidManifest, props = {}) {
+  const { addBiometricPermissions = false, configureAndroidBackup = true } =
+    props;
 
-    const permissions = config.modResults.manifest["uses-permission"];
+  if (configureAndroidBackup) {
+    ensureBackupAttributes(androidManifest);
+  }
 
-    const biometricPermission = {
-      $: { "android:name": "android.permission.USE_BIOMETRIC" },
-    };
-    const fingerprintPermission = {
-      $: { "android:name": "android.permission.USE_FINGERPRINT" },
-    };
+  if (!addBiometricPermissions) {
+    return androidManifest;
+  }
 
-    const hasBiometric = permissions.some(
-      (p) => p.$?.["android:name"] === "android.permission.USE_BIOMETRIC",
-    );
-    const hasFingerprint = permissions.some(
-      (p) => p.$?.["android:name"] === "android.permission.USE_FINGERPRINT",
-    );
+  if (!androidManifest.manifest["uses-permission"]) {
+    androidManifest.manifest["uses-permission"] = [];
+  }
 
-    if (!hasBiometric) {
-      permissions.push(biometricPermission);
-    }
-    if (!hasFingerprint) {
-      permissions.push(fingerprintPermission);
+  const permissions = androidManifest.manifest["uses-permission"];
+  for (const name of BIOMETRIC_PERMISSIONS) {
+    const present = permissions.some((p) => p.$?.["android:name"] === name);
+    if (!present) {
+      permissions.push({ $: { "android:name": name } });
     }
+  }
+
+  return androidManifest;
+}
+
+const withNitroStorage = (config, props = {}) => {
+  const { configureAndroidBackup = true } = props;
+
+  config = withInfoPlist(config, (config) => {
+    applyInfoPlist(config.modResults, props);
+    return config;
+  });
 
+  config = withAndroidManifest(config, (config) => {
+    applyAndroidManifest(config.modResults, props);
     return config;
   });
 
@@ -164,6 +162,8 @@ module.exports = createRunOncePlugin(
 );
 module.exports.withNitroStorage = withNitroStorage;
 module.exports._internal = {
+  applyInfoPlist,
+  applyAndroidManifest,
   dataExtractionRulesXml,
   fullBackupContentXml,
   ensureBackupAttributes,

package/cpp/bindings/HybridStorage.cpp

@@ -1,4 +1,5 @@
 #include "HybridStorage.hpp"
+#include <algorithm>
 #include <cmath>
 #include <stdexcept>
 
@@ -32,8 +33,8 @@ HybridStorage::HybridStorage()
 #if __APPLE__
     nativeAdapter_ = std::make_shared<::NitroStorage::IOSStorageAdapterCpp>();
 #elif __ANDROID__
-    auto context = ::NitroStorage::AndroidStorageAdapterJava::getContext();
-    nativeAdapter_ = std::make_shared<::NitroStorage::AndroidStorageAdapterCpp>(context);
+    ::NitroStorage::AndroidStorageAdapterJava::ensureInitialized();
+    nativeAdapter_ = std::make_shared<::NitroStorage::AndroidStorageAdapterCpp>();
 #endif
 #endif
 }
@@ -338,8 +339,17 @@ void HybridStorage::setBatch(const std::vector<std::string>& keys, const std::ve
             break;
         case Scope::Secure:
             ensureAdapter();
-            runAdapterOperation(
-                [&] { nativeAdapter_->setSecureBatch(keys, values); }, "Secure setBatch");
+            try {
+                runAdapterOperation(
+                    [&] { nativeAdapter_->setSecureBatch(keys, values); }, "Secure setBatch");
+            } catch (const ::NitroStorage::PartialBatchError& error) {
+                const auto listeners = copyListenersForScope(static_cast<int>(s));
+                const auto applied = std::min(error.appliedCount(), keys.size());
+                for (size_t i = 0; i < applied; ++i) {
+                    notifyListeners(listeners, keys[i], values[i]);
+                }
+                throw;
+            }
             break;
     }
 
@@ -402,8 +412,17 @@ void HybridStorage::removeBatch(const std::vector<std::string>& keys, double sco
             break;
         case Scope::Secure:
             ensureAdapter();
-            runAdapterOperation(
-                [&] { nativeAdapter_->deleteSecureBatch(keys); }, "Secure removeBatch");
+            try {
+                runAdapterOperation(
+                    [&] { nativeAdapter_->deleteSecureBatch(keys); }, "Secure removeBatch");
+            } catch (const ::NitroStorage::PartialBatchError& error) {
+                const auto listeners = copyListenersForScope(static_cast<int>(s));
+                const auto applied = std::min(error.appliedCount(), keys.size());
+                for (size_t i = 0; i < applied; ++i) {
+                    notifyListeners(listeners, keys[i], std::nullopt);
+                }
+                throw;
+            }
             break;
     }
 

package/cpp/core/NativeStorageAdapter.hpp

@@ -1,11 +1,24 @@
 #pragma once
 
-#include <string>
+#include <cstddef>
 #include <optional>
+#include <stdexcept>
+#include <string>
 #include <vector>
 
 namespace NitroStorage {
 
+class PartialBatchError : public std::runtime_error {
+public:
+    PartialBatchError(size_t appliedCount, const std::string& message)
+        : std::runtime_error(message), appliedCount_(appliedCount) {}
+
+    size_t appliedCount() const noexcept { return appliedCount_; }
+
+private:
+    size_t appliedCount_;
+};
+
 class NativeStorageAdapter {
 public:
     virtual ~NativeStorageAdapter() = default;