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

package/MMKV/Core/MMKVPredef.h

@@ -0,0 +1,293 @@
+/*
+ * 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.0.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;
+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;
+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_APPLE
+#    import <Foundation/Foundation.h>
+#    define MMKV_NAMESPACE_BEGIN namespace mmkv {
+#    define MMKV_NAMESPACE_END }
+#    define MMKV_NAMESPACE_PREFIX mmkv
+using MMKVLog_t = NSString *;
+#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 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
+struct KeyHasher {
+    size_t operator()(NSString *key) const { return key.hash; }
+};
+
+struct KeyEqualer {
+    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
+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;
+
+} // 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(__arm__)
+  #if defined(__ARM_ARCH_7A__)
+    #if defined(__ARM_NEON__)
+      #if defined(__ARM_PCS_VFP)
+        #define MMKV_ABI "armeabi-v7a/NEON (hard-float)"
+      #else
+        #define MMKV_ABI "armeabi-v7a/NEON"
+      #endif
+    #else
+      #if defined(__ARM_PCS_VFP)
+        #define MMKV_ABI "armeabi-v7a (hard-float)"
+      #else
+        #define MMKV_ABI "armeabi-v7a"
+      #endif
+    #endif
+  #else
+   #define MMKV_ABI "armeabi"
+  #endif
+#elif defined(__i386__) || defined(_M_IX86)
+  #define MMKV_ABI "x86"
+#elif defined(__x86_64__) || defined(_M_X64)
+  #define MMKV_ABI "x86_64"
+#elif defined(__mips64)
+  #define MMKV_ABI "mips64"
+#elif defined(__mips__)
+  #define MMKV_ABI "mips"
+#elif defined(__aarch64__) || defined(_M_ARM64)
+  #define MMKV_ABI "arm64-v8a"
+#else
+  #define MMKV_ABI "unknown"
+#endif
+
+#endif //MMKV_SRC_MMKVPREDEF_H

package/MMKV/Core/MMKV_Android.cpp

@@ -0,0 +1,261 @@
+/*
+ * 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;
+
+MMKV::MMKV(const string &mmapID, int size, MMKVMode mode, string *cryptKey, string *rootPath, size_t expectedCapacity)
+    : m_mmapID((mode & MMKV_BACKUP) ? mmapID : mmapedKVKey(mmapID, rootPath)) // historically Android mistakenly use mmapKey as mmapID
+    , m_mode(mode)
+    , m_path(mappedKVPathWithID(m_mmapID, mode, rootPath))
+    , m_crcPath(crcPathWithID(m_mmapID, mode, rootPath))
+    , 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, (mode & MMKV_ASHMEM) ? MMFILE_TYPE_ASHMEM : MMFILE_TYPE_FILE, m_expectedCapacity, isReadOnly()))
+    , 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(), (mode & MMKV_ASHMEM)))
+    , m_sharedProcessLock(new InterProcessLock(m_fileLock, SharedLockType))
+    , m_exclusiveProcessLock(new InterProcessLock(m_fileLock, ExclusiveLockType)) {
+    m_actualSize = 0;
+    m_output = nullptr;
+
+    // force use fcntl(), otherwise will conflict with MemoryFile::reloadFromFile()
+    m_fileModeLock = new FileLock(m_file->getFd(), true);
+    m_sharedProcessModeLock = new InterProcessLock(m_fileModeLock, SharedLockType);
+    m_exclusiveProcessModeLock = nullptr;
+
+#    ifndef MMKV_DISABLE_CRYPT
+    if (cryptKey && cryptKey->length() > 0) {
+        m_dicCrypt = new MMKVMapCrypt();
+        m_crypter = new AESCrypt(cryptKey->data(), cryptKey->length());
+    } 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, string *cryptKey)
+    : m_mmapID(mmapID)
+    , m_mode(MMKV_ASHMEM)
+    , m_path(mappedKVPathWithID(m_mmapID, MMKV_ASHMEM, nullptr))
+    , m_crcPath(crcPathWithID(m_mmapID, MMKV_ASHMEM, nullptr))
+    , m_dic(nullptr)
+    , m_dicCrypt(nullptr)
+    , 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))
+    , m_sharedProcessLock(new InterProcessLock(m_fileLock, SharedLockType))
+    , m_exclusiveProcessLock(new InterProcessLock(m_fileLock, ExclusiveLockType)) {
+
+    m_actualSize = 0;
+    m_output = nullptr;
+
+    // force use fcntl(), otherwise will conflict with MemoryFile::reloadFromFile()
+    m_fileModeLock = new FileLock(m_file->getFd(), true);
+    m_sharedProcessModeLock = new InterProcessLock(m_fileModeLock, SharedLockType);
+    m_exclusiveProcessModeLock = nullptr;
+
+#    ifndef MMKV_DISABLE_CRYPT
+    if (cryptKey && cryptKey->length() > 0) {
+        m_dicCrypt = new MMKVMapCrypt();
+        m_crypter = new AESCrypt(cryptKey->data(), cryptKey->length());
+    } 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();
+    }*/
+}
+
+MMKV *MMKV::mmkvWithID(const string &mmapID, int size, MMKVMode mode, string *cryptKey, string *rootPath, size_t expectedCapacity) {
+    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)) {
+            if (!mkPath(*rootPath)) {
+                return nullptr;
+            }
+        }
+        MMKVInfo("prepare to load %s (id %s) from rootPath %zu", mmapID.c_str(), mmapKey.c_str(), rootPath->c_str());
+    }
+    auto kv = new MMKV(mmapID, size, mode, cryptKey, rootPath, expectedCapacity);
+    (*g_instanceDic)[mmapKey] = kv;
+    return kv;
+}
+
+MMKV *MMKV::mmkvWithAshmemFD(const string &mmapID, int fd, int metaFD, string *cryptKey) {
+
+    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);
+#    endif
+        return kv;
+    }
+    auto kv = new MMKV(mmapID, fd, metaFD, cryptKey);
+    (*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, string *cryptKey) {
+    SCOPED_LOCK(m_lock);
+
+    checkReSetCryptKey(cryptKey);
+
+    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
+
+bool MMKV::checkProcessMode() {
+    // avoid exception on open() error
+    if (!m_file->isFileValid()) {
+        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;
+    }
+}
+
+#endif // MMKV_ANDROID