react-native-mmkv 2.10.2 → 2.12.0

package/MMKV/Core/CodedInputData.cpp

@@ -21,6 +21,7 @@
 #include "CodedInputData.h"
 #include "PBUtility.h"
 #include <stdexcept>
+#include <cstring>
 
 #ifdef MMKV_APPLE
 #    if __has_feature(objc_arc)
@@ -100,6 +101,22 @@ string CodedInputData::readString() {
     }
 }
 
+void CodedInputData::readString(string &s) {
+    int32_t size = readRawVarint32();
+    if (size < 0) {
+        throw length_error("InvalidProtocolBuffer negativeSize");
+    }
+
+    auto s_size = static_cast<size_t>(size);
+    if (s_size <= m_size - m_position) {
+        s.resize(s_size);
+        memcpy((void *) s.data(), (char *) (m_ptr + m_position), s_size);
+        m_position += s_size;
+    } else {
+        throw out_of_range("InvalidProtocolBuffer truncatedMessage");
+    }
+}
+
 string CodedInputData::readString(KeyValueHolder &kvHolder) {
     kvHolder.offset = static_cast<uint32_t>(m_position);
 
@@ -123,17 +140,24 @@ string CodedInputData::readString(KeyValueHolder &kvHolder) {
 
 #endif
 
-MMBuffer CodedInputData::readData() {
+MMBuffer CodedInputData::readRealData(mmkv::MMBuffer & data) {
+    CodedInputData input(data.getPtr(), data.length());
+    return input.readData(false, true);
+}
+
+MMBuffer CodedInputData::readData(bool copy, bool exactly) {
     int32_t size = this->readRawVarint32();
     if (size < 0) {
         throw length_error("InvalidProtocolBuffer negativeSize");
     }
 
     auto s_size = static_cast<size_t>(size);
-    if (s_size <= m_size - m_position) {
-        MMBuffer data(((int8_t *) m_ptr) + m_position, s_size);
+    bool isSizeValid = exactly ? (s_size == m_size - m_position) : (s_size <= m_size - m_position);
+    if (isSizeValid) {
+        size_t pos = m_position;
         m_position += s_size;
-        return data;
+        auto copyFlag = copy ? MMBufferCopy : MMBufferNoCopy;
+        return MMBuffer(((int8_t *) m_ptr) + pos, s_size, copyFlag);
     } else {
         throw out_of_range("InvalidProtocolBuffer truncatedMessage");
     }

package/MMKV/Core/CodedInputData.h

@@ -64,11 +64,15 @@ public:
 
     uint32_t readUInt32();
 
-    MMBuffer readData();
+    // exactly is like getValueSize(actualSize = true)
+    MMBuffer readData(bool copy = true, bool exactly = false);
     void readData(KeyValueHolder &kvHolder);
 
+    static MMBuffer readRealData(mmkv::MMBuffer & data);
+
 #ifndef MMKV_APPLE
     std::string readString();
+    void readString(std::string &s);
     std::string readString(KeyValueHolder &kvHolder);
 #else
     NSString *readString();

package/MMKV/Core/CodedOutputData.cpp

@@ -109,6 +109,18 @@ void CodedOutputData::seek(size_t addedSize) {
     }
 }
 
+void CodedOutputData::reset() {
+    m_position = 0;
+}
+
+size_t CodedOutputData::getPosition() {
+    return m_position;
+}
+
+void CodedOutputData::setPosition(size_t position) {
+    m_position = position;
+}
+
 void CodedOutputData::writeRawByte(uint8_t value) {
     if (m_position == m_size) {
         throw out_of_range("m_position: " + to_string(m_position) + " m_size: " + to_string(m_size));

package/MMKV/Core/CodedOutputData.h

@@ -43,6 +43,12 @@ public:
 
     void seek(size_t addedSize);
 
+    void reset();
+
+    size_t getPosition();
+
+    void setPosition(size_t position);
+
     void writeRawByte(uint8_t value);
 
     void writeRawLittleEndian32(int32_t value);

package/MMKV/Core/MMBuffer.cpp

@@ -84,6 +84,13 @@ MMBuffer::MMBuffer(void *source, size_t length, MMBufferCopyFlag flag) : isNoCop
     }
 }
 
+bool MMBuffer::operator==(const MMBuffer& other) const {
+    if (this->length() != other.length()) {
+        return false;
+    }
+    return !memcmp((uint8_t*)this->getPtr(), (uint8_t*)other.getPtr(), this->length());
+}
+
 #ifdef MMKV_APPLE
 MMBuffer::MMBuffer(NSData *data, MMBufferCopyFlag flag)
     : type(MMBufferType_Normal), ptr((void *) data.bytes), size(data.length), isNoCopy(flag) {

package/MMKV/Core/MMBuffer.h

@@ -91,6 +91,9 @@ public:
     // transfer ownership to others
     void detach();
 
+    // compare two MMBuffer
+    bool operator==(const MMBuffer& other) const;
+
     // those are expensive, just forbid it for possibly misuse
     explicit MMBuffer(const MMBuffer &other) = delete;
     MMBuffer &operator=(const MMBuffer &other) = delete;

package/MMKV/Core/MMKV.cpp

@@ -26,6 +26,7 @@
 #include "MMKVLog.h"
 #include "MMKVMetaInfo.hpp"
 #include "MMKV_IO.h"
+#include "MMKV_OSX.h"
 #include "MemoryFile.h"
 #include "MiniPBCoder.h"
 #include "PBUtility.h"
@@ -51,6 +52,7 @@
 #    if __has_feature(objc_arc)
 #        error This file must be compiled with MRC. Use -fno-objc-arc flag.
 #    endif
+#    include "MMKV_OSX.h"
 #endif // MMKV_APPLE
 
 using namespace std;
@@ -77,13 +79,14 @@ bool endsWith(const MMKVPath_t &str, const MMKVPath_t &suffix);
 MMKVPath_t filename(const MMKVPath_t &path);
 
 #ifndef MMKV_ANDROID
-MMKV::MMKV(const string &mmapID, MMKVMode mode, string *cryptKey, MMKVPath_t *rootPath)
+MMKV::MMKV(const string &mmapID, MMKVMode mode, string *cryptKey, MMKVPath_t *rootPath, size_t expectedCapacity)
     : m_mmapID(mmapID)
     , m_path(mappedKVPathWithID(m_mmapID, mode, rootPath))
     , m_crcPath(crcPathWithID(m_mmapID, mode, rootPath))
     , m_dic(nullptr)
     , m_dicCrypt(nullptr)
-    , m_file(new MemoryFile(m_path))
+    , 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_metaInfo(new MMKVMetaInfo())
     , m_crypter(nullptr)
@@ -116,10 +119,10 @@ MMKV::MMKV(const string &mmapID, MMKVMode mode, string *cryptKey, MMKVPath_t *ro
     m_exclusiveProcessLock->m_enable = m_isInterProcess;
 
     // sensitive zone
-    {
+    /*{
         SCOPED_LOCK(m_sharedProcessLock);
         loadFromFile();
-    }
+    }*/
 }
 #endif
 
@@ -193,7 +196,7 @@ void initialize() {
 #endif
 }
 
-ThreadOnceToken_t once_control = ThreadOnceUninitialized;
+static ThreadOnceToken_t once_control = ThreadOnceUninitialized;
 
 void MMKV::initializeMMKV(const MMKVPath_t &rootDir, MMKVLogLevel logLevel, mmkv::LogHandler handler) {
     g_currentLogLevel = logLevel;
@@ -201,6 +204,22 @@ void MMKV::initializeMMKV(const MMKVPath_t &rootDir, MMKVLogLevel logLevel, mmkv
 
     ThreadLock::ThreadOnce(&once_control, initialize);
 
+#ifdef MMKV_APPLE
+    // crc32 instruction requires A10 chip, aka iPhone 7 or iPad 6th generation
+    int device = 0, version = 0;
+    GetAppleMachineInfo(device, version);
+#    ifndef MMKV_IOS
+    MMKVInfo("Apple Device: %d, version: %d", device, version);
+#    else
+    // we have verified that on iOS 13+, the mlock() protection in background is no longer needed
+    // this may be true as well on iOS 12 or even iOS 11, sadly we can't verify that on WeChat
+    if (@available(iOS 13, *)) {
+        MLockPtr::isMLockPtrEnabled = false;
+    }
+    MMKVInfo("Apple Device: %d, version: %d, mlock enabled: %d", device, version, MLockPtr::isMLockPtrEnabled);
+#    endif
+#endif
+
     g_rootDir = rootDir;
     mkPath(g_rootDir);
 
@@ -212,7 +231,7 @@ const MMKVPath_t &MMKV::getRootDir() {
 }
 
 #ifndef MMKV_ANDROID
-MMKV *MMKV::mmkvWithID(const string &mmapID, MMKVMode mode, string *cryptKey, MMKVPath_t *rootPath) {
+MMKV *MMKV::mmkvWithID(const string &mmapID, MMKVMode mode, string *cryptKey, MMKVPath_t *rootPath, size_t expectedCapacity) {
 
     if (mmapID.empty()) {
         return nullptr;
@@ -234,7 +253,7 @@ MMKV *MMKV::mmkvWithID(const string &mmapID, MMKVMode mode, string *cryptKey, MM
         MMKVInfo("prepare to load %s (id %s) from rootPath %s", mmapID.c_str(), mmapKey.c_str(), rootPath->c_str());
     }
 
-    auto kv = new MMKV(mmapID, mode, cryptKey, rootPath);
+    auto kv = new MMKV(mmapID, mode, cryptKey, rootPath, expectedCapacity);
     kv->m_mmapKey = mmapKey;
     (*g_instanceDic)[mmapKey] = kv;
     return kv;
@@ -281,7 +300,7 @@ void MMKV::unRegisterContentChangeHandler() {
     g_contentChangeHandler = nullptr;
 }
 
-void MMKV::clearMemoryCache() {
+void MMKV::clearMemoryCache(bool keepSpace) {
     SCOPED_LOCK(m_lock);
     if (m_needLoadFromFile) {
         return;
@@ -305,8 +324,11 @@ void MMKV::clearMemoryCache() {
     delete m_output;
     m_output = nullptr;
 
-    m_file->clearMemoryCache();
-    m_metaFile->clearMemoryCache();
+    if (!keepSpace) {
+        m_file->clearMemoryCache();
+    }
+    // inter-process lock rely on MetaFile's fd, never close it
+    // m_metaFile->clearMemoryCache();
     m_actualSize = 0;
     m_metaInfo->m_crcDigest = 0;
 }
@@ -407,6 +429,15 @@ void MMKV::recaculateCRCDigestWithIV(const void *iv) {
     }
 }
 
+void MMKV::recaculateCRCDigestOnly() {
+    auto ptr = (const uint8_t *) m_file->getMemory();
+    if (ptr) {
+        m_crcDigest = 0;
+        m_crcDigest = (uint32_t) CRC32(0, ptr + Fixed32Size, (uint32_t) m_actualSize);
+        writeActualSize(m_actualSize, m_crcDigest, nullptr, KeepSequence);
+    }
+}
+
 void MMKV::updateCRCDigest(const uint8_t *ptr, size_t length) {
     if (ptr == nullptr) {
         return;
@@ -663,7 +694,7 @@ bool MMKV::set(const vector<string> &v, MMKVKey_t key, uint32_t expireDuration)
     auto data = MiniPBCoder::encodeDataWithObject(v);
     if (unlikely(m_enableKeyExpire) && data.length() > 0) {
         auto tmp = MMBuffer(data.length() + Fixed32Size);
-        auto ptr = (uint8_t *)tmp.getPtr();
+        auto ptr = (uint8_t *) tmp.getPtr();
         memcpy(ptr, data.getPtr(), data.length());
         auto time = (expireDuration != ExpireNever) ? getCurrentTimeInSecond() + expireDuration : ExpireNever;
         memcpy(ptr + data.length(), &time, Fixed32Size);
@@ -672,7 +703,7 @@ bool MMKV::set(const vector<string> &v, MMKVKey_t key, uint32_t expireDuration)
     return setDataForKey(std::move(data), key);
 }
 
-bool MMKV::getString(MMKVKey_t key, string &result) {
+bool MMKV::getString(MMKVKey_t key, string &result, bool inplaceModification) {
     if (isKeyEmpty(key)) {
         return false;
     }
@@ -682,10 +713,16 @@ bool MMKV::getString(MMKVKey_t key, string &result) {
     if (data.length() > 0) {
         try {
             CodedInputData input(data.getPtr(), data.length());
-            result = input.readString();
+            if (inplaceModification) {
+                input.readString(result);
+            } else {
+                result = input.readString();
+            }
             return true;
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("decode fail");
         }
     }
     return false;
@@ -701,10 +738,12 @@ bool MMKV::getBytes(MMKVKey_t key, mmkv::MMBuffer &result) {
     if (data.length() > 0) {
         try {
             CodedInputData input(data.getPtr(), data.length());
-            result = std::move(input.readData());
+            result = input.readData();
             return true;
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("decode fail");
         }
     }
     return false;
@@ -723,6 +762,8 @@ MMBuffer MMKV::getBytes(MMKVKey_t key) {
             return input.readData();
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("decode fail");
         }
     }
     return MMBuffer();
@@ -741,6 +782,8 @@ bool MMKV::getVector(MMKVKey_t key, vector<string> &result) {
             return true;
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("decode fail");
         }
     }
     return false;
@@ -767,6 +810,8 @@ bool MMKV::getBool(MMKVKey_t key, bool defaultValue, bool *hasValue) {
             return input.readBool();
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("decode fail");
         }
     }
     if (hasValue != nullptr) {
@@ -794,6 +839,8 @@ int32_t MMKV::getInt32(MMKVKey_t key, int32_t defaultValue, bool *hasValue) {
             return input.readInt32();
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("decode fail");
         }
     }
     if (hasValue != nullptr) {
@@ -821,6 +868,8 @@ uint32_t MMKV::getUInt32(MMKVKey_t key, uint32_t defaultValue, bool *hasValue) {
             return input.readUInt32();
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("decode fail");
         }
     }
     if (hasValue != nullptr) {
@@ -848,6 +897,8 @@ int64_t MMKV::getInt64(MMKVKey_t key, int64_t defaultValue, bool *hasValue) {
             return input.readInt64();
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("decode fail");
         }
     }
     if (hasValue != nullptr) {
@@ -875,6 +926,8 @@ uint64_t MMKV::getUInt64(MMKVKey_t key, uint64_t defaultValue, bool *hasValue) {
             return input.readUInt64();
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("decode fail");
         }
     }
     if (hasValue != nullptr) {
@@ -902,6 +955,8 @@ float MMKV::getFloat(MMKVKey_t key, float defaultValue, bool *hasValue) {
             return input.readFloat();
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("decode fail");
         }
     }
     if (hasValue != nullptr) {
@@ -929,6 +984,8 @@ double MMKV::getDouble(MMKVKey_t key, double defaultValue, bool *hasValue) {
             return input.readDouble();
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("decode fail");
         }
     }
     if (hasValue != nullptr) {
@@ -956,6 +1013,8 @@ size_t MMKV::getValueSize(MMKVKey_t key, bool actualSize) {
             }
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("decode fail");
         }
     }
     return data.length();
@@ -990,6 +1049,8 @@ int32_t MMKV::writeValueToBuffer(MMKVKey_t key, void *ptr, int32_t size) {
         }
     } catch (std::exception &exception) {
         MMKVError("%s", exception.what());
+    } catch (...) {
+        MMKVError("encode fail");
     }
     return -1;
 }
@@ -1011,9 +1072,15 @@ bool MMKV::containsKey(MMKVKey_t key) {
     return raw.length() != 0;
 }
 
-size_t MMKV::count() {
+size_t MMKV::count(bool filterExpire) {
     SCOPED_LOCK(m_lock);
     checkLoadData();
+
+    if (unlikely(filterExpire && m_enableKeyExpire)) {
+        SCOPED_LOCK(m_exclusiveProcessLock);
+        fullWriteback(nullptr, true);
+    }
+
     if (m_crypter) {
         return m_dicCrypt->size();
     } else {
@@ -1046,10 +1113,15 @@ void MMKV::removeValueForKey(MMKVKey_t key) {
 
 #ifndef MMKV_APPLE
 
-vector<string> MMKV::allKeys() {
+vector<string> MMKV::allKeys(bool filterExpire) {
     SCOPED_LOCK(m_lock);
     checkLoadData();
 
+    if (unlikely(filterExpire && m_enableKeyExpire)) {
+        SCOPED_LOCK(m_exclusiveProcessLock);
+        fullWriteback(nullptr, true);
+    }
+
     vector<string> keys;
     if (m_crypter) {
         for (const auto &itr : *m_dicCrypt) {
@@ -1105,6 +1177,7 @@ void MMKV::removeValuesForKeys(const vector<string> &arrKeys) {
 // file
 
 void MMKV::sync(SyncFlag flag) {
+    MMKVInfo("MMKV::sync, SyncFlag = %d", flag);
     SCOPED_LOCK(m_lock);
     if (m_needLoadFromFile || !isFileValid()) {
         return;
@@ -1128,6 +1201,18 @@ bool MMKV::try_lock() {
     return m_exclusiveProcessLock->try_lock();
 }
 
+#ifndef MMKV_WIN32
+void MMKV::lock_thread() {
+    m_lock->lock();
+}
+void MMKV::unlock_thread() {
+    m_lock->unlock();
+}
+bool MMKV::try_lock_thread() {
+    return m_lock->try_lock();
+}
+#endif
+
 // backup
 
 static bool backupOneToDirectoryByFilePath(const string &mmapKey, const MMKVPath_t &srcPath, const MMKVPath_t &dstPath) {
@@ -1351,7 +1436,17 @@ bool MMKV::restoreOneFromDirectory(const string &mmapKey, const MMKVPath_t &srcP
         auto ret = copyFileContent(srcPath, kv->m_file->getFd());
         if (ret) {
             auto srcCRCPath = srcPath + CRC_SUFFIX;
-            ret = copyFileContent(srcCRCPath, kv->m_metaFile->getFd());
+            // ret = copyFileContent(srcCRCPath, kv->m_metaFile->getFd());
+#ifndef MMKV_ANDROID
+            MemoryFile srcCRCFile(srcCRCPath);
+#else
+            MemoryFile srcCRCFile(srcCRCPath, DEFAULT_MMAP_SIZE, MMFILE_TYPE_FILE);
+#endif
+            if (srcCRCFile.isFileValid()) {
+                memcpy(kv->m_metaFile->getMemory(), srcCRCFile.getMemory(), sizeof(MMKVMetaInfo));
+            } else {
+                ret = false;
+            }
         }
 
         // reload data after restore
@@ -1496,8 +1591,8 @@ static MMKVPath_t encodeFilePath(const string &mmapID) {
         }
     }
     if (hasSpecialCharacter) {
-        static ThreadOnceToken_t once_control = ThreadOnceUninitialized;
-        ThreadLock::ThreadOnce(&once_control, mkSpecialCharacterFileDirectory);
+        static ThreadOnceToken_t once = ThreadOnceUninitialized;
+        ThreadLock::ThreadOnce(&once, mkSpecialCharacterFileDirectory);
         return MMKVPath_t(SPECIAL_CHARACTER_DIRECTORY_NAME) + MMKV_PATH_SLASH + string2MMKVPath_t(encodedID);
     } else {
         return string2MMKVPath_t(mmapID);