react-native-mmkv-dz 2.5.1

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

@@ -0,0 +1,302 @@
+//
+//  MmkvHostObject.cpp
+//  Mmkv
+//
+//  Created by Marc Rousavy on 03.09.21.
+//  Copyright © 2021 Facebook. All rights reserved.
+//
+
+#include "MmkvHostObject.h"
+#include "TypedArray.h"
+#include <MMKV.h>
+#include <android/log.h>
+#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());
+  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);
+
+  if (instance == nullptr) {
+    // Check if instanceId is invalid
+    if (instanceId.empty()) {
+      throw std::runtime_error("Failed to create MMKV instance! `id` cannot be empty!");
+    }
+
+    // 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!");
+  }
+}
+
+std::vector<jsi::PropNameID> MmkvHostObject::getPropertyNames(jsi::Runtime& rt) {
+  std::vector<jsi::PropNameID> result;
+  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("getString")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("getNumber")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("contains")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("delete")));
+  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")));
+  return result;
+}
+
+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)
+    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);
+
+      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();
+    });
+  }
+
+  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!");
+      }
+
+      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!");
+      }
+
+      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!");
+      }
+
+      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!");
+        }
+
+        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!");
+      }
+
+      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!");
+      }
+
+      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;
+    });
+  }
+
+  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();
+    });
+  }
+
+  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::Value::undefined();
+}

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

@@ -0,0 +1,26 @@
+//
+//  MmkvHostObject.h
+//  Mmkv
+//
+//  Created by Marc Rousavy on 03.09.21.
+//  Copyright © 2021 Facebook. All rights reserved.
+//
+
+#pragma once
+
+#include <jsi/jsi.h>
+#include <MMKV.h>
+
+using namespace facebook;
+
+class JSI_EXPORT MmkvHostObject: public jsi::HostObject {
+public:
+  MmkvHostObject(const std::string& instanceId, std::string path, std::string cryptKey);
+
+public:
+  jsi::Value get(jsi::Runtime&, const jsi::PropNameID& name) override;
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& rt) override;
+
+private:
+  MMKV* instance;
+};

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

@@ -0,0 +1,65 @@
+#include <jni.h>
+#include <jsi/jsi.h>
+#include <MMKV.h>
+#include "MmkvHostObject.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));
+}
+
+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) {
+    MMKV::initializeMMKV(jstringToStdString(env, path));
+
+    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.
+}

package/android/src/main/java/com/reactnativemmkv/MmkvModule.java

@@ -0,0 +1,49 @@
+package com.reactnativemmkv;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.JavaScriptContextHolder;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.module.annotations.ReactModule;
+
+@ReactModule(name = MmkvModule.NAME)
+public class MmkvModule extends ReactContextBaseJavaModule {
+  public static final String NAME = "MMKV";
+
+  public MmkvModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @NonNull
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean install(@Nullable String rootDirectory) {
+    try {
+      Log.i(NAME, "Loading C++ library...");
+      System.loadLibrary("reactnativemmkv");
+
+      JavaScriptContextHolder jsContext = getReactApplicationContext().getJavaScriptContextHolder();
+      if (rootDirectory == null) {
+        rootDirectory = getReactApplicationContext().getFilesDir().getAbsolutePath() + "/mmkv";
+      }
+      Log.i(NAME, "Installing MMKV JSI Bindings for MMKV root directory: " + rootDirectory);
+      nativeInstall(jsContext.get(), rootDirectory);
+      Log.i(NAME, "Successfully installed MMKV JSI Bindings!");
+      return true;
+    } catch (Exception exception) {
+      Log.e(NAME, "Failed to install MMKV JSI Bindings!", exception);
+      return false;
+    }
+  }
+
+  private static native void nativeInstall(long jsiPtr, String path);
+}

package/android/src/main/java/com/reactnativemmkv/MmkvPackage.java

@@ -0,0 +1,26 @@
+package com.reactnativemmkv;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.Collections;
+import java.util.List;
+
+
+public class MmkvPackage implements ReactPackage {
+  @NonNull
+  @Override
+  public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+    return Collections.singletonList(new MmkvModule(reactContext));
+  }
+
+  @NonNull
+  @Override
+  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}