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

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Core/MMKVPredef.h

@@ -0,0 +1,310 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2019 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.
+ */
+
+#ifndef MMKV_SRC_MMKVPREDEF_H
+#define MMKV_SRC_MMKVPREDEF_H
+
+// disable encryption & decryption to reduce some code
+// #define MMKV_DISABLE_CRYPT
+//#define MMKV_DISABLE_FLUTTER
+
+// using POSIX implementation
+//#define FORCE_POSIX
+
+#ifdef __cplusplus
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+
+constexpr auto MMKV_VERSION = "v2.3.0";
+
+#ifdef DEBUG
+#    define MMKV_DEBUG
+#endif
+
+#ifdef NDEBUG
+#    undef MMKV_DEBUG
+#endif
+
+#if __cplusplus>=202002L
+#    define MMKV_HAS_CPP20
+#endif
+
+#ifdef __ANDROID__
+#    ifdef FORCE_POSIX
+#        define MMKV_POSIX
+#    else
+#        define MMKV_ANDROID
+#    endif
+#elif __OHOS__
+#   ifdef FORCE_POSIX
+#       define MMKV_POSIX
+#   else
+#       define MMKV_ANDROID
+#       define MMKV_OHOS
+#endif
+#elif __APPLE__
+#    ifdef FORCE_POSIX
+#        define MMKV_POSIX
+#    else
+#        define MMKV_APPLE
+#        ifdef __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__
+#            define MMKV_IOS
+#        elif __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__
+#            define MMKV_WATCH
+#        else
+#            define MMKV_MAC
+#        endif
+#    endif // FORCE_POSIX
+#elif __linux__ || __unix__
+#    define MMKV_POSIX
+#    if __linux__
+#        define MMKV_LINUX
+#    endif
+#elif _WIN32
+#    define MMKV_WIN32
+#endif
+
+#ifdef MMKV_WIN32
+#    if !defined(_WIN32_WINNT)
+#        define _WIN32_WINNT _WIN32_WINNT_WINXP
+#    endif
+
+#    include <SDKDDKVer.h>
+// Exclude rarely-used stuff from Windows headers
+#    define WIN32_LEAN_AND_MEAN
+// Windows Header Files
+#    include <windows.h>
+
+constexpr auto MMKV_PATH_SLASH = L"\\";
+#    define MMKV_PATH_FORMAT "%ls"
+using MMKVFileHandle_t = HANDLE;
+#define MMKVFileHandleInvalidValue INVALID_HANDLE_VALUE
+using MMKVPath_t = std::wstring;
+extern MMKVPath_t string2MMKVPath_t(const std::string &str);
+extern std::string MMKVPath_t2String(const MMKVPath_t &str);
+
+#    ifndef MMKV_EMBED_ZLIB
+#        define MMKV_EMBED_ZLIB 1
+#    endif
+
+#else // MMKV_WIN32
+
+constexpr auto MMKV_PATH_SLASH = "/";
+#    define MMKV_PATH_FORMAT "%s"
+using MMKVFileHandle_t = int;
+constexpr MMKVFileHandle_t MMKVFileHandleInvalidValue = -1;
+using MMKVPath_t = std::string;
+#    define string2MMKVPath_t(str) (str)
+#    define MMKVPath_t2String(str) (str)
+
+#    ifndef MMKV_EMBED_ZLIB
+#        define MMKV_EMBED_ZLIB 0
+#    endif
+
+#endif // MMKV_WIN32
+
+#ifdef MMKV_ANDROID
+#define MMKV_EXPORT __attribute__((visibility("default")))
+#else
+#define MMKV_EXPORT
+#endif
+
+#ifdef MMKV_APPLE
+#ifdef __OBJC__
+#    import <Foundation/Foundation.h>
+using MMKVLog_t = NSString *;
+#else
+using MMKVLog_t = void *;
+#endif
+#    define MMKV_NAMESPACE_BEGIN namespace mmkv {
+#    define MMKV_NAMESPACE_END }
+#    define MMKV_NAMESPACE_PREFIX mmkv
+#else
+#    define MMKV_NAMESPACE_BEGIN
+#    define MMKV_NAMESPACE_END
+#    define MMKV_NAMESPACE_PREFIX
+using MMKVLog_t = const std::string &;
+#endif // MMKV_APPLE
+
+MMKV_NAMESPACE_BEGIN
+
+enum MMKVLogLevel : int {
+    MMKVLogDebug = 0, // not available for release/product build
+    MMKVLogInfo = 1,  // default level
+    MMKVLogWarning,
+    MMKVLogError,
+    MMKVLogNone, // special level used to disable all log messages
+};
+
+enum MMKVRecoverStrategic : int {
+    OnErrorDiscard = 0,
+    OnErrorRecover,
+};
+
+enum MMKVErrorType : int {
+    MMKVCRCCheckFail = 0,
+    MMKVFileLength,
+};
+
+enum SyncFlag : bool { MMKV_SYNC = true, MMKV_ASYNC = false };
+
+MMKV_NAMESPACE_END
+
+namespace mmkv {
+
+typedef void (*LogHandler)(MMKVLogLevel level, const char *file, int line, const char *function, MMKVLog_t message);
+
+// by default MMKV will discard all datas on failure
+// return `OnErrorRecover` to recover any data from file
+typedef MMKVRecoverStrategic (*ErrorHandler)(const std::string &mmapID, MMKVErrorType errorType);
+
+// called when content is changed by other process
+// doesn't guarantee real-time notification
+typedef void (*ContentChangeHandler)(const std::string &mmapID);
+
+
+extern MMKV_EXPORT size_t DEFAULT_MMAP_SIZE;
+#define DEFAULT_MMAP_ID "mmkv.default"
+
+class MMBuffer;
+struct KeyValueHolder;
+
+#ifdef MMKV_DISABLE_CRYPT
+using KeyValueHolderCrypt = KeyValueHolder;
+#else
+struct KeyValueHolderCrypt;
+#endif
+
+#ifdef MMKV_APPLE
+
+#ifdef __OBJC__
+struct HybridStringCP {
+    NSString *str;
+    HybridStringCP(std::string_view cpp);
+    ~HybridStringCP();
+};
+
+struct HybridString {
+    NSString *str;
+    HybridString(std::string_view cpp);
+    ~HybridString();
+};
+
+struct KeyHasher {
+    // enables heterogeneous lookup
+    using is_transparent = void;
+    size_t operator()(NSString *key) const { return key.hash; }
+};
+
+struct KeyEqualer {
+    // enables heterogeneous lookup
+    using is_transparent = void;
+    bool operator()(NSString *left, NSString *right) const {
+        if (left == right) {
+            return true;
+        }
+        return ([left isEqualToString:right] == YES);
+    }
+};
+using MMKVVector = std::vector<std::pair<NSString *, mmkv::MMBuffer>>;
+using MMKVMap = std::unordered_map<NSString *, mmkv::KeyValueHolder, KeyHasher, KeyEqualer>;
+using MMKVMapCrypt = std::unordered_map<NSString *, mmkv::KeyValueHolderCrypt, KeyHasher, KeyEqualer>;
+#else // type erase for pure C++ users
+using MMKVVector = std::vector<std::pair<void *, mmkv::MMBuffer>>;
+using MMKVMap = std::unordered_map<void *, mmkv::KeyValueHolder>;
+using MMKVMapCrypt = std::unordered_map<void *, mmkv::KeyValueHolderCrypt>;
+#endif // __OBJC__
+
+#else // !MMKV_APPLE
+
+struct KeyHasher {
+    // enables heterogeneous lookup
+    using is_transparent = void;
+
+    std::size_t operator()(const std::string_view& str) const {
+        return std::hash<std::string_view>{}(str);
+    }
+
+    std::size_t operator()(const std::string& str) const {
+        return std::hash<std::string>{}(str);
+    }
+};
+
+struct KeyEqualer {
+    // enables heterogeneous lookup
+    using is_transparent = void;
+
+    bool operator()(const std::string_view& lhs, const std::string_view& rhs) const {
+        return lhs == rhs;
+    }
+
+    bool operator()(const std::string& lhs, const std::string& rhs) const {
+        return lhs == rhs;
+    }
+};
+using MMKVVector = std::vector<std::pair<std::string, mmkv::MMBuffer>>;
+using MMKVMap = std::unordered_map<std::string, mmkv::KeyValueHolder, KeyHasher, KeyEqualer>;
+using MMKVMapCrypt = std::unordered_map<std::string, mmkv::KeyValueHolderCrypt, KeyHasher, KeyEqualer>;
+#endif // MMKV_APPLE
+
+template <typename T>
+void unused(const T &) {}
+
+constexpr size_t AES_KEY_LEN = 16;
+constexpr size_t AES_KEY_BITSET_LEN = 128;
+constexpr size_t AES_IV_LEN = 16;
+constexpr size_t AES256_KEY_LEN = 32;
+constexpr size_t AES256_KEY_BITSET_LEN = 256;
+
+} // namespace mmkv
+
+#ifdef MMKV_DEBUG
+#    include <cassert>
+#    define MMKV_ASSERT(var) assert(var)
+#else
+#    define MMKV_ASSERT(var) mmkv::unused(var)
+#endif
+
+#endif //cplus-plus
+
+#ifndef MMKV_WIN32
+#    ifndef likely
+#        define mmkv_unlikely(x) (__builtin_expect(bool(x), 0))
+#        define mmkv_likely(x) (__builtin_expect(bool(x), 1))
+#    endif
+#else
+#    ifndef likely
+#        define mmkv_unlikely(x) (x)
+#        define mmkv_likely(x) (x)
+#    endif
+#endif
+
+#if defined(__x86_64__) || defined(_M_X64)
+  #define MMKV_ABI "x86_64"
+#elif defined(__aarch64__) || defined(_M_ARM64)
+  #define MMKV_ABI "arm64-v8a"
+#else
+  #define MMKV_ABI "unknow"
+//  #error "Unsupported arch."
+#endif
+
+#endif //MMKV_SRC_MMKVPREDEF_H

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Core/MMKV_Android.cpp

