react-native-mmkv 3.0.2 → 3.2.0

package/MMKV/Core/MMKV.cpp

@@ -80,20 +80,21 @@ MMKVPath_t filename(const MMKVPath_t &path);
 #ifndef MMKV_ANDROID
 MMKV::MMKV(const string &mmapID, MMKVMode mode, string *cryptKey, MMKVPath_t *rootPath, size_t expectedCapacity)
     : m_mmapID(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, m_expectedCapacity))
-    , m_metaFile(new MemoryFile(m_crcPath))
+    , m_file(new MemoryFile(m_path, m_expectedCapacity, isReadOnly()))
+    , m_metaFile(new MemoryFile(m_crcPath, 0, isReadOnly()))
     , m_metaInfo(new MMKVMetaInfo())
     , m_crypter(nullptr)
     , m_lock(new ThreadLock())
     , m_fileLock(new FileLock(m_metaFile->getFd()))
     , m_sharedProcessLock(new InterProcessLock(m_fileLock, SharedLockType))
     , m_exclusiveProcessLock(new InterProcessLock(m_fileLock, ExclusiveLockType))
-    , m_isInterProcess((mode & MMKV_MULTI_PROCESS) != 0) {
+{
     m_actualSize = 0;
     m_output = nullptr;
 
@@ -114,8 +115,8 @@ MMKV::MMKV(const string &mmapID, MMKVMode mode, string *cryptKey, MMKVPath_t *ro
     m_crcDigest = 0;
 
     m_lock->initialize();
-    m_sharedProcessLock->m_enable = m_isInterProcess;
-    m_exclusiveProcessLock->m_enable = m_isInterProcess;
+    m_sharedProcessLock->m_enable = isMultiProcess();
+    m_exclusiveProcessLock->m_enable = isMultiProcess();
 
     // sensitive zone
     /*{
@@ -219,8 +220,10 @@ void MMKV::initializeMMKV(const MMKVPath_t &rootDir, MMKVLogLevel logLevel, mmkv
 #    endif
 #endif
 
-    g_rootDir = rootDir;
-    mkPath(g_rootDir);
+    if (g_rootDir.empty()) {
+        g_rootDir = rootDir;
+        mkPath(g_rootDir);
+    }
 
     MMKVInfo("root dir: " MMKV_PATH_FORMAT, g_rootDir.c_str());
 }
@@ -232,7 +235,7 @@ const MMKVPath_t &MMKV::getRootDir() {
 #ifndef MMKV_ANDROID
 MMKV *MMKV::mmkvWithID(const string &mmapID, MMKVMode mode, string *cryptKey, MMKVPath_t *rootPath, size_t expectedCapacity) {
 
-    if (mmapID.empty()) {
+    if (mmapID.empty() || !g_instanceLock) {
         return nullptr;
     }
     SCOPED_LOCK(g_instanceLock);
@@ -260,6 +263,9 @@ MMKV *MMKV::mmkvWithID(const string &mmapID, MMKVMode mode, string *cryptKey, MM
 #endif
 
 void MMKV::onExit() {
+    if (!g_instanceLock) {
+        return;
+    }
     SCOPED_LOCK(g_instanceLock);
 
     for (auto &pair : *g_instanceDic) {
@@ -1094,15 +1100,19 @@ size_t MMKV::actualSize() {
     return m_actualSize;
 }
 
-void MMKV::removeValueForKey(MMKVKey_t key) {
+bool MMKV::removeValueForKey(MMKVKey_t key) {
     if (isKeyEmpty(key)) {
-        return;
+        return false;
+    }
+    if (isReadOnly()) {
+        MMKVWarning("[%s] file readonly", m_mmapID.c_str());
+        return false;
     }
     SCOPED_LOCK(m_lock);
     SCOPED_LOCK(m_exclusiveProcessLock);
     checkLoadData();
 
-    removeDataForKey(key);
+    return removeDataForKey(key);
 }
 
 #ifndef MMKV_APPLE
@@ -1129,9 +1139,13 @@ vector<string> MMKV::allKeys(bool filterExpire) {
     return keys;
 }
 
-void MMKV::removeValuesForKeys(const vector<string> &arrKeys) {
+bool MMKV::removeValuesForKeys(const vector<string> &arrKeys) {
+    if (isReadOnly()) {
+        MMKVWarning("[%s] file readonly", m_mmapID.c_str());
+        return false;
+    }
     if (arrKeys.empty()) {
-        return;
+        return true;
     }
     if (arrKeys.size() == 1) {
         return removeValueForKey(arrKeys[0]);
@@ -1162,8 +1176,9 @@ void MMKV::removeValuesForKeys(const vector<string> &arrKeys) {
     if (deleteCount > 0) {
         m_hasFullWriteback = false;
 
-        fullWriteback();
+        return fullWriteback();
     }
+    return true;
 }
 
 #endif // MMKV_APPLE
@@ -1238,6 +1253,9 @@ static bool backupOneToDirectoryByFilePath(const string &mmapKey, const MMKVPath
 }
 
 bool MMKV::backupOneToDirectory(const string &mmapKey, const MMKVPath_t &dstPath, const MMKVPath_t &srcPath, bool compareFullPath) {
+    if (!g_instanceLock) {
+        return false;
+    }
     // we have to lock the creation of MMKV instance, regardless of in cache or not
     SCOPED_LOCK(g_instanceLock);
     MMKV *kv = nullptr;
@@ -1400,6 +1418,9 @@ static bool restoreOneFromDirectoryByFilePath(const string &mmapKey, const MMKVP
 // They won't know a difference when the file has been replaced.
 // We have to let them know by overriding the existing file with new content.
 bool MMKV::restoreOneFromDirectory(const string &mmapKey, const MMKVPath_t &srcPath, const MMKVPath_t &dstPath, bool compareFullPath) {
+    if (!g_instanceLock) {
+        return false;
+    }
     // we have to lock the creation of MMKV instance, regardless of in cache or not
     SCOPED_LOCK(g_instanceLock);
     MMKV *kv = nullptr;
@@ -1447,7 +1468,7 @@ bool MMKV::restoreOneFromDirectory(const string &mmapKey, const MMKVPath_t &srcP
         // reload data after restore
         kv->clearMemoryCache();
         kv->loadFromFile();
-        if (kv->m_isInterProcess) {
+        if (kv->isMultiProcess()) {
             kv->notifyContentChanged();
         }
 
@@ -1534,26 +1555,41 @@ size_t MMKV::restoreAllFromDirectory(const MMKVPath_t &srcDir, const MMKVPath_t
 // callbacks
 
 void MMKV::registerErrorHandler(ErrorHandler handler) {
+    if (!g_instanceLock) {
+        return;
+    }
     SCOPED_LOCK(g_instanceLock);
     g_errorHandler = handler;
 }
 
 void MMKV::unRegisterErrorHandler() {
+    if (!g_instanceLock) {
+        return;
+    }
     SCOPED_LOCK(g_instanceLock);
     g_errorHandler = nullptr;
 }
 
 void MMKV::registerLogHandler(LogHandler handler) {
+    if (!g_instanceLock) {
+        return;
+    }
     SCOPED_LOCK(g_instanceLock);
     g_logHandler = handler;
 }
 
 void MMKV::unRegisterLogHandler() {
+    if (!g_instanceLock) {
+        return;
+    }
     SCOPED_LOCK(g_instanceLock);
     g_logHandler = nullptr;
 }
 
 void MMKV::setLogLevel(MMKVLogLevel level) {
+    if (!g_instanceLock) {
+        return;
+    }
     SCOPED_LOCK(g_instanceLock);
     g_currentLogLevel = level;
 }

package/MMKV/Core/MMKV.h

@@ -58,8 +58,13 @@ enum MMKVMode : uint32_t {
     MMKV_ASHMEM = 1 << 3,
     MMKV_BACKUP = 1 << 4,
 #endif
+    MMKV_READ_ONLY = 1 << 5,
 };
 
+static inline MMKVMode operator | (MMKVMode one, MMKVMode other) {
+    return static_cast<MMKVMode>(static_cast<uint32_t>(one) | static_cast<uint32_t>(other));
+}
+
 #define MMKV_OUT
 
 #ifdef MMKV_HAS_CPP20
@@ -105,6 +110,7 @@ class MMKV {
     ~MMKV();
 
     std::string m_mmapID;
+    const MMKVMode m_mode;
     MMKVPath_t m_path;
     MMKVPath_t m_crcPath;
     mmkv::MMKVMap *m_dic;
@@ -281,8 +287,16 @@ public:
     static void onExit();
 
     const std::string &mmapID() const;
-
-    const bool m_isInterProcess;
+#ifndef MMKV_ANDROID
+    bool isMultiProcess() const { return  (m_mode & MMKV_MULTI_PROCESS) != 0; }
+#else
+    bool isMultiProcess() const {
+        return (m_mode & MMKV_MULTI_PROCESS) != 0
+            || (m_mode & CONTEXT_MODE_MULTI_PROCESS) != 0
+            || (m_mode & MMKV_ASHMEM) != 0; // ashmem is always multi-process
+    }
+#endif
+    bool isReadOnly() const { return (m_mode & MMKV_READ_ONLY) != 0; }
 
 #ifndef MMKV_DISABLE_CRYPT
     std::string cryptKey() const;
@@ -428,7 +442,7 @@ public:
     // filterExpire: return all non-expired keys, keep in mind it comes with cost
     NSArray *allKeys(bool filterExpire = false);
 
-    void removeValuesForKeys(NSArray *arrKeys);
+    bool removeValuesForKeys(NSArray *arrKeys);
 
     typedef void (^EnumerateBlock)(NSString *key, BOOL *stop);
     void enumerateKeys(EnumerateBlock block);
@@ -441,10 +455,10 @@ public:
     // filterExpire: return all non-expired keys, keep in mind it comes with cost
     std::vector<std::string> allKeys(bool filterExpire = false);
 
-    void removeValuesForKeys(const std::vector<std::string> &arrKeys);
+    bool removeValuesForKeys(const std::vector<std::string> &arrKeys);
 #endif // MMKV_APPLE
 
-    void removeValueForKey(MMKVKey_t key);
+    bool removeValueForKey(MMKVKey_t key);
 
     // keepSpace: remove all keys but keep the file size not changed, running faster
     void clearAll(bool keepSpace = false);

package/MMKV/Core/MMKVPredef.h

@@ -22,7 +22,7 @@
 #define MMKV_SRC_MMKVPREDEF_H
 
 // disable encryption & decryption to reduce some code
-//#define MMKV_DISABLE_CRYPT
+// #define MMKV_DISABLE_CRYPT
 //#define MMKV_DISABLE_FLUTTER
 
 // using POSIX implementation
@@ -34,7 +34,7 @@
 #include <vector>
 #include <unordered_map>
 
-constexpr auto MMKV_VERSION = "v1.3.9";
+constexpr auto MMKV_VERSION = "v2.0.0";
 
 #ifdef DEBUG
 #    define MMKV_DEBUG

package/MMKV/Core/MMKV_Android.cpp

@@ -41,20 +41,20 @@ 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))
-    , m_metaFile(new MemoryFile(m_crcPath, DEFAULT_MMAP_SIZE, m_file->m_fileType))
+    , 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_isInterProcess((mode & MMKV_MULTI_PROCESS) != 0 || (mode & CONTEXT_MODE_MULTI_PROCESS) != 0) {
+    , m_exclusiveProcessLock(new InterProcessLock(m_fileLock, ExclusiveLockType)) {
     m_actualSize = 0;
     m_output = nullptr;
 
@@ -78,8 +78,8 @@ MMKV::MMKV(const string &mmapID, int size, MMKVMode mode, string *cryptKey, stri
 
     m_crcDigest = 0;
 
-    m_sharedProcessLock->m_enable = m_isInterProcess;
-    m_exclusiveProcessLock->m_enable = m_isInterProcess;
+    m_sharedProcessLock->m_enable = isMultiProcess();
+    m_exclusiveProcessLock->m_enable = isMultiProcess();
 
     // sensitive zone
     /*{
@@ -90,6 +90,7 @@ MMKV::MMKV(const string &mmapID, int size, MMKVMode mode, string *cryptKey, stri
 
 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)
@@ -101,8 +102,7 @@ MMKV::MMKV(const string &mmapID, int ashmemFD, int ashmemMetaFD, string *cryptKe
     , 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_isInterProcess(true) {
+    , m_exclusiveProcessLock(new InterProcessLock(m_fileLock, ExclusiveLockType)) {
 
     m_actualSize = 0;
     m_output = nullptr;
@@ -127,8 +127,8 @@ MMKV::MMKV(const string &mmapID, int ashmemFD, int ashmemMetaFD, string *cryptKe
 
     m_crcDigest = 0;
 
-    m_sharedProcessLock->m_enable = m_isInterProcess;
-    m_exclusiveProcessLock->m_enable = m_isInterProcess;
+    m_sharedProcessLock->m_enable = true;
+    m_exclusiveProcessLock->m_enable = true;
 
     // sensitive zone
     /*{
@@ -138,7 +138,7 @@ MMKV::MMKV(const string &mmapID, int ashmemFD, int ashmemMetaFD, string *cryptKe
 }
 
 MMKV *MMKV::mmkvWithID(const string &mmapID, int size, MMKVMode mode, string *cryptKey, string *rootPath, size_t expectedCapacity) {
-    if (mmapID.empty()) {
+    if (mmapID.empty() || !g_instanceLock) {
         return nullptr;
     }
     SCOPED_LOCK(g_instanceLock);
@@ -164,7 +164,7 @@ MMKV *MMKV::mmkvWithID(const string &mmapID, int size, MMKVMode mode, string *cr
 
 MMKV *MMKV::mmkvWithAshmemFD(const string &mmapID, int fd, int metaFD, string *cryptKey) {
 
-    if (fd < 0) {
+    if (fd < 0 || !g_instanceLock) {
         return nullptr;
     }
     SCOPED_LOCK(g_instanceLock);
@@ -213,7 +213,7 @@ bool MMKV::checkProcessMode() {
         return true;
     }
 
-    if (m_isInterProcess) {
+    if (isMultiProcess()) {
         if (!m_exclusiveProcessModeLock) {
             m_exclusiveProcessModeLock = new InterProcessLock(m_fileModeLock, ExclusiveLockType);
         }

package/MMKV/Core/MMKV_IO.cpp

@@ -81,7 +81,7 @@ void MMKV::loadFromFile() {
         checkDataValid(loadFromFile, needFullWriteback);
         MMKVInfo("loading [%s] with %zu actual size, file size %zu, InterProcess %d, meta info "
                  "version:%u",
-                 m_mmapID.c_str(), m_actualSize, m_file->getFileSize(), m_isInterProcess, m_metaInfo->m_version);
+                 m_mmapID.c_str(), m_actualSize, m_file->getFileSize(), isMultiProcess(), m_metaInfo->m_version);
         auto ptr = (uint8_t *) m_file->getMemory();
         // loading
         if (loadFromFile && m_actualSize > 0) {
@@ -131,6 +131,10 @@ void MMKV::loadFromFile() {
         }
         auto count = m_crypter ? m_dicCrypt->size() : m_dic->size();
         MMKVInfo("loaded [%s] with %zu key-values", m_mmapID.c_str(), count);
+//        auto keys = allKeys();
+//        for (size_t index = 0; index < count; index++) {
+//            MMKVInfo("key[%llu]: %s", index, keys[index].c_str());
+//        }
     }
 
     m_needLoadFromFile = false;
@@ -303,7 +307,7 @@ void MMKV::checkLoadData() {
         loadFromFile();
         return;
     }
-    if (!m_isInterProcess) {
+    if (!isMultiProcess()) {
         return;
     }
 
@@ -397,6 +401,10 @@ bool MMKV::ensureMemorySize(size_t newSize) {
         MMKVWarning("[%s] file not valid", m_mmapID.c_str());
         return false;
     }
+    if (isReadOnly()) {
+        MMKVWarning("[%s] file readonly", m_mmapID.c_str());
+        return false;
+    }
 
     if (newSize >= m_output->spaceLeft() || (m_crypter ? m_dicCrypt->empty() : m_dic->empty())) {
         // remove expired keys
@@ -590,7 +598,7 @@ bool MMKV::setDataForKey(MMBuffer &&data, MMKVKey_t key, bool isDataHolder) {
         }
         auto itr = m_dicCrypt->find(key);
         if (itr != m_dicCrypt->end()) {
-            bool onlyOneKey = !m_isInterProcess && m_dicCrypt->size() == 1;
+            bool onlyOneKey = !isMultiProcess() && m_dicCrypt->size() == 1;
 #    ifdef MMKV_APPLE
             KVHolderRet_t ret;
             if (onlyOneKey) {
@@ -629,7 +637,7 @@ bool MMKV::setDataForKey(MMBuffer &&data, MMKVKey_t key, bool isDataHolder) {
                 }
             }
         } else {
-            bool needOverride = !m_isInterProcess && m_dicCrypt->empty() && m_actualSize > 0;
+            bool needOverride = !isMultiProcess() && m_dicCrypt->empty() && m_actualSize > 0;
             KVHolderRet_t ret;
             if (needOverride) {
                 ret = overrideDataWithKey(data, key, isDataHolder);
@@ -681,7 +689,7 @@ bool MMKV::setDataForKey(MMBuffer &&data, MMKVKey_t key, bool isDataHolder) {
                 }
             }
 
-            bool onlyOneKey = !m_isInterProcess && m_dic->size() == 1;
+            bool onlyOneKey = !isMultiProcess() && m_dic->size() == 1;
             if (mmkv_likely(!m_enableKeyExpire)) {
                 KVHolderRet_t ret;
                 if (onlyOneKey) {
@@ -713,7 +721,7 @@ bool MMKV::setDataForKey(MMBuffer &&data, MMKVKey_t key, bool isDataHolder) {
                 }
             }
         } else {
-            bool needOverride = !m_isInterProcess && m_dic->empty() && m_actualSize > 0;
+            bool needOverride = !isMultiProcess() && m_dic->empty() && m_actualSize > 0;
             KVHolderRet_t ret;
             if (needOverride) {
                 ret = overrideDataWithKey(data, key, isDataHolder);
@@ -1338,6 +1346,10 @@ bool MMKV::reKey(const string &cryptKey) {
         MMKVWarning("[%s] file not valid", m_mmapID.c_str());
         return false;
     }
+    if (isReadOnly()) {
+        MMKVWarning("[%s] file readonly", m_mmapID.c_str());
+        return false;
+    }
 
     bool ret = false;
     if (m_crypter) {
@@ -1408,6 +1420,10 @@ void MMKV::trim() {
         MMKVWarning("[%s] file not valid", m_mmapID.c_str());
         return;
     }
+    if (isReadOnly()) {
+        MMKVWarning("[%s] file readonly", m_mmapID.c_str());
+        return;
+    }
 
     if (m_actualSize == 0) {
         clearAll();
@@ -1452,6 +1468,10 @@ void MMKV::clearAll(bool keepSpace) {
         MMKVWarning("[%s] file not valid", m_mmapID.c_str());
         return;
     }
+    if (isReadOnly()) {
+        MMKVWarning("[%s] file readonly", m_mmapID.c_str());
+        return;
+    }
 
     if (m_file->getFileSize() == m_expectedCapacity && m_actualSize == 0) {
         MMKVInfo("nothing to clear for [%s]", m_mmapID.c_str());
@@ -1524,6 +1544,9 @@ bool MMKV::isFileValid(const string &mmapID, MMKVPath_t *relatePath) {
 }
 
 bool MMKV::removeStorage(const std::string &mmapID, MMKVPath_t *relatePath) {
+    if (!g_instanceLock) {
+        return false;
+    }
     auto mmapKey = mmapedKVKey(mmapID, relatePath);
 #ifdef MMKV_ANDROID
     auto &realID = mmapKey; // historically Android mistakenly use mmapKey as mmapID
@@ -1625,6 +1648,10 @@ bool MMKV::enableAutoKeyExpire(uint32_t expiredInSeconds) {
     if (m_metaInfo->hasFlag(MMKVMetaInfo::EnableKeyExipre)) {
         return true;
     }
+    if (isReadOnly()) {
+        MMKVWarning("[%s] file readonly", m_mmapID.c_str());
+        return false;
+    }
 
     auto autoRecordExpireTime = (m_expiredInSeconds != 0);
     auto time = autoRecordExpireTime ? getCurrentTimeInSecond() + m_expiredInSeconds : 0;
@@ -1685,6 +1712,10 @@ bool MMKV::disableAutoKeyExpire() {
     if (!m_metaInfo->hasFlag(MMKVMetaInfo::EnableKeyExipre)) {
         return true;
     }
+    if (isReadOnly()) {
+        MMKVWarning("[%s] file readonly", m_mmapID.c_str());
+        return false;
+    }
 
     MMKVInfo("erase previous recorded expire date for all keys inside [%s]", m_mmapID.c_str());
     m_metaInfo->unsetFlag(MMKVMetaInfo::EnableKeyExipre);

package/MMKV/Core/MMKV_OSX.cpp

@@ -42,7 +42,7 @@
 #    endif
 
 #    ifdef __aarch64__
-#        include "Checksum.h"
+#        include "crc32/Checksum.h"
 #    endif
 
 #    if __has_feature(objc_arc)
@@ -94,6 +94,9 @@ bool MLockPtr::isMLockPtrEnabled = true;
 static bool g_isInBackground = false;
 
 void MMKV::setIsInBackground(bool isInBackground) {
+    if (!g_instanceLock) {
+        return;
+    }
     SCOPED_LOCK(g_instanceLock);
 
     g_isInBackground = isInBackground;
@@ -101,6 +104,9 @@ void MMKV::setIsInBackground(bool isInBackground) {
 }
 
 bool MMKV::isInBackground() {
+    if (!g_instanceLock) {
+        return true;
+    }
     SCOPED_LOCK(g_instanceLock);
 
     return g_isInBackground;
@@ -300,9 +306,13 @@ NSArray *MMKV::allKeys(bool filterExpire) {
     return keys;
 }
 
-void MMKV::removeValuesForKeys(NSArray *arrKeys) {
+bool MMKV::removeValuesForKeys(NSArray *arrKeys) {
+    if (isReadOnly()) {
+        MMKVWarning("[%s] file readonly", m_mmapID.c_str());
+        return false;
+    }
     if (arrKeys.count == 0) {
-        return;
+        return true;
     }
     if (arrKeys.count == 1) {
         return removeValueForKey(arrKeys[0]);
@@ -337,8 +347,9 @@ void MMKV::removeValuesForKeys(NSArray *arrKeys) {
     if (deleteCount > 0) {
         m_hasFullWriteback = false;
 
-        fullWriteback();
+        return fullWriteback();
     }
+    return true;
 }
 
 void MMKV::enumerateKeys(EnumerateBlock block) {

package/MMKV/Core/MemoryFile.cpp

@@ -50,7 +50,10 @@ File::File(MMKVPath_t path, OpenFlag flag) : m_path(std::move(path)), m_fd(-1),
     open();
 }
 
-MemoryFile::MemoryFile(MMKVPath_t path, size_t expectedCapacity) : m_diskFile(std::move(path), OpenFlag::ReadWrite | OpenFlag::Create), m_ptr(nullptr), m_size(0) {
+MemoryFile::MemoryFile(MMKVPath_t path, size_t expectedCapacity, bool readOnly)
+    : m_diskFile(std::move(path), readOnly ? OpenFlag::ReadOnly : (OpenFlag::ReadWrite | OpenFlag::Create))
+    , m_ptr(nullptr), m_size(0), m_readOnly(readOnly)
+{
     reloadFromFile(expectedCapacity);
 }
 #    endif // !defined(MMKV_ANDROID)
@@ -61,7 +64,7 @@ void tryResetFileProtection(const string &path);
 
 static int OpenFlag2NativeFlag(OpenFlag flag) {
     int native = O_CLOEXEC;
-    if (flag & OpenFlag::ReadWrite) {
+    if ((flag & OpenFlagRWMask) == OpenFlag::ReadWrite) {
         native |= O_RDWR;
     } else if (flag & OpenFlag::ReadOnly) {
         native |= O_RDONLY;
@@ -92,10 +95,10 @@ bool File::open() {
     }
     m_fd = ::open(m_path.c_str(), OpenFlag2NativeFlag(m_flag), S_IRWXU);
     if (!isFileValid()) {
-        MMKVError("fail to open [%s], %d(%s)", m_path.c_str(), errno, strerror(errno));
+        MMKVError("fail to open [%s], flag %x, %d(%s)", m_path.c_str(), m_flag, errno, strerror(errno));
         return false;
     }
-    MMKVInfo("open fd[%p], %s", m_fd, m_path.c_str());
+    MMKVInfo("open fd[%p], flag %x, %s", m_fd, m_flag, m_path.c_str());
     return true;
 }
 
@@ -128,6 +131,10 @@ bool MemoryFile::truncate(size_t size) {
     if (size == m_size) {
         return true;
     }
+    if (m_readOnly) {
+        // truncate readonly file not allow
+        return false;
+    }
 #    ifdef MMKV_ANDROID
     if (m_diskFile.m_fileType == MMFILE_TYPE_ASHMEM) {
         if (size > m_size) {
@@ -182,6 +189,10 @@ bool MemoryFile::truncate(size_t size) {
 }
 
 bool MemoryFile::msync(SyncFlag syncFlag) {
+    if (m_readOnly) {
+        // there's no point in msync() readonly memory
+        return true;
+    }
     if (m_ptr) {
         auto ret = ::msync(m_ptr, m_size, syncFlag ? MS_SYNC : MS_ASYNC);
         if (ret == 0) {
@@ -194,9 +205,10 @@ bool MemoryFile::msync(SyncFlag syncFlag) {
 
 bool MemoryFile::mmap() {
     auto oldPtr = m_ptr;
-    m_ptr = (char *) ::mmap(m_ptr, m_size, PROT_READ | PROT_WRITE, MAP_SHARED, m_diskFile.m_fd, 0);
+    auto mode = m_readOnly ? PROT_READ : (PROT_READ | PROT_WRITE);
+    m_ptr = (char *) ::mmap(m_ptr, m_size, mode, MAP_SHARED, m_diskFile.m_fd, 0);
     if (m_ptr == MAP_FAILED) {
-        MMKVError("fail to mmap [%s], %s", m_diskFile.m_path.c_str(), strerror(errno));
+        MMKVError("fail to mmap [%s], mode %x, %s", m_diskFile.m_path.c_str(), mode, strerror(errno));
         m_ptr = nullptr;
         return false;
     }
@@ -226,7 +238,7 @@ void MemoryFile::reloadFromFile(size_t expectedCapacity) {
         mmkv::getFileSize(m_diskFile.m_fd, m_size);
         size_t expectedSize = std::max<size_t>(DEFAULT_MMAP_SIZE, roundUp<size_t>(expectedCapacity, DEFAULT_MMAP_SIZE));
         // round up to (n * pagesize)
-        if (m_size < expectedSize || (m_size % DEFAULT_MMAP_SIZE != 0)) {
+        if (!m_readOnly && (m_size < expectedSize || (m_size % DEFAULT_MMAP_SIZE != 0))) {
             InterProcessLock exclusiveLock(&fileLock, ExclusiveLockType);
             SCOPED_LOCK(&exclusiveLock);
 
@@ -240,7 +252,9 @@ void MemoryFile::reloadFromFile(size_t expectedCapacity) {
             }
         }
 #    ifdef MMKV_IOS
-        tryResetFileProtection(m_diskFile.m_path);
+        if (!m_readOnly) {
+            tryResetFileProtection(m_diskFile.m_path);
+        }
 #    endif
     }
 }
@@ -556,7 +570,7 @@ void walkInDir(const MMKVPath_t &dirPath, WalkType type, const function<void(con
 
     while (auto child = readdir(dir)) {
         if ((child->d_type & DT_REG) && (type & WalkFile)) {
-#ifdef _DIRENT_HAVE_D_NAMLEN
+#if defined(_DIRENT_HAVE_D_NAMLEN) || defined(__APPLE__)
             stpcpy(childPath + folderPathLength, child->d_name);
             childPath[folderPathLength + child->d_namlen] = 0;
 #else
@@ -564,7 +578,7 @@ void walkInDir(const MMKVPath_t &dirPath, WalkType type, const function<void(con
 #endif
             walker(childPath, WalkFile);
         } else if ((child->d_type & DT_DIR) && (type & WalkFolder)) {
-#ifdef _DIRENT_HAVE_D_NAMLEN
+#if defined(_DIRENT_HAVE_D_NAMLEN) || defined(__APPLE__)
             if ((child->d_namlen == 1 && child->d_name[0] == '.') ||
                 (child->d_namlen == 2 && child->d_name[0] == '.' && child->d_name[1] == '.')) {
                 continue;