react-native-mmkv 2.10.2 → 2.12.0

package/android/src/main/cpp/MmkvHostObject.cpp

@@ -13,12 +13,16 @@
 #include <string>
 #include <vector>
 
-MmkvHostObject::MmkvHostObject(const std::string& instanceId, std::string path, std::string cryptKey) {
-  __android_log_print(ANDROID_LOG_INFO, "RNMMKV", "Creating MMKV instance \"%s\"... (Path: %s, Encryption-Key: %s)",
-                      instanceId.c_str(), path.c_str(), cryptKey.c_str());
+MmkvHostObject::MmkvHostObject(const std::string& instanceId, std::string path,
+                               std::string cryptKey) {
+  bool hasEncryptionKey = cryptKey.size() > 0;
+  __android_log_print(ANDROID_LOG_INFO, "RNMMKV",
+                      "Creating MMKV instance \"%s\"... (Path: %s, Encrypted: %b)",
+                      instanceId.c_str(), path.c_str(), hasEncryptionKey);
   std::string* pathPtr = path.size() > 0 ? &path : nullptr;
   std::string* cryptKeyPtr = cryptKey.size() > 0 ? &cryptKey : nullptr;
-  instance = MMKV::mmkvWithID(instanceId, mmkv::DEFAULT_MMAP_SIZE, MMKV_SINGLE_PROCESS, cryptKeyPtr, pathPtr);
+  instance = MMKV::mmkvWithID(instanceId, mmkv::DEFAULT_MMAP_SIZE, MMKV_SINGLE_PROCESS, cryptKeyPtr,
+                              pathPtr);
 
   if (instance == nullptr) {
     // Check if instanceId is invalid
@@ -28,7 +32,8 @@ MmkvHostObject::MmkvHostObject(const std::string& instanceId, std::string path,
 
     // Check if encryptionKey is invalid
     if (cryptKey.size() > 16) {
-      throw std::runtime_error("Failed to create MMKV instance! `encryptionKey` cannot be longer than 16 bytes!");
+      throw std::runtime_error(
+          "Failed to create MMKV instance! `encryptionKey` cannot be longer than 16 bytes!");
     }
 
     throw std::runtime_error("Failed to create MMKV instance!");
@@ -56,247 +61,229 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
 
   if (propName == "set") {
     // MMKV.set(key: string, value: string | number | bool | Uint8Array)
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forAscii(runtime, funcName),
-                                                 2,  // key, value
-                                                 [this](jsi::Runtime& runtime,
-                                                        const jsi::Value& thisValue,
-                                                        const jsi::Value* arguments,
-                                                        size_t count) -> jsi::Value {
-      if (!arguments[0].isString()) {
-        throw jsi::JSError(runtime, "MMKV::set: First argument ('key') has to be of type string!");
-      }
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName),
+        2, // key, value
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (!arguments[0].isString()) {
+            throw jsi::JSError(runtime,
+                               "MMKV::set: First argument ('key') has to be of type string!");
+          }
 
-      auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          auto keyName = arguments[0].getString(runtime).utf8(runtime);
 
-      if (arguments[1].isBool()) {
-        // bool
-        instance->set(arguments[1].getBool(), keyName);
-      } else if (arguments[1].isNumber()) {
-        // number
-        instance->set(arguments[1].getNumber(), keyName);
-      } else if (arguments[1].isString()) {
-        // string
-        auto stringValue = arguments[1].getString(runtime).utf8(runtime);
-        instance->set(stringValue, keyName);
-      } else if (arguments[1].isObject()) {
-        // object
-        auto object = arguments[1].asObject(runtime);
-        if (isTypedArray(runtime, object)) {
-          // Uint8Array
-          auto typedArray = getTypedArray(runtime, object);
-          auto bufferValue = typedArray.getBuffer(runtime);
-          mmkv::MMBuffer buffer(bufferValue.data(runtime),
-                                bufferValue.size(runtime),
-                                mmkv::MMBufferCopyFlag::MMBufferNoCopy);
-          instance->set(buffer, keyName);
-        } else {
-          // unknown object
-          throw jsi::JSError(runtime, "MMKV::set: 'value' argument is an object, but not of type Uint8Array!");
-        }
-      } else {
-        // unknown type
-        throw jsi::JSError(runtime, "MMKV::set: 'value' argument is not of type bool, number, string or buffer!");
-      }
+          if (arguments[1].isBool()) {
+            // bool
+            instance->set(arguments[1].getBool(), keyName);
+          } else if (arguments[1].isNumber()) {
+            // number
+            instance->set(arguments[1].getNumber(), keyName);
+          } else if (arguments[1].isString()) {
+            // string
+            auto stringValue = arguments[1].getString(runtime).utf8(runtime);
+            instance->set(stringValue, keyName);
+          } else if (arguments[1].isObject()) {
+            // object
+            auto object = arguments[1].asObject(runtime);
+            if (isTypedArray(runtime, object)) {
+              // Uint8Array
+              auto typedArray = getTypedArray(runtime, object);
+              auto bufferValue = typedArray.getBuffer(runtime);
+              mmkv::MMBuffer buffer(bufferValue.data(runtime), bufferValue.size(runtime),
+                                    mmkv::MMBufferCopyFlag::MMBufferNoCopy);
+              instance->set(buffer, keyName);
+            } else {
+              // unknown object
+              throw jsi::JSError(
+                  runtime, "MMKV::set: 'value' argument is an object, but not of type Uint8Array!");
+            }
+          } else {
+            // unknown type
+            throw jsi::JSError(
+                runtime,
+                "MMKV::set: 'value' argument is not of type bool, number, string or buffer!");
+          }
 
-      return jsi::Value::undefined();
-    });
+          return jsi::Value::undefined();
+        });
   }
 
   if (propName == "getBoolean") {
     // MMKV.getBoolean(key: string)
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forAscii(runtime, funcName),
-                                                 1,  // key
-                                                 [this](jsi::Runtime& runtime,
-                                                        const jsi::Value& thisValue,
-                                                        const jsi::Value* arguments,
-                                                        size_t count) -> jsi::Value {
-      if (!arguments[0].isString()) {
-        throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
-      }
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName),
+        1, // key
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (!arguments[0].isString()) {
+            throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
+          }
 
-      auto keyName = arguments[0].getString(runtime).utf8(runtime);
-      bool hasValue;
-      auto value = instance->getBool(keyName, false, &hasValue);
-      if (hasValue) {
-        return jsi::Value(value);
-      } else {
-        return jsi::Value::undefined();
-      }
-    });
+          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          bool hasValue;
+          auto value = instance->getBool(keyName, false, &hasValue);
+          if (hasValue) {
+            return jsi::Value(value);
+          } else {
+            return jsi::Value::undefined();
+          }
+        });
   }
 
   if (propName == "getString") {
     // MMKV.getString(key: string)
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forAscii(runtime, funcName),
-                                                 1,  // key
-                                                 [this](jsi::Runtime& runtime,
-                                                        const jsi::Value& thisValue,
-                                                        const jsi::Value* arguments,
-                                                        size_t count) -> jsi::Value {
-      if (!arguments[0].isString()) {
-        throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
-      }
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName),
+        1, // key
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (!arguments[0].isString()) {
+            throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
+          }
 
-      auto keyName = arguments[0].getString(runtime).utf8(runtime);
-      std::string result;
-      bool hasValue = instance->getString(keyName, result);
-      if (hasValue) {
-        return jsi::Value(runtime, jsi::String::createFromUtf8(runtime, result));
-      } else {
-        return jsi::Value::undefined();
-      }
-    });
+          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          std::string result;
+          bool hasValue = instance->getString(keyName, result);
+          if (hasValue) {
+            return jsi::Value(runtime, jsi::String::createFromUtf8(runtime, result));
+          } else {
+            return jsi::Value::undefined();
+          }
+        });
   }
 
   if (propName == "getNumber") {
     // MMKV.getNumber(key: string)
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forAscii(runtime, funcName),
-                                                 1,  // key
-                                                 [this](jsi::Runtime& runtime,
-                                                        const jsi::Value& thisValue,
-                                                        const jsi::Value* arguments,
-                                                        size_t count) -> jsi::Value {
-      if (!arguments[0].isString()) {
-        throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
-      }
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName),
+        1, // key
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (!arguments[0].isString()) {
+            throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
+          }
 
-      auto keyName = arguments[0].getString(runtime).utf8(runtime);
-      bool hasValue;
-      auto value = instance->getDouble(keyName, 0.0, &hasValue);
-      if (hasValue) {
-        return jsi::Value(value);
-      } else {
-        return jsi::Value::undefined();
-      }
-    });
+          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          bool hasValue;
+          auto value = instance->getDouble(keyName, 0.0, &hasValue);
+          if (hasValue) {
+            return jsi::Value(value);
+          } else {
+            return jsi::Value::undefined();
+          }
+        });
   }
 
