react-native-mmkv 2.12.1 → 3.0.0-beta.1

package/android/src/main/AndroidManifest.xml

@@ -1,3 +1,3 @@
-<manifest package="com.reactnativemmkv" xmlns:android="http://schemas.android.com/apk/res/android">
-
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.mrousavy.mmkv">
 </manifest>

package/android/src/{hasNamespace/AndroidManifest.xml → main/AndroidManifestNew.xml}

@@ -1,3 +1,2 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
-
 </manifest>

package/android/src/main/cpp/AndroidLogger.cpp

@@ -0,0 +1,16 @@
+//
+//  AndroidLogger.cpp
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 05.03.24.
+//
+
+#include "Logger.h"
+#include <android/log.h>
+
+void Logger::log(const std::string& tag, const std::string& message) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wformat-security"
+  __android_log_print(ANDROID_LOG_INFO, tag.c_str(), message.c_str());
+#pragma clang diagnostic pop
+}

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

@@ -1,83 +1,7 @@
-#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) : "";
-}
-
-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);
-
-        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));
-
-  // 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 "";
-
-  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);
-
-  std::string ret = std::string((char*)pBytes, length);
-  env->ReleaseByteArrayElements(stringJbytes, pBytes, JNI_ABORT);
-
-  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) {
-#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.
+extern "C" JNIEXPORT jdouble JNICALL Java_com_mmkv_MmkvModule_nativeMultiply(JNIEnv* env,
+                                                                             jclass type, jdouble a,
+                                                                             jdouble b) {
+  return 5.0;
 }

package/android/src/main/java/com/mrousavy/mmkv/MmkvPackage.java

@@ -0,0 +1,44 @@
+package com.mrousavy.mmkv;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+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 com.facebook.react.TurboReactPackage;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class MmkvPackage extends TurboReactPackage {
+  @Nullable
+  @Override
+  public NativeModule getModule(String name, @NonNull ReactApplicationContext reactContext) {
+    if (name.equals(MmkvPlatformContextModule.NAME)) {
+      return new MmkvPlatformContextModule(reactContext);
+    } else {
+      return null;
+    }
+  }
+
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return () -> {
+      final Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
+      moduleInfos.put(
+              MmkvPlatformContextModule.NAME,
+              new ReactModuleInfo(
+                      MmkvPlatformContextModule.NAME,
+                      MmkvPlatformContextModule.NAME,
+                      false, // canOverrideExistingModule
+                      false, // needsEagerInit
+                      true, // hasConstants
+                      false, // isCxxModule
+                      true // isTurboModule
+              ));
+      return moduleInfos;
+    };
+  }
+}

package/android/src/main/java/com/mrousavy/mmkv/MmkvPlatformContextModule.java

@@ -0,0 +1,17 @@
+package com.mrousavy.mmkv;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+
+public class MmkvPlatformContextModule extends NativeMmkvPlatformContextSpec {
+    private final ReactApplicationContext context;
+
+    public MmkvPlatformContextModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        context = reactContext;
+    }
+
+    @Override
+    public String getBaseDirectory() {
+        return context.getFilesDir().getAbsolutePath() + "/mmkv";
+    }
+}

package/cpp/Logger.h

@@ -0,0 +1,35 @@
+//
+//  Logger.h
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 25.03.24.
+//
+
+#include <string>
+
+class Logger {
+private:
+  Logger() = delete;
+
+private:
+  template <typename... Args>
+  static std::string string_format(const std::string& format, Args... args) {
+    int size_s = std::snprintf(nullptr, 0, format.c_str(), args...) + 1; // Extra space for '\0'
+    if (size_s <= 0) {
+      throw std::runtime_error("Failed to format string!");
+    }
+    auto size = static_cast<size_t>(size_s);
+    std::unique_ptr<char[]> buf(new char[size]);
+    std::snprintf(buf.get(), size, format.c_str(), args...);
+    return std::string(buf.get(), buf.get() + size - 1); // We don't want the '\0' inside
+  }
+
+public:
+  static void log(const std::string& tag, const std::string& message);
+
+  template <typename... Args>
+  inline static void log(const std::string& tag, const std::string& formatString, Args&&... args) {
+    std::string formattedString = string_format(formatString, std::forward<Args>(args)...);
+    log(tag, formattedString);
+  }
+};

