@react-native-ohos/react-native-mmkv 3.3.1-rc.1

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Android/MMKV/mmkv/src/main/java/com/tencent/mmkv/NativeBuffer.java

@@ -0,0 +1,36 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2025 THL A29 Limited, a Tencent company.
+ * All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use
+ * this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *       https://opensource.org/licenses/BSD-3-Clause
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.tencent.mmkv;
+
+/**
+ * A native memory wrapper, whose underlying memory can be passed to another JNI method directly.
+ * Avoiding unnecessary JNI boxing and unboxing.
+ * Must be destroy manually {@link MMKV#destroyNativeBuffer}.
+ */
+public final class NativeBuffer {
+    public long pointer;
+    public int size;
+
+    public NativeBuffer(long ptr, int length) {
+        pointer = ptr;
+        size = length;
+    }
+}

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Android/MMKV/mmkv/src/main/java/com/tencent/mmkv/ParcelableMMKV.java

@@ -0,0 +1,108 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2018 THL A29 Limited, a Tencent company.
+ * All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use
+ * this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *       https://opensource.org/licenses/BSD-3-Clause
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.tencent.mmkv;
+
+import android.os.Parcel;
+import android.os.ParcelFileDescriptor;
+import android.os.Parcelable;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import org.jetbrains.annotations.Contract;
+
+import java.io.IOException;
+
+/**
+ * A helper class for MMKV based on Anonymous Shared Memory. {@link MMKV#mmkvWithAshmemID}
+ */
+public final class ParcelableMMKV implements Parcelable {
+    private final String mmapID;
+    private int ashmemFD = -1;
+    private int ashmemMetaFD = -1;
+    private String cryptKey = null;
+
+    public ParcelableMMKV(@NonNull MMKV mmkv) {
+        mmapID = mmkv.mmapID();
+        ashmemFD = mmkv.ashmemFD();
+        ashmemMetaFD = mmkv.ashmemMetaFD();
+        cryptKey = mmkv.cryptKey();
+    }
+
+    private ParcelableMMKV(String id, int fd, int metaFD, String key) {
+        mmapID = id;
+        ashmemFD = fd;
+        ashmemMetaFD = metaFD;
+        cryptKey = key;
+    }
+
+    @Nullable
+    public MMKV toMMKV() {
+        if (ashmemFD >= 0 && ashmemMetaFD >= 0) {
+            return MMKV.mmkvWithAshmemFD(mmapID, ashmemFD, ashmemMetaFD, cryptKey);
+        }
+        return null;
+    }
+
+    @Override
+    public int describeContents() {
+        return CONTENTS_FILE_DESCRIPTOR;
+    }
+
+    @Override
+    public void writeToParcel(@NonNull Parcel dest, int flags) {
+        try {
+            dest.writeString(mmapID);
+            ParcelFileDescriptor fd = ParcelFileDescriptor.fromFd(ashmemFD);
+            ParcelFileDescriptor metaFD = ParcelFileDescriptor.fromFd(ashmemMetaFD);
+            flags = flags | Parcelable.PARCELABLE_WRITE_RETURN_VALUE;
+            fd.writeToParcel(dest, flags);
+            metaFD.writeToParcel(dest, flags);
+            if (cryptKey != null) {
+                dest.writeString(cryptKey);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static final Parcelable.Creator<ParcelableMMKV> CREATOR = new Parcelable.Creator<ParcelableMMKV>() {
+        @Nullable
+        @Override
+        public ParcelableMMKV createFromParcel(@NonNull Parcel source) {
+            String mmapID = source.readString();
+            ParcelFileDescriptor fd = ParcelFileDescriptor.CREATOR.createFromParcel(source);
+            ParcelFileDescriptor metaFD = ParcelFileDescriptor.CREATOR.createFromParcel(source);
+            String cryptKey = source.readString();
+            if (fd != null && metaFD != null) {
+                return new ParcelableMMKV(mmapID, fd.detachFd(), metaFD.detachFd(), cryptKey);
+            }
+            return null;
+        }
+
+        @NonNull
+        @Contract(value = "_ -> new", pure = true)
+        @Override
+        public ParcelableMMKV[] newArray(int size) {
+            return new ParcelableMMKV[size];
+        }
+    };
+}

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Android/MMKV/mmkv/src/main/java/com/tencent/mmkv/UnsupportedArchitectureException.java

@@ -0,0 +1,27 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2025 THL A29 Limited, a Tencent company.
+ * All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use
+ * this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *       https://opensource.org/licenses/BSD-3-Clause
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.tencent.mmkv;
+
+public class UnsupportedArchitectureException extends RuntimeException {
+    public UnsupportedArchitectureException(String message) {
+        super(message);
+    }
+}

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Android/MMKV/mmkvannotation/build.gradle

@@ -0,0 +1,34 @@
+apply plugin: 'com.android.library'
+
+android {
+    namespace "com.tencent.mmkv"
+
+    compileSdk rootProject.ext.compileSdk
+
+    defaultConfig {
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        minSdkVersion rootProject.ext.minSdkVersion
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            consumerProguardFiles 'proguard-rules.pro'
+        }
+    }
+
+
+}
+
+configurations {
+    javadocDeps
+}
+
+dependencies {
+    implementation fileTree(include: ['*.jar'], dir: 'libs')
+    implementation 'androidx.annotation:annotation:1.9.1'
+    javadocDeps 'androidx.annotation:annotation:1.9.1'
+    testImplementation 'junit:junit:4.13.2'
+    androidTestImplementation 'androidx.test:runner:1.6.2'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.6.1'
+}

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Android/MMKV/mmkvannotation/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Android/MMKV/mmkvannotation/src/main/java/dalvik/annotation/optimization/FastNative.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dalvik.annotation.optimization;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+/**
+ * An ART runtime built-in optimization for {@code native} methods to speed up JNI transitions:
+ * Compared to normal {@code native} methods, {@code native} methods that are annotated with
+ * {@literal @}{@code FastNative} use faster JNI transitions from managed code to the native code
+ * and back. Calls from a {@literal @}{@code FastNative} method implementation to JNI functions
+ * that access the managed heap or call managed code also have faster internal transitions.
+ *
+ * <p>
+ * While executing a {@literal @}{@code FastNative} method, the garbage collection cannot
+ * suspend the thread for essential work and may become blocked. Use with caution. Do not use
+ * this annotation for long-running methods, including usually-fast, but generally unbounded,
+ * methods. In particular, the code should not perform significant I/O operations or acquire
+ * native locks that can be held for a long time. (Some logging or native allocations, which
+ * internally acquire native locks for a short time, are generally OK. However, as the cost
+ * of several such operations adds up, the {@literal @}{@code FastNative} performance gain
+ * can become insignificant and overshadowed by potential GC delays.)
+ * Acquiring managed locks is OK as it internally allows thread suspension.
+ * </p>
+ *
+ * <p>
+ * For performance critical methods that need this annotation, it is strongly recommended
+ * to explicitly register the method(s) with JNI {@code RegisterNatives} instead of relying
+ * on the built-in dynamic JNI linking.
+ * </p>
+ *
+ * <p>
+ * The {@literal @}{@code FastNative} optimization was implemented for system use since
+ * Android 8 and became CTS-tested public API in Android 14. Developers aiming for maximum
+ * compatibility should avoid calling {@literal @}{@code FastNative} methods on Android 13-.
+ * The optimization is likely to work also on Android 8-13 devices (after all, it was used
+ * in the system, albeit without the strong CTS guarantees), especially those that use
+ * unmodified versions of ART, such as Android 12+ devices with the official ART Module.
+ * The built-in dynamic JNI linking is working only in Android 12+, the explicit registration
+ * with JNI {@code RegisterNatives} is strictly required for running on Android versions 8-11.
+ * The annotation is ignored on Android 7-.
+ * </p>
+ *
+ * <p>
+ * <b>Deadlock Warning:</b> As a rule of thumb, any native locks acquired in a
+ * {@literal @}{@link FastNative} call (despite the above warning that this is an unbounded
+ * operation that can block GC for a long time) must be released before returning to managed code.
+ * </p>
+ *
+ * <p>
+ * Say some code does:
+ *
+ * <code>
+ * fast_jni_call_to_grab_a_lock();
+ * does_some_java_work();
+ * fast_jni_call_to_release_a_lock();
+ * </code>
+ *
+ * <p>
+ * This code can lead to deadlocks. Say thread 1 just finishes
+ * {@code fast_jni_call_to_grab_a_lock()} and is in {@code does_some_java_work()}.
+ * GC kicks in and suspends thread 1. Thread 2 now is in {@code fast_jni_call_to_grab_a_lock()}
+ * but is blocked on grabbing the native lock since it's held by thread 1.
+ * Now thread suspension can't finish since thread 2 can't be suspended since it's doing
+ * FastNative JNI.
+ * </p>
+ *
+ * <p>
+ * Normal JNI doesn't have the issue since once it's in native code,
+ * it is considered suspended from java's point of view.
+ * FastNative JNI however doesn't do the state transition done by JNI.
+ * </p>
+ *
+ * <p>
+ * Note that even in FastNative methods you <b>are</b> allowed to
+ * allocate objects and make upcalls into Java code. A call from Java to
+ * a FastNative function and back to Java is equivalent to a call from one Java
+ * method to another. What's forbidden in a FastNative method is blocking
+ * the calling thread in some non-Java code and thereby preventing the thread
+ * from responding to requests from the garbage collector to enter the suspended
+ * state.
+ * </p>
+ *
+ * <p>
+ * Has no effect when used with non-native methods.
+ * </p>
+ */
+@Retention(RetentionPolicy.CLASS)  // Save memory, don't instantiate as an object at runtime.
+@Target(ElementType.METHOD)
+public @interface FastNative { }

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Android/MMKV/mmkvdemo/build.gradle

@@ -0,0 +1,116 @@
+apply plugin: 'com.android.application'
+apply plugin: 'kotlin-android'
+
+android {
+    namespace "com.tencent.mmkvdemo"
+    compileSdk rootProject.ext.compileSdk
+
+    signingConfigs {
+        config {
+            keyAlias 'key0'
+            keyPassword 'mmkv.wxg'
+            storeFile rootProject.file('debug.keystore')
+            storePassword 'mmkv.wxg'
+        }
+    }
+
+    defaultConfig {
+        applicationId "com.tencent.mmkvdemo"
+        minSdkVersion rootProject.ext.minSdkVersion
+        targetSdkVersion rootProject.ext.targetSdkVersion
+        versionCode 1
+        versionName "1.0"
+
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        externalNativeBuild {
+            cmake {
+                arguments = ["-DANDROID_STL=c++_shared"]
+                // use prefab or not: Gradle has bug handling local prefab modules, fails on linking
+                arguments += ["-DHAS_PREFAB=1"]
+                cppFlags "-fvisibility=hidden", "-funwind-tables", "-fasynchronous-unwind-tables", "-O2",
+                        "-Wl,-z,max-page-size=16384"
+            }
+        }
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled true
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+            signingConfig signingConfigs.config
+//            debuggable true
+//            jniDebuggable true
+        }
+        debug {
+            signingConfig signingConfigs.config
+            jniDebuggable true
+        }
+    }
+
+    sourceSets {
+        main.java.srcDirs += 'src/main/kotlin'
+    }
+
+    flavorDimensions = ["stl_mode"]
+    productFlavors {
+        DefaultCpp.dimension = "stl_mode"
+        StaticCpp.dimension = "stl_mode"
+        SharedCpp.dimension = "stl_mode"
+    }
+    externalNativeBuild {
+        cmake {
+            path file('src/main/cpp/CMakeLists.txt')
+        }
+    }
+
+    buildFeatures {
+        aidl true
+
+        prefab true
+    }
+
+    kotlinOptions {
+        jvmTarget = JavaVersion.VERSION_1_8.toString()
+    }
+    /*splits {
+        // Configures multiple APKs based on ABI.
+        abi {
+
+            // Enables building multiple APKs per ABI.
+            enable true
+
+            // By default all ABIs are included, so use reset() and include to specify that we only want specific APKs
+            // Resets the list of ABIs that Gradle should create APKs for to none.
+            reset()
+
+            // Specifies a list of ABIs that Gradle should create APKs for.
+            include "armeabi-v7a"
+
+            // Specifies that we do not want to also generate a universal APK that includes all ABIs.
+            universalApk false
+        }
+    }*/
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+// Define the mmkv version to use
+def mmkvVersion = "${VERSION_NAME_PREFIX}${VERSION_NAME_SUFFIX}"
+
+dependencies {
+    implementation fileTree(include: ['*.jar'], dir: 'libs')
+    implementation project(':mmkv')
+//    implementation "com.tencent:mmkv:$mmkvVersion"
+//    implementation "com.tencent:mmkv-static:$mmkvVersion" // this is identical to 'com.tencent:mmkv'
+//    implementation "com.tencent:mmkv-shared:$mmkvVersion" // with prefab functionality
+    implementation 'androidx.appcompat:appcompat:1.7.1'
+    implementation 'androidx.constraintlayout:constraintlayout:2.2.1'
+    testImplementation 'junit:junit:4.13.2'
+    androidTestImplementation 'androidx.test:runner:1.7.0'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.7.0'
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    implementation 'com.getkeepsafe.relinker:relinker:1.4.5'
+}

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Android/MMKV/mmkvdemo/proguard-rules.pro

@@ -0,0 +1,24 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
+-keepclasseswithmembers,includedescriptorclasses class com.tencent.mmkvdemo.** {
+    native <methods>;
+}

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Android/MMKV/mmkvdemo/src/main/AndroidManifest.xml

@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <application
+        android:allowBackup="true"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:roundIcon="@mipmap/ic_launcher_round"
+        android:supportsRtl="true"
+        android:theme="@style/AppTheme"
+        android:name=".MyApplication">
+        <activity
+            android:name=".MainActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+
+        <service
+            android:name=".MyService"
+            android:enabled="true"
+            android:exported="false"
+            android:process=":mmkvdemo_svr">
+            <intent-filter>
+                <action android:name="com.tencent.mmkvdemo.MyService"/>
+            </intent-filter>
+        </service>
+        <service
+            android:name=".MyService_1"
+            android:enabled="true"
+            android:exported="false"
+            android:process=":mmkvdemo_svr_1">
+            <intent-filter>
+                <action android:name="com.tencent.mmkvdemo.MyService_1"/>
+            </intent-filter>
+        </service>
+
+        <provider android:name=".MultiProcessSharedPreferences"
+            android:authorities=".MultiProcessSharedPreferences"
+            android:process=".MultiProcessSharedPreferences"
+            android:exported="false">
+        </provider>
+
+        <provider
+            android:authorities="com.tencent.mmkvdemo.MMKVContentProvider"
+            android:name="com.tencent.mmkv.MMKVContentProvider"
+            android:exported="false">
+        </provider>
+    </application>
+
+</manifest>

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Android/MMKV/mmkvdemo/src/main/aidl/com/tencent/mmkvdemo/IAshmemMMKV.aidl

@@ -0,0 +1,8 @@
+// IAshmemMMKV.aidl
+package com.tencent.mmkvdemo;
+
+import com.tencent.mmkv.ParcelableMMKV;
+
+interface IAshmemMMKV {
+    ParcelableMMKV GetAshmemMMKV();
+}

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Android/MMKV/mmkvdemo/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,50 @@
+
+# For more information about using CMake with Android Studio, read the
+# documentation: https://d.android.com/studio/projects/add-native-code.html.
+# For more examples on how to use CMake, see https://github.com/android/ndk-samples.
+
+# Sets the minimum CMake version required for this project.
+cmake_minimum_required(VERSION 3.10.0)
+
+# Declares the project name. The project name can be accessed via ${ PROJECT_NAME},
+# Since this is the top level CMakeLists.txt, the project name is also accessible
+# with ${CMAKE_PROJECT_NAME} (both CMake variables are in-sync within the top level
+# build script scope).
+project("mmkvdemo")
+
+# Creates and names a library, sets it as either STATIC
+# or SHARED, and provides the relative paths to its source code.
+# You can define multiple libraries, and CMake builds them for you.
+# Gradle automatically packages shared libraries with your APK.
+#
+# In this top level CMakeLists.txt, ${CMAKE_PROJECT_NAME} is used to define
+# the target library name; in the sub-module's CMakeLists.txt, ${PROJECT_NAME}
+# is preferred for the same purpose.
+#
+# In order to load a library into your app from Java/Kotlin, you must call
+# System.loadLibrary() and pass the name of the library defined here;
+# for GameActivity/NativeActivity derived applications, the same library name must be
+# used in the AndroidManifest.xml file.
+add_library(${CMAKE_PROJECT_NAME} SHARED
+    # List C/C++ source files with relative paths to this CMakeLists.txt.
+    mmkvdemo.cpp)
+
+# Find the mmkv lib in prefab
+if (HAS_PREFAB)
+    find_package(mmkv REQUIRED CONFIG)
+    target_link_libraries(${CMAKE_PROJECT_NAME}
+            mmkv::mmkv
+    )
+    target_compile_options(${CMAKE_PROJECT_NAME} PRIVATE
+            -DENABLE_MMKV_NATIVE=1
+    )
+endif ()
+
+# Specifies libraries CMake should link to your target library. You
+# can link libraries from various origins, such as libraries defined in this
+# build script, prebuilt third-party libraries, or Android system libraries.
+target_link_libraries(${CMAKE_PROJECT_NAME}
+    # List libraries link to the target library
+    android
+    log
+)