react-native-mmkv 2.12.2 → 3.0.0-beta.2

package/android/build.gradle

@@ -1,139 +1,109 @@
-import com.android.Version
-
-def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
-def agpVersionMajor = agpVersion.tokenize('.')[0].toInteger()
-def androidManifestPath = agpVersionMajor >= 7 ? 'src/main/AndroidManifest.xml' : 'src/hasNamespace/AndroidManifest.xml'
-
 buildscript {
   repositories {
-    maven {
-      url "https://plugins.gradle.org/m2/"
-    }
-    mavenCentral()
     google()
+    mavenCentral()
   }
 
   dependencies {
-    classpath("com.android.tools.build:gradle:8.2.2")
+    classpath "com.android.tools.build:gradle:7.2.1"
   }
 }
 
-def resolveBuildType() {
-    Gradle gradle = getGradle()
-    String tskReqStr = gradle.getStartParameter().getTaskRequests()['args'].toString()
-
-    return tskReqStr.contains('Release') ? 'release' : 'debug'
-}
-
 def isNewArchitectureEnabled() {
-  // To opt-in for the New Architecture, you can either:
-  // - Set `newArchEnabled` to true inside the `gradle.properties` file
-  // - Invoke gradle with `-newArchEnabled=true`
-  // - Set an environment variable `ORG_GRADLE_PROJECT_newArchEnabled=true`
-  return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
 }
 
+apply plugin: "com.android.library"
+
 if (isNewArchitectureEnabled()) {
-  apply plugin: 'com.facebook.react'
+  apply plugin: "com.facebook.react"
 }
-apply plugin: 'com.android.library'
 
-def safeExtGet(prop, fallback) {
-  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["Mmkv_" + name]
 }
 
-def reactNativeArchitectures() {
-  def value = project.getProperties().get("reactNativeArchitectures")
-  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Mmkv_" + name]).toInteger()
 }
 
-repositories {
-  mavenCentral()
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
 }
 
 android {
-  compileSdkVersion safeExtGet("compileSdkVersion", 28)
-  if (agpVersionMajor >= 7) {
-    namespace = "com.reactnativemmkv"
-  }
+  if (supportsNamespace()) {
+    namespace "com.mrousavy.mmkv"
 
-  if (agpVersionMajor >= 8) {
-      buildFeatures {
-          buildConfig = true
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
       }
-  }
-
-  sourceSets {
-    main {
-      manifest.srcFile androidManifestPath
     }
   }
 
-  // Used to override the NDK path/version on internal CI or by allowing
-  // users to customize the NDK path/version from their root project (e.g. for M1 support)
-  if (rootProject.hasProperty("ndkPath")) {
-    ndkPath rootProject.ext.ndkPath
-  }
-  if (rootProject.hasProperty("ndkVersion")) {
-    ndkVersion rootProject.ext.ndkVersion
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
   }
 
   buildFeatures {
-    prefab true
+    buildConfig true
   }
 
-  defaultConfig {
-    minSdkVersion safeExtGet('minSdkVersion', 16)
-    targetSdkVersion safeExtGet('targetSdkVersion', 28)
-    versionCode 1
-    versionName "1.0"
-    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
-    externalNativeBuild {
-      cmake {
-        cppFlags "-O2 -frtti -fexceptions -Wall -Wno-unused-variable -fstack-protector-all"
-        arguments "-DANDROID_STL=c++_shared"
-        abiFilters (*reactNativeArchitectures())
-      }
+  buildTypes {
+    release {
+      minifyEnabled false
     }
   }
 
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
   compileOptions {
     sourceCompatibility JavaVersion.VERSION_1_8
     targetCompatibility JavaVersion.VERSION_1_8
   }
 
-  externalNativeBuild {
-    cmake {
-      path "CMakeLists.txt"
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+          java.srcDirs += [
+            // This is needed to build Kotlin project with NewArch enabled
+            "${project.buildDir}/generated/source/codegen/java"
+          ]
+      }
     }
   }
-  packagingOptions {
-    doNotStrip resolveBuildType() == 'debug' ? "**/**/*.so" : ''
-    excludes = [
-            "META-INF",
-            "META-INF/**",
-            "**/libjsi.so",
-            "**/libc++_shared.so"
-    ]
-  }
 }
 
+repositories {
+  mavenCentral()
+  google()
+}
+
+
 dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
   //noinspection GradleDynamicVersion
-  implementation 'com.facebook.react:react-android:+'
+  implementation "com.facebook.react:react-native:+"
 }
 
-// Resolves "LOCAL_SRC_FILES points to a missing file, Check that libfb.so exists or that its path is correct".
-tasks.whenTaskAdded { task ->
-  if (task.name.contains("configureCMakeDebug")) {
-    rootProject.getTasksByName("packageReactNdkDebugLibs", true).forEach {
-      task.dependsOn(it)
-    }
-  }
-  // We want to add a dependency for both configureCMakeRelease and configureCMakeRelWithDebInfo
-  if (task.name.contains("configureCMakeRel")) {
-    rootProject.getTasksByName("packageReactNdkReleaseLibs", true).forEach {
-      task.dependsOn(it)
-    }
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "Mmkv"
+    codegenJavaPackageName = "com.mrousavy.mmkv"
   }
 }

package/android/gradle.properties

@@ -1,6 +1,5 @@
-Mmkv_compileSdkVersion=31
-Mmkv_buildToolsVersion=31.0.0
+Mmkv_kotlinVersion=1.7.0
+Mmkv_minSdkVersion=21
 Mmkv_targetSdkVersion=31
-android.useAndroidX=true
-
-org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+Mmkv_compileSdkVersion=31
+Mmkv_ndkversion=21.4.7075529

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,32 @@
+//
+//  ManagedBuffer.h
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 25.03.24.
+//
+
+#pragma once
+
+#include "MMKVManagedBuffer.h"
+#include <jsi/jsi.h>
+
+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;
+};