react-native-mmkv 4.0.0-beta.1 → 4.0.0-beta.10

package/NitroMmkv.podspec

@@ -0,0 +1,44 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroMmkv"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported, :visionos => 1.0, :tvos => "12.0", :osx => "10.14" }
+  s.source       = { :git => "https://github.com/mrousavy/react-native-mmkv.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    # Implementation (Swift)
+    "ios/**/*.{swift}",
+    # Autolinking/Registration (Objective-C++)
+    "ios/**/*.{m,mm}",
+    # Implementation (C++ objects)
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  # Add MMKV Core dependency
+  s.compiler_flags = '-x objective-c++'
+  s.libraries    = 'z', 'c++'
+  s.dependency 'MMKVCore', '>= 2.2.3'
+
+  # TODO: Remove when no one uses RN 0.79 anymore
+  # Add support for React Native 0.79 or below
+  s.pod_target_xcconfig = {
+    "HEADER_SEARCH_PATHS" => ["${PODS_ROOT}/RCT-Folly"],
+    "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES",
+    "OTHER_CPLUSPLUSFLAGS" => "$(inherited) -DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1"
+  }
+
+  load 'nitrogen/generated/ios/NitroMmkv+autolinking.rb'
+  add_nitrogen_files(s)
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  install_modules_dependencies(s)
+end

package/README.md

@@ -1,5 +1,3 @@
 # react-native-mmkv
 
-The fastest key/value storage for React Native. ~30x faster than AsyncStorage!
-
-See [README.md](https://github.com/mrousavy/react-native-mmkv) for more information.
+See https://github.com/mrousavy/react-native-mmkv

package/android/CMakeLists.txt

@@ -1,41 +1,42 @@
+project(NitroMmkv)
 cmake_minimum_required(VERSION 3.9.0)
-project(ReactNativeMmkv)
-
-set(CMAKE_VERBOSE_MAKEFILE ON)
-set(CMAKE_CXX_STANDARD 20)
-
-# Check for supported ABIs only
-if(NOT (ANDROID_ABI STREQUAL "arm64-v8a" OR ANDROID_ABI STREQUAL "x86_64"))
-    message(FATAL_ERROR "MMKV prefab does not support ABI: ${ANDROID_ABI}. Supported ABIs: arm64-v8a, x86_64")
-endif()
-
-# Compile sources
-add_library(
-        react-native-mmkv
-        SHARED
-        src/main/cpp/AndroidLogger.cpp
-        ../cpp/MmkvHostObject.cpp
-        ../cpp/NativeMmkvModule.cpp
+
+set (PACKAGE_NAME NitroMmkv)
+set (CMAKE_VERBOSE_MAKEFILE ON)
+set (CMAKE_CXX_STANDARD 20)
+
+# Find all C++ files (shared and platform specifics)
+file(GLOB_RECURSE shared_files RELATIVE ${CMAKE_SOURCE_DIR}
+     "../cpp/**.cpp"
+)
+file(GLOB_RECURSE android_files RELATIVE ${CMAKE_SOURCE_DIR}
+     "src/main/cpp/**.cpp"
 )
 
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../cpp)
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED
+            ${shared_files}
+            ${android_files}
+)
 
-# Find MMKV prefab package
+# Find MMKV prefab package (from mmkv-shared gradle dependency)
 find_package(mmkv REQUIRED CONFIG)
 
-# Add android/log dependency
-find_library(android_log log)
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroMmkv+autolinking.cmake)
 
-target_include_directories(
-        react-native-mmkv
-        PUBLIC
-        ${CMAKE_CURRENT_SOURCE_DIR}/../cpp
+# Set up local includes
+include_directories(
+        "src/main/cpp"
+        "../cpp"
 )
 
+find_library(LOG_LIB log)
+
+# Link all libraries together
 target_link_libraries(
-        react-native-mmkv
-        mmkv::mmkv                  # <-- MMKV core (now manually configured)
-        ${android_log}              # <-- Logcat logger
-        android                     # <-- Android JNI core
-        react_codegen_RNMmkvSpec    # <-- Generated Specs from CodeGen
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        mmkv::mmkv                  # <-- MMKV core
+        android                     # <-- Android core
 )

package/android/build.gradle

@@ -5,33 +5,38 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:8.12.1"
+    classpath "com.android.tools.build:gradle:8.13.0"
   }
 }
 
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["x86_64", "arm64-v8a"]
+}
+
 def isNewArchitectureEnabled() {
   return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
 }
 
 apply plugin: "com.android.library"