+  if (propName == "getBuffer") {
+    // MMKV.getBuffer(key: string)
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName),
+        1, // key
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (!arguments[0].isString()) {
+            throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
+          }
 
-    if (propName == "getBuffer") {
-        // MMKV.getBuffer(key: string)
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, funcName),
-                                                     1,  // key
-                                                     [this](jsi::Runtime& runtime,
-                                                            const jsi::Value& thisValue,
-                                                            const jsi::Value* arguments,
-                                                            size_t count) -> jsi::Value {
-        if (!arguments[0].isString()) {
-          throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
-        }
-
-        auto keyName = arguments[0].getString(runtime).utf8(runtime);
-        mmkv::MMBuffer buffer;
-        bool hasValue = instance->getBytes(keyName, buffer);
-        if (hasValue) {
-          auto length = buffer.length();
-          TypedArray<TypedArrayKind::Uint8Array> array(runtime, length);
-          auto data = static_cast<const unsigned char*>(buffer.getPtr());
-          std::vector<unsigned char> vector(length);
-          vector.assign(data, data + length);
-          array.update(runtime, vector);
-          return array;
-        } else {
-          return jsi::Value::undefined();
-        }
-      });
-    }
+          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          mmkv::MMBuffer buffer;
+          bool hasValue = instance->getBytes(keyName, buffer);
+          if (hasValue) {
+            auto length = buffer.length();
+            TypedArray<TypedArrayKind::Uint8Array> array(runtime, length);
+            auto data = static_cast<const unsigned char*>(buffer.getPtr());
+            std::vector<unsigned char> vector(length);
+            vector.assign(data, data + length);
+            array.update(runtime, vector);
+            return array;
+          } else {
+            return jsi::Value::undefined();
+          }
+        });
+  }
 
   if (propName == "contains") {
     // MMKV.contains(key: string)
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forAscii(runtime, funcName),
-                                                 1,  // key
-                                                 [this](jsi::Runtime& runtime,
-                                                        const jsi::Value& thisValue,
-                                                        const jsi::Value* arguments,
-                                                        size_t count) -> jsi::Value {
-      if (!arguments[0].isString()) {
-        throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
-      }
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName),
+        1, // key
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (!arguments[0].isString()) {
+            throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
+          }
 
-      auto keyName = arguments[0].getString(runtime).utf8(runtime);
-      bool containsKey = instance->containsKey(keyName);
-      return jsi::Value(containsKey);
-    });
+          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          bool containsKey = instance->containsKey(keyName);
+          return jsi::Value(containsKey);
+        });
   }
 
   if (propName == "delete") {
     // MMKV.delete(key: string)
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forAscii(runtime, funcName),
-                                                 1,  // key
-                                                 [this](jsi::Runtime& runtime,
-                                                        const jsi::Value& thisValue,
-                                                        const jsi::Value* arguments,
-                                                        size_t count) -> jsi::Value {
-      if (!arguments[0].isString()) {
-        throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
-      }
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName),
+        1, // key
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (!arguments[0].isString()) {
+            throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
+          }
 
-      auto keyName = arguments[0].getString(runtime).utf8(runtime);
-      instance->removeValueForKey(keyName);
-      return jsi::Value::undefined();
-    });
+          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          instance->removeValueForKey(keyName);
+          return jsi::Value::undefined();
+        });
   }
 
   if (propName == "getAllKeys") {
     // MMKV.getAllKeys()
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forAscii(runtime, funcName),
-                                                 0,
-                                                 [this](jsi::Runtime& runtime,
-                                                        const jsi::Value& thisValue,
-                                                        const jsi::Value* arguments,
-                                                        size_t count) -> jsi::Value {
-      auto keys = instance->allKeys();
-      auto array = jsi::Array(runtime, keys.size());
-      for (int i = 0; i < keys.size(); i++) {
-        array.setValueAtIndex(runtime, i, keys[i]);
-      }
-      return array;
-    });
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName), 0,
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          auto keys = instance->allKeys();
+          auto array = jsi::Array(runtime, keys.size());
+          for (int i = 0; i < keys.size(); i++) {
+            array.setValueAtIndex(runtime, i, keys[i]);
+          }
+          return array;
+        });
   }
 
   if (propName == "clearAll") {
     // MMKV.clearAll()
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forAscii(runtime, funcName),
-                                                 0,
-                                                 [this](jsi::Runtime& runtime,
-                                                        const jsi::Value& thisValue,
-                                                        const jsi::Value* arguments,
-                                                        size_t count) -> jsi::Value {
-      instance->clearAll();
-      return jsi::Value::undefined();
-    });
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName), 0,
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          instance->clearAll();
+          return jsi::Value::undefined();
+        });
   }
 
   if (propName == "recrypt") {
     // MMKV.recrypt(encryptionKey)
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forAscii(runtime, funcName),
-                                                 1, // encryptionKey
-                                                 [this](jsi::Runtime& runtime,
-                                                        const jsi::Value& thisValue,
-                                                        const jsi::Value* arguments,
-                                                        size_t count) -> jsi::Value {
-      if (arguments[0].isUndefined()) {
-        // reset encryption key to "no encryption"
-        instance->reKey(std::string());
-      } else if (arguments[0].isString()) {
-        // reKey(..) with new encryption-key
-        auto encryptionKey = arguments[0].getString(runtime).utf8(runtime);
-        instance->reKey(encryptionKey);
-      } else {
-        throw jsi::JSError(runtime, "First argument ('encryptionKey') has to be of type string (or undefined)!");
-      }
-      return jsi::Value::undefined();
-    });
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName),
+        1, // encryptionKey
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (arguments[0].isUndefined()) {
+            // reset encryption key to "no encryption"
+            instance->reKey(std::string());
+          } else if (arguments[0].isString()) {
+            // reKey(..) with new encryption-key
+            auto encryptionKey = arguments[0].getString(runtime).utf8(runtime);
+            instance->reKey(encryptionKey);
+          } else {
+            throw jsi::JSError(
+                runtime,
+                "First argument ('encryptionKey') has to be of type string (or undefined)!");
+          }
+          return jsi::Value::undefined();
+        });
   }
 
   return jsi::Value::undefined();