@@ -0,0 +1,365 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2019 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.
+ */
+
+#include "MMKV.h"
+// #include <bits/alltypes.h>
+
+#ifdef MMKV_ANDROID
+
+#    include "InterProcessLock.h"
+#    include "KeyValueHolder.h"
+#    include "MMKVLog.h"
+#    include "MMKVMetaInfo.hpp"
+#    include "MemoryFile.h"
+#    include "ScopedLock.hpp"
+#    include "ThreadLock.h"
+#    include <unistd.h>
+#    include "MMKV_IO.h"
+
+using namespace std;
+using namespace mmkv;
+
+extern unordered_map<string, MMKV *> *g_instanceDic;
+extern ThreadLock *g_instanceLock;
+
+#ifndef MMKV_OHOS
+static bool g_enableProcessModeCheck = false;
+#endif
+
+MMKV::MMKV(const string &mmapID, int size, MMKVMode mode, const string *cryptKey, const string *rootPath, size_t expectedCapacity, bool aes256)
+    : m_mmapID(mmapID)
+    , m_mode(mode)
+    , m_path(mappedKVPathWithID(m_mmapID, rootPath, mode))
+    , m_crcPath(crcPathWithPath(m_path))
+    , m_dic(nullptr)
+    , m_dicCrypt(nullptr)
+    , m_expectedCapacity(std::max<size_t>(DEFAULT_MMAP_SIZE, roundUp<size_t>(expectedCapacity, DEFAULT_MMAP_SIZE)))
+    , m_file(new MemoryFile(m_path, size, isAshmem() ? MMFILE_TYPE_ASHMEM : MMFILE_TYPE_FILE, m_expectedCapacity, isReadOnly(), !isAshmem()))
+    , m_metaFile(new MemoryFile(m_crcPath, DEFAULT_MMAP_SIZE, m_file->m_fileType, 0, isReadOnly()))
+    , m_metaInfo(new MMKVMetaInfo())
+    , m_crypter(nullptr)
+    , m_lock(new ThreadLock())
+    , m_fileLock(new FileLock(m_metaFile->getFd(), isAshmem(), 0, 1))
+    , m_sharedProcessLock(new InterProcessLock(m_fileLock, SharedLockType))
+    , m_exclusiveProcessLock(new InterProcessLock(m_fileLock, ExclusiveLockType)) {
+    m_actualSize = 0;
+    m_output = nullptr;
+
+#ifndef MMKV_OHOS
+    if (g_enableProcessModeCheck) {
+        // force use fcntl(), otherwise will conflict with MemoryFile::reloadFromFile()
+        m_fileModeLock = new FileLock(m_metaFile->getFd(), true, 1, 2);
+        m_sharedProcessModeLock = new InterProcessLock(m_fileModeLock, SharedLockType);
+    } else {
+        m_fileModeLock = nullptr;
+        m_sharedProcessModeLock = nullptr;
+    }
+    m_exclusiveProcessModeLock = nullptr;
+#endif
+
+    m_fileMigrationLock = new FileLock(m_metaFile->getFd(), true, 2, 3);
+    m_sharedMigrationLock = new InterProcessLock(m_fileMigrationLock, SharedLockType);
+    m_sharedMigrationLock->try_lock();
+
+#    ifndef MMKV_DISABLE_CRYPT
+    if (cryptKey && cryptKey->length() > 0) {
+        m_dicCrypt = new MMKVMapCrypt();
+        m_crypter = new AESCrypt(cryptKey->data(), cryptKey->length(), nullptr, 0, aes256);
+    } else
+#    endif
+    {
+        m_dic = new MMKVMap();
+    }
+
+    m_needLoadFromFile = true;
+    m_hasFullWriteback = false;
+
+    m_crcDigest = 0;
+
+    m_sharedProcessLock->m_enable = isMultiProcess();
+    m_exclusiveProcessLock->m_enable = isMultiProcess();
+
+    // sensitive zone
+    /*{
+        SCOPED_LOCK(m_sharedProcessLock);
+        loadFromFile();
+    }*/
+}
+
+MMKV::MMKV(const string &mmapID, int ashmemFD, int ashmemMetaFD, const string *cryptKey, bool aes256)
+    : m_mmapID(mmapID)
+    , m_mode(MMKV_ASHMEM)
+    , m_path(mappedKVPathWithID(m_mmapID, nullptr, MMKV_ASHMEM))
+    , m_crcPath(crcPathWithPath(m_path))
+    , m_dic(nullptr)
+    , m_dicCrypt(nullptr)
+    , m_expectedCapacity(DEFAULT_MMAP_SIZE)
+    , m_file(new MemoryFile(ashmemFD))
+    , m_metaFile(new MemoryFile(ashmemMetaFD))
+    , m_metaInfo(new MMKVMetaInfo())
+    , m_crypter(nullptr)
+    , m_lock(new ThreadLock())
+    , m_fileLock(new FileLock(m_metaFile->getFd(), true, 0, 1))
+    , m_sharedProcessLock(new InterProcessLock(m_fileLock, SharedLockType))
+    , m_exclusiveProcessLock(new InterProcessLock(m_fileLock, ExclusiveLockType)) {
+
+    m_actualSize = 0;
+    m_output = nullptr;
+
+#ifndef MMKV_OHOS
+    if (g_enableProcessModeCheck) {
+        // force use fcntl(), otherwise will conflict with MemoryFile::reloadFromFile()
+        m_fileModeLock = new FileLock(m_metaFile->getFd(), true, 1, 2);
+        m_sharedProcessModeLock = new InterProcessLock(m_fileModeLock, SharedLockType);
+    } else {
+        m_fileModeLock = nullptr;
+        m_sharedProcessModeLock = nullptr;
+    }
+    m_exclusiveProcessModeLock = nullptr;
+#endif
+
+    m_fileMigrationLock = new FileLock(m_metaFile->getFd(), true, 2, 3);
+    m_sharedMigrationLock = new InterProcessLock(m_fileMigrationLock, SharedLockType);
+    m_sharedMigrationLock->try_lock();
+
+#    ifndef MMKV_DISABLE_CRYPT
+    if (cryptKey && cryptKey->length() > 0) {
+        m_dicCrypt = new MMKVMapCrypt();
+        m_crypter = new AESCrypt(cryptKey->data(), cryptKey->length(), nullptr, 0, aes256);
+    } else
+#    endif
+    {
+        m_dic = new MMKVMap();
+    }
+
+    m_needLoadFromFile = true;
+    m_hasFullWriteback = false;
+
+    m_crcDigest = 0;
+
+    m_sharedProcessLock->m_enable = true;
+    m_exclusiveProcessLock->m_enable = true;
+
+    // sensitive zone
+    /*{
+        SCOPED_LOCK(m_sharedProcessLock);
+        loadFromFile();
+    }*/
+}
+
+// historically Android mistakenly use mmapKey as mmapID, we try migrate back to normal when possible
+MigrateStatus tryMigrateLegacyMMKVFile(const string &mmapID, const string *rootPath) {
+    auto legacyID = legacyMmapedKVKey(mmapID, rootPath);
+    if (legacyID == mmapID) {
+        // it's not specially encoded
+        return MigrateStatus::NotSpecial;
+    }
+    auto path = mappedKVPathWithID(legacyID, rootPath);
+    auto targetPath = mappedKVPathWithID(mmapID, rootPath);
+    bool oldExit = isFileExist(path);
+    bool newExist = isFileExist(targetPath);
+    if (oldExit) {
+        if (newExist) {
+            MMKVWarning("both legacy file [%s] modify: %lld ms, and new file [%s] modify: %lld ms exist",
+                        path.c_str(), getFileModifyTimeInMS(path.c_str()),
+                        targetPath.c_str(), getFileModifyTimeInMS(targetPath.c_str()));
+            return MigrateStatus::OldAndNewExist;
+        }
+        auto file = File(path, OpenFlag::ReadWrite);
+        if (file.isFileValid()) {
+            // check if it's opened by other process
+            auto fileMigrationLock = FileLock(file.getFd(), true, 2, 3);
+            auto exclusiveMigrationLock = InterProcessLock(&fileMigrationLock, ExclusiveLockType);
+            // works even if it's opened by us
+            if (exclusiveMigrationLock.try_lock()) {
+                if (tryAtomicRename(path, targetPath)) {
+                    if (tryAtomicRename(crcPathWithPath(path), crcPathWithPath(targetPath))) {
+                        MMKVInfo("Migrated legacy MMKV [%s] to [%s] in path %s", legacyID.c_str(), mmapID.c_str(), rootPath->c_str());
+                        return MigrateStatus::OldToNewMigrated;
+                    }
+                }
+            } else {
+                MMKVInfo("Can't migrate legacy MMKV [%s] to [%s] in path %s, try next time.", legacyID.c_str(), mmapID.c_str(), rootPath->c_str());
+            }
+        }
+        return MigrateStatus::OldToNewMigrateFail;
+    }
+    return newExist ? MigrateStatus::NewExist : MigrateStatus::NoneExist;
+}
+
+MMKV *MMKV::mmkvWithID(const string &mmapID, int size, MMKVMode mode, const string *cryptKey, const string *rootPath, size_t expectedCapacity, bool aes256) {
+    if (mmapID.empty() || !g_instanceLock) {
+        return nullptr;
+    }
+    SCOPED_LOCK(g_instanceLock);
+
+    auto mmapKey = mmapedKVKey(mmapID, rootPath);
+    auto itr = g_instanceDic->find(mmapKey);
+    if (itr != g_instanceDic->end()) {
+        MMKV *kv = itr->second;
+        return kv;
+    }
+    if (rootPath) {
+        if (!isFileExist(*rootPath)) {
+            MMKVPath_t specialPath = (*rootPath) + MMKV_PATH_SLASH + SPECIAL_CHARACTER_DIRECTORY_NAME;
+            if (!isFileExist(specialPath)) {
+                mkPath(specialPath);
+            }
+        }
+        MMKVInfo("prepare to load %s (id %s) from rootPath %s", mmapID.c_str(), mmapKey.c_str(), rootPath->c_str());
+    }
+
+    MMKV *kv = nullptr;
+    auto migrateStatus = (mode & MMKV_ASHMEM) ? MigrateStatus::NoneExist : tryMigrateLegacyMMKVFile(mmapID, rootPath);
+    switch (migrateStatus) {
+        case MigrateStatus::NotSpecial:
+        case MigrateStatus::NoneExist:
+        case MigrateStatus::NewExist:
+        case MigrateStatus::OldToNewMigrated:
+        case MigrateStatus::OldAndNewExist: // TODO: shell we compare and use the latest one?
+            kv = new MMKV(mmapID, size, mode, cryptKey, rootPath, expectedCapacity);
+            break;
+        case MigrateStatus::OldToNewMigrateFail: {
+            auto legacyID = legacyMmapedKVKey(mmapID, rootPath);
+            kv = new MMKV(legacyID, size, mode, cryptKey, rootPath, expectedCapacity, aes256);
+            break;
+        }
+    }
+    kv->m_mmapKey = mmapKey;
+
+    (*g_instanceDic)[mmapKey] = kv;
+    return kv;
+}
+
+MMKV *MMKV::mmkvWithAshmemFD(const string &mmapID, int fd, int metaFD, const string *cryptKey, bool aes256) {
+
+    if (fd < 0 || !g_instanceLock) {
+        return nullptr;
+    }
+    SCOPED_LOCK(g_instanceLock);
+
+    auto itr = g_instanceDic->find(mmapID);
+    if (itr != g_instanceDic->end()) {
+        MMKV *kv = itr->second;
+#    ifndef MMKV_DISABLE_CRYPT
+        kv->checkReSetCryptKey(fd, metaFD, cryptKey, aes256);
+#    endif
+        return kv;
+    }
+    auto kv = new MMKV(mmapID, fd, metaFD, cryptKey, aes256);
+    kv->m_mmapKey = mmapID;
+    (*g_instanceDic)[mmapID] = kv;
+    return kv;
+}
+
+int MMKV::ashmemFD() {
+    return (m_file->m_fileType & mmkv::MMFILE_TYPE_ASHMEM) ? m_file->getFd() : -1;
+}
+
+int MMKV::ashmemMetaFD() {
+    return (m_file->m_fileType & mmkv::MMFILE_TYPE_ASHMEM) ? m_metaFile->getFd() : -1;
+}
+
+#    ifndef MMKV_DISABLE_CRYPT
+void MMKV::checkReSetCryptKey(int fd, int metaFD, const string *cryptKey, bool aes256) {
+    SCOPED_LOCK(m_lock);
+
+    checkReSetCryptKey(cryptKey, aes256);
+
+    if (m_file->m_fileType & MMFILE_TYPE_ASHMEM) {
+        if (m_file->getFd() != fd) {
+            ::close(fd);
+        }
+        if (m_metaFile->getFd() != metaFD) {
+            ::close(metaFD);
+        }
+    }
+}
+#    endif // MMKV_DISABLE_CRYPT
+
+#ifndef MMKV_OHOS
+
+bool MMKV::checkProcessMode() {
+    // avoid exception on open() error
+    if (!m_file->isFileValid()) {
+        return true;
+    }
+    // avoid invalid status
+    if (!g_enableProcessModeCheck || !m_fileModeLock || !m_sharedProcessModeLock) {
+        return true;
+    }
+
+    if (isMultiProcess()) {
+        if (!m_exclusiveProcessModeLock) {
+            m_exclusiveProcessModeLock = new InterProcessLock(m_fileModeLock, ExclusiveLockType);
+        }
+        // avoid multiple processes get shared lock at the same time, https://github.com/Tencent/MMKV/issues/523
+        auto tryAgain = false;
+        auto exclusiveLocked = m_exclusiveProcessModeLock->try_lock(&tryAgain);
+        if (exclusiveLocked) {
+            return true;
+        }
+        auto shareLocked = m_sharedProcessModeLock->try_lock();
+        if (!shareLocked) {
+            // this call will fail on most case, just do it to make sure
+            m_exclusiveProcessModeLock->try_lock();
+            return true;
+        } else {
+            if (!tryAgain) {
+                // something wrong with the OS/filesystem, let's try again
+                exclusiveLocked = m_exclusiveProcessModeLock->try_lock(&tryAgain);
+                if (!exclusiveLocked && !tryAgain) {
+                    // still something wrong, we have to give up and assume it passed the test
+                    MMKVWarning("Got a shared lock, but fail to exclusive lock [%s], assume it's ok", m_mmapID.c_str());
+                    exclusiveLocked = true;
+                }
+            }
+            if (!exclusiveLocked) {
+                MMKVError("Got a shared lock, but fail to exclusive lock [%s]", m_mmapID.c_str());
+            }
+            return exclusiveLocked;
+        }
+    } else {
+        auto tryAgain = false;
+        auto shareLocked = m_sharedProcessModeLock->try_lock(&tryAgain);
+        if (!shareLocked && !tryAgain) {
+            // something wrong with the OS/filesystem, we have to give up and assume it passed the test
+            MMKVWarning("Fail to shared lock [%s], assume it's ok", m_mmapID.c_str());
+            shareLocked = true;
+        }
+        if (!shareLocked) {
+            MMKVError("Fail to share lock [%s]", m_mmapID.c_str());
+        }
+        return shareLocked;
+    }
+}
+
+void MMKV::enableDisableProcessMode(bool enable) {
+    MMKVInfo("process mode check enable/disable: %d", enable);
+    g_enableProcessModeCheck = enable;
+}
+
+#endif // !MMKV_OHOS
+
+MMKV *NameSpace::mmkvWithID(const string &mmapID, int size, MMKVMode mode, const string *cryptKey, size_t expectedCapacity, bool aes256) {
+    return MMKV::mmkvWithID(mmapID, size, mode, cryptKey, &m_rootDir, expectedCapacity, aes256);
+}
+
+#endif // MMKV_ANDROID