+apply plugin: 'org.jetbrains.kotlin.android'
+apply from: '../nitrogen/generated/android/NitroMmkv+autolinking.gradle'
+apply from: "./fix-prefab.gradle"
 
 if (isNewArchitectureEnabled()) {
   apply plugin: "com.facebook.react"
 }
 
 def getExtOrDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["Mmkv_" + name]
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["NitroMmkv_" + name]
 }
 
 def getExtOrIntegerDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Mmkv_" + name]).toInteger()
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroMmkv_" + name]).toInteger()
 }
 
-logger.warn("[react-native-mmkv] Thank you for using react-native-mmkv ❤️")
-logger.warn("[react-native-mmkv] If you enjoy using react-native-mmkv, please consider sponsoring this project: https://github.com/sponsors/mrousavy")
-
 android {
-  namespace "com.mrousavy.mmkv"
+  namespace "com.margelo.nitro.mmkv"
 
   ndkVersion getExtOrDefault("ndkVersion")
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
@@ -40,6 +45,50 @@ android {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
   }
 
   buildFeatures {
@@ -65,18 +114,18 @@ android {
   sourceSets {
     main {
       if (isNewArchitectureEnabled()) {
-          java.srcDirs += [
-            // This is needed to build Kotlin project with NewArch enabled
-            "${project.buildDir}/generated/source/codegen/java"
-          ]
+        java.srcDirs += [
+          // React Codegen files
+          "${project.buildDir}/generated/source/codegen/java"
+        ]
       }
     }
   }
 }
 
 repositories {
-  google()
   mavenCentral()
+  google()
 }
 
 
@@ -86,14 +135,10 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
 
-  // Use the MMKV shared lib - includes C++ prefabs (shared STL for React Native compatibility)
+  // Add a dependency on NitroModules
+  implementation project(":react-native-nitro-modules")
+
+  // Add a dependency on mmkv core (this ships a C++ prefab)
   implementation "com.tencent:mmkv-shared:2.2.3"
 }
 
-if (isNewArchitectureEnabled()) {
-  react {
-    jsRootDir = file("../src/")
-    libraryName = "Mmkv"
-    codegenJavaPackageName = "com.mrousavy.mmkv"
-  }
-}

package/android/fix-prefab.gradle

@@ -0,0 +1,51 @@
+tasks.configureEach { task ->
+  // Make sure that we generate our prefab publication file only after having built the native library
+  // so that not a header publication file, but a full configuration publication will be generated, which
+  // will include the .so file
+
+  def prefabConfigurePattern = ~/^prefab(.+)ConfigurePackage$/
+  def matcher = task.name =~ prefabConfigurePattern
+  if (matcher.matches()) {
+    def variantName = matcher[0][1]
+    task.outputs.upToDateWhen { false }
+    task.dependsOn("externalNativeBuild${variantName}")
+  }
+}
+
+afterEvaluate {
+  def abis = reactNativeArchitectures()
+  rootProject.allprojects.each { proj ->
+    if (proj === rootProject) return
+
+    def dependsOnThisLib = proj.configurations.findAll { it.canBeResolved }.any { config ->
+      config.dependencies.any { dep ->
+        dep.group == project.group && dep.name == project.name
+      }
+    }
+    if (!dependsOnThisLib && proj != project) return
+
+    if (!proj.plugins.hasPlugin('com.android.application') && !proj.plugins.hasPlugin('com.android.library')) {
+      return
+    }
+
+    def variants = proj.android.hasProperty('applicationVariants') ? proj.android.applicationVariants : proj.android.libraryVariants
+    // Touch the prefab_config.json files to ensure that in ExternalNativeJsonGenerator.kt we will re-trigger the prefab CLI to
+    // generate a libnameConfig.cmake file that will contain our native library (.so).
+    // See this condition: https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:build-system/gradle-core/src/main/java/com/android/build/gradle/tasks/ExternalNativeJsonGenerator.kt;l=207-219?q=createPrefabBuildSystemGlue
+    variants.all { variant ->
+      def variantName = variant.name
+      abis.each { abi ->
+        def searchDir = new File(proj.projectDir, ".cxx/${variantName}")
+        if (!searchDir.exists()) return
+        def matches = []
+        searchDir.eachDir { randomDir ->
+          def prefabFile = new File(randomDir, "${abi}/prefab_config.json")
+          if (prefabFile.exists()) matches << prefabFile
+        }
+        matches.each { prefabConfig ->
+          prefabConfig.setLastModified(System.currentTimeMillis())
+        }
+      }
+    }
+  }
+}

package/android/gradle.properties

@@ -1,5 +1,5 @@
-Mmkv_kotlinVersion=1.9.24
-Mmkv_minSdkVersion=23
-Mmkv_targetSdkVersion=34
-Mmkv_compileSdkVersion=34
-Mmkv_ndkversion=26.1.10909125
+NitroMmkv_kotlinVersion=2.1.20
+NitroMmkv_minSdkVersion=23
+NitroMmkv_targetSdkVersion=36
+NitroMmkv_compileSdkVersion=36
+NitroMmkv_ndkVersion=27.1.12297006

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

@@ -0,0 +1,6 @@
+#include "NitroMmkvOnLoad.hpp"
+#include <jni.h>
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::mmkv::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/mmkv/HybridMMKVPlatformContext.kt

@@ -0,0 +1,19 @@
+package com.margelo.nitro.mmkv
+
+import androidx.annotation.Keep
+import com.facebook.common.internal.DoNotStrip
+import com.margelo.nitro.NitroModules
+
+@DoNotStrip
+@Keep
+class HybridMMKVPlatformContext: HybridMMKVPlatformContextSpec() {
+    override fun getBaseDirectory(): String {
+        val context = NitroModules.applicationContext ?: throw Error("Cannot get MMKV base directory - No Android Context available!")
+        return context.filesDir.absolutePath + "/mmkv";
+    }
+
+    override fun getAppGroupDirectory(): String? {
+        // AppGroups do not exist on Android. It's iOS only.
+        throw Error("getAppGroupDirectory() is not supported on Android! It's iOS only.")
+    }
+}

package/android/src/main/java/com/margelo/nitro/mmkv/NitroMmkvPackage.java

@@ -0,0 +1,33 @@
+package com.margelo.nitro.mmkv;
+
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.TurboReactPackage;
+import com.margelo.nitro.core.HybridObject;
+
+import java.util.HashMap;
+import java.util.function.Supplier;
+
+public class NitroMmkvPackage extends TurboReactPackage {
+  @Nullable
+  @Override
+  public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+    return null;
+  }
+
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return () -> {
+        return new HashMap<>();
+    };
+  }
+
+  static {
+    NitroMmkvOnLoad.initializeNative();
+  }
+}

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./lib/expo-plugin/withMMKV.cjs')