package/android/src/main/cpp/MmkvHostObject.h

@@ -8,12 +8,12 @@
 
 #pragma once
 
-#include <jsi/jsi.h>
 #include <MMKV.h>
+#include <jsi/jsi.h>
 
 using namespace facebook;
 
-class JSI_EXPORT MmkvHostObject: public jsi::HostObject {
+class JSI_EXPORT MmkvHostObject : public jsi::HostObject {
 public:
   MmkvHostObject(const std::string& instanceId, std::string path, std::string cryptKey);
 

package/android/src/main/cpp/cpp-adapter.cpp

@@ -1,70 +1,83 @@
-#include <jni.h>
-#include <jsi/jsi.h>
-#include <MMKV.h>
 #include "MmkvHostObject.h"
 #include "TypedArray.h"
+#include <MMKV.h>
+#include <jni.h>
+#include <jsi/jsi.h>
 
 using namespace facebook;
 
-std::string getPropertyAsStringOrEmptyFromObject(jsi::Object& object, const std::string& propertyName, jsi::Runtime& runtime) {
-    jsi::Value value = object.getProperty(runtime, propertyName.c_str());
-    return value.isString() ? value.asString(runtime).utf8(runtime) : "";
+std::string getPropertyAsStringOrEmptyFromObject(jsi::Object& object,
+                                                 const std::string& propertyName,
+                                                 jsi::Runtime& runtime) {
+  jsi::Value value = object.getProperty(runtime, propertyName.c_str());
+  return value.isString() ? value.asString(runtime).utf8(runtime) : "";
 }
 
 void install(jsi::Runtime& jsiRuntime) {
-    // MMKV.createNewInstance()
-    auto mmkvCreateNewInstance = jsi::Function::createFromHostFunction(jsiRuntime,
-                                                                       jsi::PropNameID::forAscii(jsiRuntime, "mmkvCreateNewInstance"),
-                                                                       1,
-                                                                       [](jsi::Runtime& runtime,
-                                                                          const jsi::Value& thisValue,
-                                                                          const jsi::Value* arguments,
-                                                                          size_t count) -> jsi::Value {
-                                                                         if (count != 1) {
-                                                                             throw jsi::JSError(runtime, "MMKV.createNewInstance(..) expects one argument (object)!");
-                                                                         }
-                                                                         jsi::Object config = arguments[0].asObject(runtime);
+  // MMKV.createNewInstance()
+  auto mmkvCreateNewInstance = jsi::Function::createFromHostFunction(
+      jsiRuntime, jsi::PropNameID::forAscii(jsiRuntime, "mmkvCreateNewInstance"), 1,
+      [](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+         size_t count) -> jsi::Value {
+        if (count != 1) {
+          throw jsi::JSError(runtime, "MMKV.createNewInstance(..) expects one argument (object)!");
+        }
+        jsi::Object config = arguments[0].asObject(runtime);
 
-                                                                         std::string instanceId = getPropertyAsStringOrEmptyFromObject(config, "id", runtime);
-                                                                         std::string path = getPropertyAsStringOrEmptyFromObject(config, "path", runtime);
-                                                                         std::string encryptionKey = getPropertyAsStringOrEmptyFromObject(config, "encryptionKey", runtime);
+        std::string instanceId = getPropertyAsStringOrEmptyFromObject(config, "id", runtime);
+        std::string path = getPropertyAsStringOrEmptyFromObject(config, "path", runtime);
+        std::string encryptionKey =
+            getPropertyAsStringOrEmptyFromObject(config, "encryptionKey", runtime);
 
-                                                                         auto instance = std::make_shared<MmkvHostObject>(instanceId, path, encryptionKey);
-                                                                         return jsi::Object::createFromHostObject(runtime, instance);
-                                                                       });
-    jsiRuntime.global().setProperty(jsiRuntime, "mmkvCreateNewInstance", std::move(mmkvCreateNewInstance));
+        auto instance = std::make_shared<MmkvHostObject>(instanceId, path, encryptionKey);
+        return jsi::Object::createFromHostObject(runtime, instance);
+      });
+  jsiRuntime.global().setProperty(jsiRuntime, "mmkvCreateNewInstance",
+                                  std::move(mmkvCreateNewInstance));
 
-    // Adds the PropNameIDCache object to the Runtime. If the Runtime gets destroyed, the Object gets destroyed and the cache gets invalidated.
-    auto propNameIdCache = std::make_shared<InvalidateCacheOnDestroy>(jsiRuntime);
-    jsiRuntime.global().setProperty(jsiRuntime, "mmkvArrayBufferPropNameIdCache", jsi::Object::createFromHostObject(jsiRuntime, propNameIdCache));
+  // Adds the PropNameIDCache object to the Runtime. If the Runtime gets destroyed, the Object gets
+  // destroyed and the cache gets invalidated.
+  auto propNameIdCache = std::make_shared<InvalidateCacheOnDestroy>(jsiRuntime);
+  jsiRuntime.global().setProperty(jsiRuntime, "mmkvArrayBufferPropNameIdCache",
+                                  jsi::Object::createFromHostObject(jsiRuntime, propNameIdCache));
 }
 
-std::string jstringToStdString(JNIEnv *env, jstring jStr) {
-    if (!jStr) return "";
+std::string jstringToStdString(JNIEnv* env, jstring jStr) {
+  if (!jStr)
+    return "";
 
-    const auto stringClass = env->GetObjectClass(jStr);
-    const auto getBytes = env->GetMethodID(stringClass, "getBytes", "(Ljava/lang/String;)[B");
-    const auto stringJbytes = (jbyteArray) env->CallObjectMethod(jStr, getBytes, env->NewStringUTF("UTF-8"));
+  const auto stringClass = env->GetObjectClass(jStr);
+  const auto getBytes = env->GetMethodID(stringClass, "getBytes", "(Ljava/lang/String;)[B");
+  const auto stringJbytes =
+      (jbyteArray)env->CallObjectMethod(jStr, getBytes, env->NewStringUTF("UTF-8"));
 
-    auto length = (size_t) env->GetArrayLength(stringJbytes);
-    auto pBytes = env->GetByteArrayElements(stringJbytes, nullptr);
+  auto length = (size_t)env->GetArrayLength(stringJbytes);
+  auto pBytes = env->GetByteArrayElements(stringJbytes, nullptr);
 
-    std::string ret = std::string((char *)pBytes, length);
-    env->ReleaseByteArrayElements(stringJbytes, pBytes, JNI_ABORT);
+  std::string ret = std::string((char*)pBytes, length);
+  env->ReleaseByteArrayElements(stringJbytes, pBytes, JNI_ABORT);
 
-    env->DeleteLocalRef(stringJbytes);
-    env->DeleteLocalRef(stringClass);
-    return ret;
+  env->DeleteLocalRef(stringJbytes);
+  env->DeleteLocalRef(stringClass);
+  return ret;
 }
 
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_reactnativemmkv_MmkvModule_nativeInstall(JNIEnv *env, jobject clazz, jlong jsiPtr, jstring path) {
-    MMKV::initializeMMKV(jstringToStdString(env, path));
+extern "C" JNIEXPORT void JNICALL Java_com_reactnativemmkv_MmkvModule_nativeInstall(JNIEnv* env,
+                                                                                    jobject clazz,
+                                                                                    jlong jsiPtr,
+                                                                                    jstring path) {
+#if DEBUG
+  MMKVLogLevel logLevel = MMKVLogDebug;
+#else
+  MMKVLogLevel logLevel = MMKVLogError;
+#endif
+  std::string storageDirectory = jstringToStdString(env, path);
+  MMKV::initializeMMKV(storageDirectory, logLevel);
 
-    auto runtime = reinterpret_cast<jsi::Runtime*>(jsiPtr);
-    if (runtime) {
-        install(*runtime);
-    }
-    // if runtime was nullptr, MMKV will not be installed. This should only happen while Remote Debugging (Chrome), but will be weird either way.
+  auto runtime = reinterpret_cast<jsi::Runtime*>(jsiPtr);
+  if (runtime) {
+    install(*runtime);
+  }
+  // if runtime was nullptr, MMKV will not be installed. This should only happen while Remote
+  // Debugging (Chrome), but will be weird either way.
 }