react-native-nitro-storage 0.1.4 → 0.3.1

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

@@ -3,6 +3,52 @@
 namespace NitroStorage {
 
 using namespace facebook::jni;
+using JavaStringArray = JArrayClass<jstring>;
+
+namespace {
+
+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]);
+        javaArray->setElement(static_cast<jsize>(i), javaValue.get());
+    }
+    return javaArray;
+}
+
+std::vector<std::optional<std::string>> fromNullableJavaStringArray(alias_ref<JavaStringArray> values) {
+    std::vector<std::optional<std::string>> parsedValues;
+    if (!values) return parsedValues;
+
+    const jsize size = static_cast<jsize>(values->size());
+    parsedValues.reserve(size);
+    for (jsize i = 0; i < size; ++i) {
+        auto currentValue = values->getElement(i);
+        if (!currentValue) {
+            parsedValues.push_back(std::nullopt);
+            continue;
+        }
+        parsedValues.push_back(currentValue->toStdString());
+    }
+    return parsedValues;
+}
+
+std::vector<std::string> fromJavaStringArray(alias_ref<JavaStringArray> values) {
+    std::vector<std::string> result;
+    if (!values) return result;
+
+    const jsize size = static_cast<jsize>(values->size());
+    result.reserve(size);
+    for (jsize i = 0; i < size; ++i) {
+        auto currentValue = values->getElement(i);
+        if (currentValue) {
+            result.push_back(currentValue->toStdString());
+        }
+    }
+    return result;
+}
+
+} // namespace
 
 AndroidStorageAdapterCpp::AndroidStorageAdapterCpp(alias_ref<JObject> context) {
     if (!context) [[unlikely]] {
@@ -12,6 +58,8 @@ AndroidStorageAdapterCpp::AndroidStorageAdapterCpp(alias_ref<JObject> context) {
 
 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);
@@ -29,6 +77,65 @@ void AndroidStorageAdapterCpp::deleteDisk(const std::string& key) {
     method(AndroidStorageAdapterJava::javaClassStatic(), key);
 }
 
+bool AndroidStorageAdapterCpp::hasDisk(const std::string& key) {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jboolean(std::string)>("hasDisk");
+    return method(AndroidStorageAdapterJava::javaClassStatic(), key);
+}
+
+std::vector<std::string> AndroidStorageAdapterCpp::getAllKeysDisk() {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+        local_ref<JavaStringArray>()
+    >("getAllKeysDisk");
+    auto keys = method(AndroidStorageAdapterJava::javaClassStatic());
+    return fromJavaStringArray(keys);
+}
+
+size_t AndroidStorageAdapterCpp::sizeDisk() {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jint()>("sizeDisk");
+    return static_cast<size_t>(method(AndroidStorageAdapterJava::javaClassStatic()));
+}
+
+void AndroidStorageAdapterCpp::setDiskBatch(
+    const std::vector<std::string>& keys,
+    const std::vector<std::string>& values
+) {
+    auto javaKeys = toJavaStringArray(keys);
+    auto javaValues = toJavaStringArray(values);
+    static auto method =
+        AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+            void(alias_ref<JavaStringArray>, alias_ref<JavaStringArray>)
+        >("setDiskBatch");
+    method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys, javaValues);
+}
+
+std::vector<std::optional<std::string>> AndroidStorageAdapterCpp::getDiskBatch(
+    const std::vector<std::string>& keys
+) {
+    auto javaKeys = toJavaStringArray(keys);
+    static auto method =
+        AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+            local_ref<JavaStringArray>(alias_ref<JavaStringArray>)
+        >("getDiskBatch");
+    auto values = method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys);
+    return fromNullableJavaStringArray(values);
+}
+
+void AndroidStorageAdapterCpp::deleteDiskBatch(const std::vector<std::string>& keys) {
+    auto javaKeys = toJavaStringArray(keys);
+    static auto method =
+        AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+            void(alias_ref<JavaStringArray>)
+        >("deleteDiskBatch");
+    method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys);
+}
+
+void AndroidStorageAdapterCpp::clearDisk() {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void()>("clearDisk");
+    method(AndroidStorageAdapterJava::javaClassStatic());
+}
+
+// --- 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);
@@ -46,9 +153,56 @@ void AndroidStorageAdapterCpp::deleteSecure(const std::string& key) {
     method(AndroidStorageAdapterJava::javaClassStatic(), key);
 }
 