package/cpp/HybridMMKV.cpp

@@ -0,0 +1,184 @@
+//
+//  HybridMMKV.cpp
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 21.08.2025.
+//
+
+#include "HybridMMKV.hpp"
+#include "MMKVTypes.hpp"
+#include "MMKVValueChangedListenerRegistry.hpp"
+#include "ManagedMMBuffer.hpp"
+#include <NitroModules/NitroLogger.hpp>
+
+namespace margelo::nitro::mmkv {
+
+HybridMMKV::HybridMMKV(const Configuration& config) : HybridObject(TAG) {
+  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(LogLevel::Info, TAG, "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* encryptionKeyPtr = encryptionKey.size() > 0 ? &encryptionKey : nullptr;
+  MMKVMode mode = getMMKVMode(config);
+  if (config.readOnly.has_value() && config.readOnly.value()) {
+    Logger::log(LogLevel::Info, TAG, "Instance is read-only!");
+    mode = mode | ::mmkv::MMKV_READ_ONLY;
+  }
+
+#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) [[unlikely]] {
+    // Check if instanceId is invalid
+    if (config.id.empty()) [[unlikely]] {
+      throw std::runtime_error("Failed to create MMKV instance! `id` cannot be empty!");
+    }
+
+    // Check if encryptionKey is invalid
+    if (encryptionKey.size() > 16) [[unlikely]] {
+      throw std::runtime_error("Failed to create MMKV instance! `encryptionKey` cannot be longer "
+                               "than 16 bytes!");
+    }
+
+    // Check if path is maybe invalid
+    if (path.empty()) [[unlikely]] {
+      throw std::runtime_error("Failed to create MMKV instance! `path` cannot be empty!");
+    }
+
+    throw std::runtime_error("Failed to create MMKV instance!");
+  }
+}
+
+double HybridMMKV::getSize() {
+  return instance->actualSize();
+}
+bool HybridMMKV::getIsReadOnly() {
+  return instance->isReadOnly();
+}
+
+// helper: overload pattern matching for lambdas
+template <class... Ts>
+struct overloaded : Ts... {
+  using Ts::operator()...;
+};
+template <class... Ts>
+overloaded(Ts...) -> overloaded<Ts...>;
+
+void HybridMMKV::set(const std::string& key, const std::variant<std::string, double, bool, std::shared_ptr<ArrayBuffer>>& value) {
+  // Pattern-match each potential value in std::variant
+  std::visit(overloaded{[&](const std::string& string) { instance->set(string, key); }, [&](double number) { instance->set(number, key); },
+                        [&](bool b) { instance->set(b, key); },
+                        [&](const std::shared_ptr<ArrayBuffer>& buf) {
+                          MMBuffer buffer(buf->data(), buf->size(), MMBufferCopyFlag::MMBufferNoCopy);
+                          instance->set(std::move(buffer), key);
+                        }},
+             value);
+
+  // Notify on changed
+  MMKVValueChangedListenerRegistry::notifyOnValueChanged(instance->mmapID(), key);
+}
+std::optional<bool> HybridMMKV::getBoolean(const std::string& key) {
+  bool hasValue;
+  bool result = instance->getBool(key, /* defaultValue */ false, &hasValue);
+  if (hasValue) {
+    return result;
+  } else {
+    return std::nullopt;
+  }
+}
+std::optional<std::string> HybridMMKV::getString(const std::string& key) {
+  std::string result;
+  bool hasValue = instance->getString(key, result, /* inplaceModification */ true);
+  if (hasValue) {
+    return result;
+  } else {
+    return std::nullopt;
+  }
+}
+std::optional<double> HybridMMKV::getNumber(const std::string& key) {
+  bool hasValue;
+  double result = instance->getDouble(key, /* defaultValue */ 0.0, &hasValue);
+  if (hasValue) {
+    return result;
+  } else {
+    return std::nullopt;
+  }
+}
+std::optional<std::shared_ptr<ArrayBuffer>> HybridMMKV::getBuffer(const std::string& key) {
+  MMBuffer result;
+#ifdef __APPLE__
+  // iOS: Convert std::string to NSString* for MMKVCore pod compatibility
+  bool hasValue = instance->getBytes(@(key.c_str()), result);
+#else
+  // Android/other platforms: Use std::string directly (converts to
+  // std::string_view)
+  bool hasValue = instance->getBytes(key, result);
+#endif
+  if (hasValue) {
+    return std::make_shared<ManagedMMBuffer>(std::move(result));
+  } else {
+    return std::nullopt;
+  }
+}
+bool HybridMMKV::contains(const std::string& key) {
+  return instance->containsKey(key);
+}
+bool HybridMMKV::remove(const std::string& key) {
+  return instance->removeValueForKey(key);
+}
+std::vector<std::string> HybridMMKV::getAllKeys() {
+  return instance->allKeys();
+}
+void HybridMMKV::clearAll() {
+  instance->clearAll();
+}
+void HybridMMKV::recrypt(const std::optional<std::string>& key) {
+  bool successful = false;
+  if (key.has_value()) {
+    // Encrypt with the given key
+    successful = instance->reKey(key.value());
+  } else {
+    // Remove the encryption key by setting it to a blank string
+    successful = instance->reKey(std::string());
+  }
+  if (!successful) {
+    throw std::runtime_error("Failed to recrypt MMKV instance!");
+  }
+}
+void HybridMMKV::trim() {
+  instance->trim();
+  instance->clearMemoryCache();
+}
+
+Listener HybridMMKV::addOnValueChangedListener(const std::function<void(const std::string& /* key */)>& onValueChanged) {
+  // Add listener
+  auto mmkvID = instance->mmapID();
+  auto listenerID = MMKVValueChangedListenerRegistry::addListener(instance->mmapID(), onValueChanged);
+
+  return Listener([=]() {
+    // remove()
+    MMKVValueChangedListenerRegistry::removeListener(mmkvID, listenerID);
+  });
+}
+
+MMKVMode HybridMMKV::getMMKVMode(const Configuration& config) {
+  if (!config.mode.has_value()) {
+    return ::mmkv::MMKV_SINGLE_PROCESS;
+  }
+  switch (config.mode.value()) {
+    case Mode::SINGLE_PROCESS:
+      return ::mmkv::MMKV_SINGLE_PROCESS;
+    case Mode::MULTI_PROCESS:
+      return ::mmkv::MMKV_MULTI_PROCESS;
+    default:
+      [[unlikely]] throw std::runtime_error("Invalid MMKV Mode value!");
+  }
+}
+
+} // namespace margelo::nitro::mmkv