package/cpp/MMKVManagedBuffer.h

@@ -0,0 +1,37 @@
+//
+//  ManagedBuffer.h
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 25.03.24.
+//
+
+#pragma once
+
+#include <jsi/jsi.h>
+
+#if __has_include("MMKVManagedBuffer.h")
+#include "MMKVManagedBuffer.h"
+#else
+#include <MMKVCore/MMKVManagedBuffer.h>
+#endif
+
+using namespace facebook;
+
+/**
+ A jsi::MutableBuffer that manages mmkv::MMBuffer memory (by ownership).
+ */
+class MMKVManagedBuffer : public jsi::MutableBuffer {
+public:
+  explicit MMKVManagedBuffer(mmkv::MMBuffer&& buffer) : _buffer(std::move(buffer)) {}
+
+  uint8_t* data() override {
+    return static_cast<uint8_t*>(_buffer.getPtr());
+  }
+
+  size_t size() const override {
+    return _buffer.length();
+  }
+
+private:
+  mmkv::MMBuffer _buffer;
+};

package/{android/src/main/cpp → cpp}/MmkvHostObject.cpp

@@ -7,31 +7,39 @@
 //
 
 #include "MmkvHostObject.h"
-#include "TypedArray.h"
+#include "Logger.h"
+#include "MMKVManagedBuffer.h"
 #include <MMKV.h>
-#include <android/log.h>
 #include <string>
 #include <vector>
 
-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);
+using namespace mmkv;
+
+MmkvHostObject::MmkvHostObject(const facebook::react::MMKVConfig& config) {
+  std::string path = config.path.has_value() ? config.path.value() : "";
+  std::string encryptionKey = config.encryptionKey.has_value() ? config.encryptionKey.value() : "";
+  bool hasEncryptionKey = encryptionKey.size() > 0;
+  Logger::log("RNMMKV", "Creating MMKV instance \"%s\"... (Path: %s, Encrypted: %s)",
+              config.id.c_str(), path.c_str(), hasEncryptionKey ? "true" : "false");
+
   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);