-void AndroidStorageAdapterCpp::clearDisk() {
-    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void()>("clearDisk");
-    method(AndroidStorageAdapterJava::javaClassStatic());
+bool AndroidStorageAdapterCpp::hasSecure(const std::string& key) {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jboolean(std::string)>("hasSecure");
+    return method(AndroidStorageAdapterJava::javaClassStatic(), key);
+}
+
+std::vector<std::string> AndroidStorageAdapterCpp::getAllKeysSecure() {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+        local_ref<JavaStringArray>()
+    >("getAllKeysSecure");
+    auto keys = method(AndroidStorageAdapterJava::javaClassStatic());
+    return fromJavaStringArray(keys);
+}
+
+size_t AndroidStorageAdapterCpp::sizeSecure() {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jint()>("sizeSecure");
+    return static_cast<size_t>(method(AndroidStorageAdapterJava::javaClassStatic()));
+}
+
+void AndroidStorageAdapterCpp::setSecureBatch(
+    const std::vector<std::string>& keys,
+    const std::vector<std::string>& values
+) {
+    auto javaKeys = toJavaStringArray(keys);
+    auto javaValues = toJavaStringArray(values);
+    static auto method =
+        AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+            void(alias_ref<JavaStringArray>, alias_ref<JavaStringArray>)
+        >("setSecureBatch");
+    method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys, javaValues);
+}
+
+std::vector<std::optional<std::string>> AndroidStorageAdapterCpp::getSecureBatch(
+    const std::vector<std::string>& keys
+) {
+    auto javaKeys = toJavaStringArray(keys);
+    static auto method =
+        AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+            local_ref<JavaStringArray>(alias_ref<JavaStringArray>)
+        >("getSecureBatch");
+    auto values = method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys);
+    return fromNullableJavaStringArray(values);
+}
+
+void AndroidStorageAdapterCpp::deleteSecureBatch(const std::vector<std::string>& keys) {
+    auto javaKeys = toJavaStringArray(keys);
+    static auto method =
+        AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+            void(alias_ref<JavaStringArray>)
+        >("deleteSecureBatch");
+    method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys);
 }
 
 void AndroidStorageAdapterCpp::clearSecure() {
@@ -56,4 +210,38 @@ void AndroidStorageAdapterCpp::clearSecure() {
     method(AndroidStorageAdapterJava::javaClassStatic());
 }
 
+// --- Config (no-ops on Android; access control / groups are iOS-specific) ---
+
+void AndroidStorageAdapterCpp::setSecureAccessControl(int /*level*/) {}
+void AndroidStorageAdapterCpp::setKeychainAccessGroup(const std::string& /*group*/) {}
+
+// --- Biometric ---
+
+void AndroidStorageAdapterCpp::setSecureBiometric(const std::string& key, const std::string& value) {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(std::string, std::string)>("setSecureBiometric");
+    method(AndroidStorageAdapterJava::javaClassStatic(), key, value);
+}
+
+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);
+    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);
+}
+
+bool AndroidStorageAdapterCpp::hasSecureBiometric(const std::string& key) {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jboolean(std::string)>("hasSecureBiometric");
+    return method(AndroidStorageAdapterJava::javaClassStatic(), key);
+}
+
+void AndroidStorageAdapterCpp::clearSecureBiometric() {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void()>("clearSecureBiometric");
+    method(AndroidStorageAdapterJava::javaClassStatic());
+}
+
 } // namespace NitroStorage

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