package/cpp/HybridMMKV.hpp

@@ -0,0 +1,47 @@
+//
+//  HybridMMKV.hpp
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 21.08.2025.
+//
+
+#pragma once
+
+#include "Configuration.hpp"
+#include "HybridMMKVSpec.hpp"
+#include "MMKVTypes.hpp"
+
+namespace margelo::nitro::mmkv {
+
+class HybridMMKV final : public HybridMMKVSpec {
+public:
+  explicit HybridMMKV(const Configuration& configuration);
+
+public:
+  // Properties
+  double getSize() override;
+  bool getIsReadOnly() override;
+
+public:
+  // Methods
+  void set(const std::string& key, const std::variant<std::string, double, bool, std::shared_ptr<ArrayBuffer>>& value) override;
+  std::optional<bool> getBoolean(const std::string& key) override;
+  std::optional<std::string> getString(const std::string& key) override;
+  std::optional<double> getNumber(const std::string& key) override;
+  std::optional<std::shared_ptr<ArrayBuffer>> getBuffer(const std::string& key) override;
+  bool contains(const std::string& key) override;
+  bool remove(const std::string& key) override;
+  std::vector<std::string> getAllKeys() override;
+  void clearAll() override;
+  void recrypt(const std::optional<std::string>& key) override;
+  void trim() override;
+  Listener addOnValueChangedListener(const std::function<void(const std::string& /* key */)>& onValueChanged) override;
+
+private:
+  static MMKVMode getMMKVMode(const Configuration& config);
+
+private:
+  MMKV* instance;
+};
+
+} // namespace margelo::nitro::mmkv