+  std::string* encryptionKeyPtr = encryptionKey.size() > 0 ? &encryptionKey : nullptr;
+  MMKVMode mode = getMMKVMode(config);
+
+#ifdef __APPLE__
+  instance = MMKV::mmkvWithID(config.id, mode, encryptionKeyPtr, pathPtr);
+#else
+  instance = MMKV::mmkvWithID(config.id, DEFAULT_MMAP_SIZE, mode, encryptionKeyPtr, pathPtr);
+#endif
 
   if (instance == nullptr) {
     // Check if instanceId is invalid
-    if (instanceId.empty()) {
+    if (config.id.empty()) {
       throw std::runtime_error("Failed to create MMKV instance! `id` cannot be empty!");
     }
 
     // Check if encryptionKey is invalid
-    if (cryptKey.size() > 16) {
+    if (encryptionKey.size() > 16) {
       throw std::runtime_error(
           "Failed to create MMKV instance! `encryptionKey` cannot be longer than 16 bytes!");
     }
@@ -40,8 +48,18 @@ MmkvHostObject::MmkvHostObject(const std::string& instanceId, std::string path,
   }
 }
 
+MmkvHostObject::~MmkvHostObject() {
+  if (instance != nullptr) {
+    std::string instanceId = instance->mmapID();
+    Logger::log("RNMMKV", "Destroying MMKV instance \"%s\"...", instanceId.c_str());
+    instance->clearMemoryCache();
+  }
+  instance = nullptr;
+}
+
 std::vector<jsi::PropNameID> MmkvHostObject::getPropertyNames(jsi::Runtime& rt) {
   std::vector<jsi::PropNameID> result;
+  result.reserve(12);
   result.push_back(jsi::PropNameID::forUtf8(rt, std::string("set")));
   result.push_back(jsi::PropNameID::forUtf8(rt, std::string("getBoolean")));
   result.push_back(jsi::PropNameID::forUtf8(rt, std::string("getBuffer")));
@@ -52,26 +70,44 @@ std::vector<jsi::PropNameID> MmkvHostObject::getPropertyNames(jsi::Runtime& rt)
   result.push_back(jsi::PropNameID::forUtf8(rt, std::string("getAllKeys")));
   result.push_back(jsi::PropNameID::forUtf8(rt, std::string("deleteAll")));
   result.push_back(jsi::PropNameID::forUtf8(rt, std::string("recrypt")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("trim")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("size")));
   return result;
 }
 
+MMKVMode MmkvHostObject::getMMKVMode(const facebook::react::MMKVConfig& config) {
+  if (!config.mode.has_value()) {
+    return MMKVMode::MMKV_SINGLE_PROCESS;
+  }
+  auto mode = config.mode.value();
+  switch (mode) {
+    case facebook::react::MmkvCxxMode::SINGLE_PROCESS:
+      return MMKVMode::MMKV_SINGLE_PROCESS;
+    case facebook::react::MmkvCxxMode::MULTI_PROCESS:
+      return MMKVMode::MMKV_MULTI_PROCESS;
+    default:
+      throw std::runtime_error("Invalid MMKV Mode value!");
+  }
+}
+
 jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& propNameId) {
   auto propName = propNameId.utf8(runtime);
   auto funcName = "MMKV." + propName;
 
   if (propName == "set") {
-    // MMKV.set(key: string, value: string | number | bool | Uint8Array)
+    // MMKV.set(key: string, value: string | number | bool | ArrayBuffer)
     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()) {
+          if (count != 2 || !arguments[0].isString()) {
+            [[unlikely]];
             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].asString(runtime).utf8(runtime);
 
           if (arguments[1].isBool()) {
             // bool
@@ -81,22 +117,21 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
             instance->set(arguments[1].getNumber(), keyName);
           } else if (arguments[1].isString()) {
             // string
-            auto stringValue = arguments[1].getString(runtime).utf8(runtime);
+            auto stringValue = arguments[1].asString(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);
+            if (object.isArrayBuffer(runtime)) {
+              // ArrayBuffer
+              auto arrayBuffer = object.getArrayBuffer(runtime);
+              MMBuffer data(arrayBuffer.data(runtime), arrayBuffer.size(runtime), MMBufferNoCopy);
+              instance->set(data, keyName);
             } else {
               // unknown object
               throw jsi::JSError(
-                  runtime, "MMKV::set: 'value' argument is an object, but not of type Uint8Array!");
+                  runtime,
+                  "MMKV::set: 'value' argument is an object, but not of type ArrayBuffer!");
             }
           } else {
             // unknown type
@@ -116,62 +151,65 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
         1, // key
         [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
                size_t count) -> jsi::Value {
-          if (!arguments[0].isString()) {
+          if (count != 1 || !arguments[0].isString()) {
+            [[unlikely]];
             throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
           }
 
-          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          auto keyName = arguments[0].asString(runtime).utf8(runtime);
           bool hasValue;
           auto value = instance->getBool(keyName, false, &hasValue);
-          if (hasValue) {
-            return jsi::Value(value);
-          } else {
+          if (!hasValue) {
+            [[unlikely]];
             return jsi::Value::undefined();
           }
+          return jsi::Value(value);
         });
   }
 
-  if (propName == "getString") {
-    // MMKV.getString(key: string)
+  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()) {
+          if (count != 1 || !arguments[0].isString()) {
+            [[unlikely]];
             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 {
+          auto keyName = arguments[0].asString(runtime).utf8(runtime);
+          bool hasValue;
+          auto value = instance->getDouble(keyName, 0.0, &hasValue);
+          if (!hasValue) {
+            [[unlikely]];
             return jsi::Value::undefined();
           }
+          return jsi::Value(value);
         });
   }
 
-  if (propName == "getNumber") {
-    // MMKV.getNumber(key: string)
+  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()) {
+          if (count != 1 || !arguments[0].isString()) {
+            [[unlikely]];
             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 {
+          auto keyName = arguments[0].asString(runtime).utf8(runtime);
+          std::string result;
+          bool hasValue = instance->getString(keyName, result);
+          if (!hasValue) {
+            [[unlikely]];
             return jsi::Value::undefined();
           }
+          return jsi::Value(runtime, jsi::String::createFromUtf8(runtime, result));
         });
   }
 
@@ -182,24 +220,20 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
         1, // key
         [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
                size_t count) -> jsi::Value {
-          if (!arguments[0].isString()) {
+          if (count != 1 || !arguments[0].isString()) {
+            [[unlikely]];
             throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
           }
 
-          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          auto keyName = arguments[0].asString(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 {
+          if (!hasValue) {
+            [[unlikely]];
             return jsi::Value::undefined();
           }
+          auto mutableData = std::make_shared<MMKVManagedBuffer>(std::move(buffer));
+          return jsi::ArrayBuffer(runtime, mutableData);
         });
   }
 
@@ -210,11 +244,12 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
         1, // key
         [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
                size_t count) -> jsi::Value {
-          if (!arguments[0].isString()) {
+          if (count != 1 || !arguments[0].isString()) {
+            [[unlikely]];
             throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
           }
 
-          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          auto keyName = arguments[0].asString(runtime).utf8(runtime);
           bool containsKey = instance->containsKey(keyName);
           return jsi::Value(containsKey);
         });
@@ -227,11 +262,12 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
         1, // key
         [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
                size_t count) -> jsi::Value {
-          if (!arguments[0].isString()) {
+          if (count != 1 || !arguments[0].isString()) {
+            [[unlikely]];
             throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
           }
 
-          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          auto keyName = arguments[0].asString(runtime).utf8(runtime);
           instance->removeValueForKey(keyName);
           return jsi::Value::undefined();
         });
@@ -270,6 +306,12 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
         1, // encryptionKey
         [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
                size_t count) -> jsi::Value {
+          if (count != 1) {
+            [[unlikely]];
+            throw jsi::JSError(runtime, "Expected 1 argument (encryptionKey), but received " +
+                                            std::to_string(count) + "!");
+          }
+
           if (arguments[0].isUndefined()) {
             // reset encryption key to "no encryption"
             instance->reKey(std::string());
@@ -278,13 +320,34 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
             auto encryptionKey = arguments[0].getString(runtime).utf8(runtime);
             instance->reKey(encryptionKey);
           } else {
+            // Invalid argument (maybe object?)
             throw jsi::JSError(
                 runtime,
                 "First argument ('encryptionKey') has to be of type string (or undefined)!");
           }
+
           return jsi::Value::undefined();
         });
   }
 
+  if (propName == "trim") {
+    // MMKV.trim()
+    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->clearMemoryCache();
+          instance->trim();
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propName == "size") {
+    // MMKV.size
+    size_t size = instance->actualSize();
+    return jsi::Value(static_cast<int>(size));
+  }
+
   return jsi::Value::undefined();
 }

package/{android/src/main/cpp → cpp}/MmkvHostObject.h

@@ -8,19 +8,30 @@
 
 #pragma once
 
-#include <MMKV.h>
+#include "NativeMmkvModule.h"
 #include <jsi/jsi.h>
 
+#if __has_include("MMKV.h")
+#include "MMKV.h"
+#else
+#include <MMKVCore/MMKV.h>
+#endif
+
 using namespace facebook;
+using namespace mmkv;
 
-class JSI_EXPORT MmkvHostObject : public jsi::HostObject {
+class MmkvHostObject : public jsi::HostObject {
 public:
-  MmkvHostObject(const std::string& instanceId, std::string path, std::string cryptKey);
+  MmkvHostObject(const facebook::react::MMKVConfig& config);
+  ~MmkvHostObject();
 
 public:
   jsi::Value get(jsi::Runtime&, const jsi::PropNameID& name) override;
   std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& rt) override;
 
+private:
+  static MMKVMode getMMKVMode(const facebook::react::MMKVConfig& config);
+
 private:
   MMKV* instance;
 };