@@ -18,47 +18,6 @@ struct AndroidStorageAdapterJava : facebook::jni::JavaClass<AndroidStorageAdapte
      return method(javaClassStatic());
   }
 
-  void setDisk(std::string key, std::string value) {
-      static auto method = javaClassStatic()->getMethod<void(std::string, std::string)>("setDisk");
-      method(self(), key, value);
-  }
-
-  std::string getDisk(std::string key) {
-      static auto method = javaClassStatic()->getMethod<jstring(std::string)>("getDisk");
-      auto result = method(self(), key);
-      return result ? result->toStdString() : "";
-  }
-  
-  void deleteDisk(std::string key) {
-      static auto method = javaClassStatic()->getMethod<void(std::string)>("deleteDisk");
-      method(self(), key);
-  }
-
-  void setSecure(std::string key, std::string value) {
-      static auto method = javaClassStatic()->getMethod<void(std::string, std::string)>("setSecure");
-      method(self(), key, value);
-  }
-
-  std::string getSecure(std::string key) {
-      static auto method = javaClassStatic()->getMethod<jstring(std::string)>("getSecure");
-      auto result = method(self(), key);
-      return result ? result->toStdString() : "";
-  }
-  
-  void deleteSecure(std::string key) {
-      static auto method = javaClassStatic()->getMethod<void(std::string)>("deleteSecure");
-      method(self(), key);
-  }
-
-  void clearDisk() {
-      static auto method = javaClassStatic()->getStaticMethod<void()>("clearDisk");
-      method(javaClassStatic());
-  }
-
-  void clearSecure() {
-      static auto method = javaClassStatic()->getStaticMethod<void()>("clearSecure");
-      method(javaClassStatic());
-  }
 };
 
 class AndroidStorageAdapterCpp : public NativeStorageAdapter {
@@ -69,13 +28,34 @@ public:
     void setDisk(const std::string& key, const std::string& value) override;
     std::optional<std::string> getDisk(const std::string& key) override;
     void deleteDisk(const std::string& key) override;
+    bool hasDisk(const std::string& key) override;
+    std::vector<std::string> getAllKeysDisk() override;
+    size_t sizeDisk() override;
+    void setDiskBatch(const std::vector<std::string>& keys, const std::vector<std::string>& values) override;
+    std::vector<std::optional<std::string>> getDiskBatch(const std::vector<std::string>& keys) override;
+    void deleteDiskBatch(const std::vector<std::string>& keys) override;
     
     void setSecure(const std::string& key, const std::string& value) override;
     std::optional<std::string> getSecure(const std::string& key) override;
     void deleteSecure(const std::string& key) override;
+    bool hasSecure(const std::string& key) override;
+    std::vector<std::string> getAllKeysSecure() override;
+    size_t sizeSecure() override;
+    void setSecureBatch(const std::vector<std::string>& keys, const std::vector<std::string>& values) override;
+    std::vector<std::optional<std::string>> getSecureBatch(const std::vector<std::string>& keys) override;
+    void deleteSecureBatch(const std::vector<std::string>& keys) override;
     
     void clearDisk() override;
     void clearSecure() override;
+
+    void setSecureAccessControl(int level) override;
+    void setKeychainAccessGroup(const std::string& group) override;
+
+    void setSecureBiometric(const std::string& key, const std::string& value) override;
+    std::optional<std::string> getSecureBiometric(const std::string& key) override;
+    void deleteSecureBiometric(const std::string& key) override;
+    bool hasSecureBiometric(const std::string& key) override;
+    void clearSecureBiometric() override;
 };
 
 } // namespace NitroStorage

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