package/cpp/HybridMMKVFactory.cpp

@@ -0,0 +1,33 @@
+//
+//  HybridMMKVFactory.cpp
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 21.08.2025.
+//
+
+#include "HybridMMKVFactory.hpp"
+#include "HybridMMKV.hpp"
+#include "MMKVTypes.hpp"
+
+namespace margelo::nitro::mmkv {
+
+std::string HybridMMKVFactory::getDefaultMMKVInstanceId() {
+  return DEFAULT_MMAP_ID;
+}
+
+std::shared_ptr<HybridMMKVSpec> HybridMMKVFactory::createMMKV(const Configuration& configuration) {
+  return std::make_shared<HybridMMKV>(configuration);
+}
+
+void HybridMMKVFactory::initializeMMKV(const std::string& rootPath) {
+  Logger::log(LogLevel::Info, TAG, "Initializing MMKV with rootPath=%s", rootPath.c_str());
+
+#ifdef NITRO_DEBUG
+  MMKVLogLevel logLevel = ::mmkv::MMKVLogDebug;
+#else
+  MMKVLogLevel logLevel = ::mmkv::MMKVLogWarning;
+#endif
+  MMKV::initializeMMKV(rootPath, logLevel);
+}
+
+} // namespace margelo::nitro::mmkv

package/cpp/HybridMMKVFactory.hpp

@@ -0,0 +1,24 @@
+//
+//  HybridMMKVFactory.hpp
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 21.08.2025.
+//
+
+#pragma once
+
+#include "HybridMMKVFactorySpec.hpp"
+
+namespace margelo::nitro::mmkv {
+
+class HybridMMKVFactory final : public HybridMMKVFactorySpec {
+public:
+  HybridMMKVFactory() : HybridObject(TAG) {}
+
+public:
+  std::string getDefaultMMKVInstanceId() override;
+  std::shared_ptr<HybridMMKVSpec> createMMKV(const Configuration& configuration) override;
+  void initializeMMKV(const std::string& rootPath) override;
+};
+
+} // namespace margelo::nitro::mmkv