react-native-mmkv 4.0.0-beta.4 → 4.0.0-beta.6

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);
+}
+void HybridMMKV::remove(const std::string& key) {
+  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;
+  void 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

package/cpp/MMKVTypes.hpp

@@ -0,0 +1,50 @@
+//
+//  MMKVTypes.h
+//  react-native-mmkv
+//
+//  Created by Brad Anderson on 10.08.2025.
+//  Platform-specific MMKV type unification header
+//
+
+#pragma once
+
+// Platform-specific MMKV includes
+#ifdef __ANDROID__
+#include <MMKV/MMKV.h>
+
+// On Android, bring global namespace types into mmkv namespace for consistency
+namespace mmkv {
+using MMKV = ::MMKV;
+using MMKVMode = ::MMKVMode;
+using MMKVLogLevel = ::MMKVLogLevel;
+
+// Constants - bring into mmkv namespace
+constexpr auto MMKVLogDebug = ::MMKVLogDebug;
+constexpr auto MMKVLogInfo = ::MMKVLogInfo;
+constexpr auto MMKVLogWarning = ::MMKVLogWarning;
+constexpr auto MMKVLogError = ::MMKVLogError;
+constexpr auto MMKVLogNone = ::MMKVLogNone;
+
+constexpr auto MMKV_SINGLE_PROCESS = ::MMKV_SINGLE_PROCESS;
+constexpr auto MMKV_MULTI_PROCESS = ::MMKV_MULTI_PROCESS;
+constexpr auto MMKV_READ_ONLY = ::MMKVMode::MMKV_READ_ONLY;
+} // namespace mmkv
+
+#else
+#include <MMKVCore/MMKV.h>
+// iOS already has everything in mmkv:: namespace
+#endif
+
+/**
+ * Unified MMKV namespace usage for cross-platform compatibility.
+ *
+ * After including this header, use:
+ * - mmkv::MMKV for the main class
+ * - mmkv::MMKVMode for mode enum
+ * - mmkv::MMKVLogLevel for log level enum
+ * - mmkv::MMBuffer for buffer type
+ * - mmkv::MMKV_SINGLE_PROCESS / mmkv::MMKV_MULTI_PROCESS for modes
+ * - mmkv::MMKVLogDebug, etc. for log levels
+ */
+
+using namespace mmkv;

package/cpp/MMKVValueChangedListenerRegistry.cpp

@@ -0,0 +1,58 @@
+//
+//  MMKVValueChangedListenerRegistry.cpp
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 21.08.2025.
+//
+
+#include "MMKVValueChangedListenerRegistry.hpp"
+
+namespace margelo::nitro::mmkv {
+
+// static members
+std::atomic<ListenerID> MMKVValueChangedListenerRegistry::_listenersCounter = 0;
+std::unordered_map<MMKVID, std::vector<ListenerSubscription>> MMKVValueChangedListenerRegistry::_listeners;
+
+ListenerID MMKVValueChangedListenerRegistry::addListener(const std::string& mmkvID,
+                                                         const std::function<void(const std::string& /* key */)>& callback) {
+  // 1. Get (or create) the listeners array for these MMKV instances
+  auto& listeners = _listeners[mmkvID];
+  // 2. Get (and increment) the listener ID counter
+  auto id = _listenersCounter.fetch_add(1);
+  // 3. Add the listener to our array
+  listeners.push_back(ListenerSubscription{
+      .id = id,
+      .callback = callback,
+  });
+  // 4. Return the ID used to unsubscribe later on
+  return id;
+}
+
+void MMKVValueChangedListenerRegistry::removeListener(const std::string& mmkvID, ListenerID id) {
+  // 1. Get the listeners array for these MMKV instances
+  auto entry = _listeners.find(mmkvID);
+  if (entry == _listeners.end()) {
+    // There's no more listeners for this instance anyways.
+    return;
+  }
+  // 2. Remove all listeners where the ID matches. Should only be one.
+  auto& listeners = entry->second;
+  listeners.erase(std::remove_if(listeners.begin(), listeners.end(), [id](const ListenerSubscription& e) { return e.id == id; }),
+                  listeners.end());
+}
+
+void MMKVValueChangedListenerRegistry::notifyOnValueChanged(const std::string& mmkvID, const std::string& key) {
+  // 1. Get all listeners for the specific MMKV ID
+  auto entry = _listeners.find(mmkvID);
+  if (entry == _listeners.end()) {
+    // There are no listeners. Return
+    return;
+  }
+  // 2. Call each listener.
+  auto& listeners = entry->second;
+  for (const auto& listener : listeners) {
+    listener.callback(key);
+  }
+}
+
+} // namespace margelo::nitro::mmkv

package/cpp/MMKVValueChangedListenerRegistry.hpp

@@ -0,0 +1,43 @@
+//
+//  MMKVValueChangedListenerRegistry.hpp
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 21.08.2025.
+//
+
+#include "MMKVTypes.hpp"
+#include <atomic>
+#include <unordered_map>
+
+namespace margelo::nitro::mmkv {
+
+using ListenerID = size_t;
+using MMKVID = std::string;
+
+struct ListenerSubscription {
+  ListenerID id;
+  std::function<void(const std::string& /* key */)> callback;
+};
+
+/**
+ * Listeners are tracked across instances - so we need an extra static class for
+ * the registry.
+ */
+class MMKVValueChangedListenerRegistry final {
+public:
+  MMKVValueChangedListenerRegistry() = delete;
+  ~MMKVValueChangedListenerRegistry() = delete;
+
+public:
+  static ListenerID addListener(const std::string& mmkvID, const std::function<void(const std::string& /* key */)>& callback);
+  static void removeListener(const std::string& mmkvID, ListenerID id);
+
+public:
+  static void notifyOnValueChanged(const std::string& mmkvID, const std::string& key);
+
+private:
+  static std::atomic<ListenerID> _listenersCounter;
+  static std::unordered_map<MMKVID, std::vector<ListenerSubscription>> _listeners;
+};
+
+} // namespace margelo::nitro::mmkv

package/cpp/ManagedMMBuffer.hpp

@@ -0,0 +1,40 @@
+//
+//  ManagedMMBuffer.h
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 25.03.24.
+//
+
+#pragma once
+
+#include "MMKVTypes.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::mmkv {
+
+/**
+ An ArrayBuffer subclass that manages MMBuffer memory (by ownership).
+ */
+class ManagedMMBuffer : public ArrayBuffer {
+public:
+  explicit ManagedMMBuffer(MMBuffer&& buffer) : _buffer(std::move(buffer)) {}
+
+public:
+  bool isOwner() const noexcept override {
+    return true;
+  }
+
+public:
+  uint8_t* data() override {
+    return static_cast<uint8_t*>(_buffer.getPtr());
+  }
+
+  size_t size() const override {
+    return _buffer.length();
+  }
+
+private:
+  MMBuffer _buffer;
+};
+
+} // namespace margelo::nitro::mmkv

package/nitro.json

@@ -23,5 +23,6 @@
   },
   "ignorePaths": [
     "**/node_modules"
-  ]
+  ],
+  "gitAttributesGeneratedFlag": false
 }

package/nitrogen/generated/.gitattributes

@@ -1 +1 @@
-** linguist-generated=true
+** linguist-generated=false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mmkv",
-  "version": "4.0.0-beta.4",
+  "version": "4.0.0-beta.6",
   "description": "react-native-mmkv",
   "main": "lib/index",
   "module": "lib/index",
@@ -22,6 +22,9 @@
     "ios/**/*.mm",
     "ios/**/*.cpp",
     "ios/**/*.swift",
+    "cpp/**/*.h",
+    "cpp/**/*.hpp",
+    "cpp/**/*.cpp",
     "app.plugin.js",
     "nitro.json",
     "*.podspec",