@@ -11,39 +11,52 @@ import javax.crypto.AEADBadTagException
 class AndroidStorageAdapter private constructor(private val context: Context) {
     private val sharedPreferences: SharedPreferences = 
         context.getSharedPreferences("NitroStorage", Context.MODE_PRIVATE)
-    
-    private val masterKey: MasterKey = MasterKey.Builder(context)
+
+    private val masterKeyAlias = "${context.packageName}.nitro_storage.master_key"
+    private val masterKey: MasterKey = MasterKey.Builder(context, masterKeyAlias)
         .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
         .build()
     
-    private val encryptedPreferences: SharedPreferences = initializeEncryptedPreferences()
+    private val encryptedPreferences: SharedPreferences = initializeEncryptedPreferences("NitroStorageSecure", masterKey)
+
+    private val biometricMasterKeyAlias = "${context.packageName}.nitro_storage.biometric_key"
+
+    private val biometricPreferences: SharedPreferences by lazy {
+        try {
+            val bioKey = MasterKey.Builder(context, biometricMasterKeyAlias)
+                .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
+                .setUserAuthenticationRequired(true, 30)
+                .build()
+            initializeEncryptedPreferences("NitroStorageBiometric", bioKey)
+        } catch (e: Exception) {
+            Log.w("NitroStorage", "Biometric storage unavailable, falling back to regular encrypted storage: ${e.message}")
+            encryptedPreferences
+        }
+    }
     
-    private fun initializeEncryptedPreferences(): SharedPreferences {
+    private fun initializeEncryptedPreferences(name: String, key: MasterKey): SharedPreferences {
         return try {
             EncryptedSharedPreferences.create(
                 context,
-                "NitroStorageSecure",
-                masterKey,
+                name,
+                key,
                 EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
                 EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
             )
         } catch (e: Exception) {
-            // Handle corrupted keystore keys by clearing and re-initializing
             if (e is AEADBadTagException || e.cause is AEADBadTagException) {
-                Log.w("NitroStorage", "Detected corrupted encryption keys, clearing secure storage...")
-                clearCorruptedSecureStorage()
-                
-                // Retry initialization
+                Log.w("NitroStorage", "Detected corrupted encryption keys for $name, clearing...")
+                clearCorruptedStorage(name, key)
                 EncryptedSharedPreferences.create(
                     context,
-                    "NitroStorageSecure",
-                    masterKey,
+                    name,
+                    key,
                     EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
                     EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
                 )
             } else {
                 throw RuntimeException(
-                    "NitroStorage: Failed to initialize secure storage. " +
+                    "NitroStorage: Failed to initialize $name. " +
                     "This may be due to corrupted encryption keys. " +
                     "Try clearing app data or reinstalling the app.", e
                 )
@@ -51,19 +64,30 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         }
     }
     
-    private fun clearCorruptedSecureStorage() {
+    private fun clearCorruptedStorage(name: String, key: MasterKey) {
         try {
-            // Delete the encrypted shared preferences file
-            context.deleteSharedPreferences("NitroStorageSecure")
-            
-            // Delete the master key from Android Keystore
+            context.deleteSharedPreferences(name)
             val keyStore = KeyStore.getInstance("AndroidKeyStore")
             keyStore.load(null)
-            keyStore.deleteEntry(MasterKey.DEFAULT_MASTER_KEY_ALIAS)
-            
-            Log.i("NitroStorage", "Successfully cleared corrupted secure storage")
+            val alias = if (key === masterKey) masterKeyAlias else biometricMasterKeyAlias
+            keyStore.deleteEntry(alias)
+            Log.i("NitroStorage", "Cleared corrupted storage: $name")
+        } catch (e: Exception) {
+            Log.e("NitroStorage", "Failed to clear corrupted storage: $name", e)
+        }
+    }
+
+    private fun getSecureSafe(prefs: SharedPreferences, key: String): String? {
+        return try {
+            prefs.getString(key, null)
         } catch (e: Exception) {
-            Log.e("NitroStorage", "Failed to clear corrupted secure storage", e)
+            if (e is AEADBadTagException || e.cause is AEADBadTagException) {
+                Log.w("NitroStorage", "Corrupt entry for key '$key', removing")
+                prefs.edit().remove(key).commit()
+                null
+            } else {
+                throw e
+            }
         }
     }
     
@@ -93,45 +117,173 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         fun getContext(): Context {
             return getInstanceOrThrow().context
         }
+
+        // --- Disk ---
         
         @JvmStatic
         fun setDisk(key: String, value: String) {
             getInstanceOrThrow().sharedPreferences.edit().putString(key, value).apply()
         }
+
+        @JvmStatic
+        fun setDiskBatch(keys: Array<String>, values: Array<String>) {
+            val editor = getInstanceOrThrow().sharedPreferences.edit()
+            val count = minOf(keys.size, values.size)
+            for (index in 0 until count) {
+                editor.putString(keys[index], values[index])
+            }
+            editor.apply()
+        }
         
         @JvmStatic
         fun getDisk(key: String): String? {
             return getInstanceOrThrow().sharedPreferences.getString(key, null)
         }
+
+        @JvmStatic
+        fun getDiskBatch(keys: Array<String>): Array<String?> {
+            val prefs = getInstanceOrThrow().sharedPreferences
+            return Array(keys.size) { index ->
+                prefs.getString(keys[index], null)
+            }
+        }
         
         @JvmStatic
         fun deleteDisk(key: String) {
             getInstanceOrThrow().sharedPreferences.edit().remove(key).apply()
         }
+
+        @JvmStatic
+        fun deleteDiskBatch(keys: Array<String>) {
+            val editor = getInstanceOrThrow().sharedPreferences.edit()
+            for (key in keys) {
+                editor.remove(key)
+            }
+            editor.apply()
+        }
+
+        @JvmStatic
+        fun hasDisk(key: String): Boolean {
+            return getInstanceOrThrow().sharedPreferences.contains(key)
+        }
+
+        @JvmStatic
+        fun getAllKeysDisk(): Array<String> {
+            return getInstanceOrThrow().sharedPreferences.all.keys.toTypedArray()
+        }
+
+        @JvmStatic
+        fun sizeDisk(): Int {
+            return getInstanceOrThrow().sharedPreferences.all.size
+        }
+
+        @JvmStatic
+        fun clearDisk() {
+            getInstanceOrThrow().sharedPreferences.edit().clear().apply()
+        }
+
+        // --- Secure (uses commit for reliability) ---
         
         @JvmStatic
         fun setSecure(key: String, value: String) {
-            getInstanceOrThrow().encryptedPreferences.edit().putString(key, value).apply()
+            getInstanceOrThrow().encryptedPreferences.edit().putString(key, value).commit()
+        }
+
+        @JvmStatic
+        fun setSecureBatch(keys: Array<String>, values: Array<String>) {
+            val editor = getInstanceOrThrow().encryptedPreferences.edit()
+            val count = minOf(keys.size, values.size)
+            for (index in 0 until count) {
+                editor.putString(keys[index], values[index])
+            }
+            editor.commit()
         }
         
         @JvmStatic
         fun getSecure(key: String): String? {
-            return getInstanceOrThrow().encryptedPreferences.getString(key, null)
+            return getInstanceOrThrow().getSecureSafe(getInstanceOrThrow().encryptedPreferences, key)
+        }
+
+        @JvmStatic
+        fun getSecureBatch(keys: Array<String>): Array<String?> {
+            val inst = getInstanceOrThrow()
+            return Array(keys.size) { index ->
+                inst.getSecureSafe(inst.encryptedPreferences, keys[index])
+            }
         }
         
         @JvmStatic
         fun deleteSecure(key: String) {
-            getInstanceOrThrow().encryptedPreferences.edit().remove(key).apply()
+            val inst = getInstanceOrThrow()
+            inst.encryptedPreferences.edit().remove(key).commit()
+            inst.biometricPreferences.edit().remove(key).commit()
         }
 
         @JvmStatic
-        fun clearDisk() {
-            getInstanceOrThrow().sharedPreferences.edit().clear().apply()
+        fun deleteSecureBatch(keys: Array<String>) {
+            val inst = getInstanceOrThrow()
+            val secureEditor = inst.encryptedPreferences.edit()
+            val biometricEditor = inst.biometricPreferences.edit()
+            for (key in keys) {
+                secureEditor.remove(key)
+                biometricEditor.remove(key)
+            }
+            secureEditor.commit()
+            biometricEditor.commit()
+        }
+
+        @JvmStatic
+        fun hasSecure(key: String): Boolean {
+            val inst = getInstanceOrThrow()
+            return inst.encryptedPreferences.contains(key) || inst.biometricPreferences.contains(key)
+        }
+
+        @JvmStatic
+        fun getAllKeysSecure(): Array<String> {
+            val inst = getInstanceOrThrow()
+            val keys = linkedSetOf<String>()
+            keys.addAll(inst.encryptedPreferences.all.keys)
+            keys.addAll(inst.biometricPreferences.all.keys)
+            return keys.toTypedArray()
+        }
+
+        @JvmStatic
+        fun sizeSecure(): Int {
+            return getAllKeysSecure().size
         }
 
         @JvmStatic
         fun clearSecure() {
-            getInstanceOrThrow().encryptedPreferences.edit().clear().apply()
+            val inst = getInstanceOrThrow()
+            inst.encryptedPreferences.edit().clear().commit()
+            inst.biometricPreferences.edit().clear().commit()
+        }
+
+        // --- Biometric (separate encrypted store, requires recent biometric auth on Android) ---
+
+        @JvmStatic
+        fun setSecureBiometric(key: String, value: String) {
+            getInstanceOrThrow().biometricPreferences.edit().putString(key, value).commit()
+        }
+
+        @JvmStatic
+        fun getSecureBiometric(key: String): String? {
+            return getInstanceOrThrow().getSecureSafe(getInstanceOrThrow().biometricPreferences, key)
+        }
+
+        @JvmStatic
+        fun deleteSecureBiometric(key: String) {
+            getInstanceOrThrow().biometricPreferences.edit().remove(key).commit()
+        }
+
+        @JvmStatic
+        fun hasSecureBiometric(key: String): Boolean {
+            return getInstanceOrThrow().biometricPreferences.contains(key)
+        }
+
+        @JvmStatic
+        fun clearSecureBiometric() {
+            getInstanceOrThrow().biometricPreferences.edit().clear().commit()
         }
     }
 }

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

@@ -1,13 +1,13 @@
 package com.nitrostorage
 
-import com.facebook.react.TurboReactPackage
+import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.model.ReactModuleInfo
 import com.facebook.react.module.model.ReactModuleInfoProvider
 import java.util.HashMap
 
-class NitroStoragePackage : TurboReactPackage() {
+class NitroStoragePackage : BaseReactPackage() {
   override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
     return null
   }

package/app.plugin.js

@@ -6,19 +6,21 @@ const {
 } = require("@expo/config-plugins");
 
 const withNitroStorage = (config, props = {}) => {
-  const {
-    faceIDPermission = "Allow $(PRODUCT_NAME) to use Face ID for secure authentication",
-  } = props;
+  const defaultFaceIDPermission =
+    "Allow $(PRODUCT_NAME) to use Face ID for secure authentication";
+  const { faceIDPermission, addBiometricPermissions = false } = props;
 
   config = withInfoPlist(config, (config) => {
-    config.modResults.NSFaceIDUsageDescription =
-      faceIDPermission || config.modResults.NSFaceIDUsageDescription;
+    if (typeof faceIDPermission === "string" && faceIDPermission.trim() !== "") {
+      config.modResults.NSFaceIDUsageDescription = faceIDPermission;
+    } else if (!config.modResults.NSFaceIDUsageDescription) {
+      config.modResults.NSFaceIDUsageDescription = defaultFaceIDPermission;
+    }
     return config;
   });
 
   config = withAndroidManifest(config, (config) => {
-    const mainApplication = config.modResults.manifest.application?.[0];
-    if (!mainApplication) {
+    if (!addBiometricPermissions) {
       return config;
     }