react-native-mmkv 4.0.0-beta.3 → 4.0.0-beta.5

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/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/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/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.3",
+  "version": "4.0.0-beta.5",
   "description": "react-native-mmkv",
   "main": "lib/index",
   "module": "lib/index",
@@ -22,6 +22,9 @@
     "ios/**/*.mm",
     "ios/**/*.cpp",
     "ios/**/*.swift",
+    "cpp/**/*.h",
+    "cpp/**/*.cpp",
+    "cpp/**/*.cpp",
     "app.plugin.js",
     "nitro.json",
     "*.podspec",