react-native-mmkv 3.0.0-beta.6 → 3.0.0-beta.8

package/MMKV/Core/MMKVPredef.h

@@ -34,7 +34,7 @@
 #include <vector>
 #include <unordered_map>
 
-constexpr auto MMKV_VERSION = "v1.3.5";
+constexpr auto MMKV_VERSION = "v1.3.9";
 
 #ifdef DEBUG
 #    define MMKV_DEBUG
@@ -44,6 +44,10 @@ constexpr auto MMKV_VERSION = "v1.3.5";
 #    undef MMKV_DEBUG
 #endif
 
+#if __cplusplus>=202002L
+#    define MMKV_HAS_CPP20
+#endif
+
 #ifdef __ANDROID__
 #    ifdef FORCE_POSIX
 #        define MMKV_POSIX
@@ -195,9 +199,34 @@ 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>;
-using MMKVMapCrypt = std::unordered_map<std::string, mmkv::KeyValueHolderCrypt>;
+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>
@@ -217,6 +246,18 @@ constexpr size_t AES_KEY_BITSET_LEN = 128;
 
 #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__)

package/MMKV/Core/MMKV_IO.cpp

@@ -338,7 +338,6 @@ void MMKV::checkLoadData() {
     }
 }
 
-constexpr uint32_t ItemSizeHolder = 0x00ffffff;
 constexpr uint32_t ItemSizeHolderSize = 4;
 
 static pair<MMBuffer, size_t> prepareEncode(const MMKVMap &dic) {
@@ -496,7 +495,7 @@ bool MMKV::writeActualSize(size_t size, uint32_t crcDigest, const void *iv, bool
         needsFullWrite = true;
     }
 #ifndef MMKV_DISABLE_CRYPT
-    if (unlikely(iv)) {
+    if (mmkv_unlikely(iv)) {
         memcpy(m_metaInfo->m_vector, iv, sizeof(m_metaInfo->m_vector));
         if (m_metaInfo->m_version < MMKVVersionRandomIV) {
             m_metaInfo->m_version = MMKVVersionRandomIV;
@@ -504,7 +503,7 @@ bool MMKV::writeActualSize(size_t size, uint32_t crcDigest, const void *iv, bool
         needsFullWrite = true;
     }
 #endif
-    if (unlikely(increaseSequence)) {
+    if (mmkv_unlikely(increaseSequence)) {
         m_metaInfo->m_sequence++;
         m_metaInfo->m_lastConfirmedMetaInfo.lastActualSize = static_cast<uint32_t>(size);
         m_metaInfo->m_lastConfirmedMetaInfo.lastCRCDigest = crcDigest;
@@ -526,7 +525,7 @@ bool MMKV::writeActualSize(size_t size, uint32_t crcDigest, const void *iv, bool
         return false;
     }
 #endif
-    if (unlikely(needsFullWrite)) {
+    if (mmkv_unlikely(needsFullWrite)) {
         m_metaInfo->write(m_metaFile->getMemory());
     } else {
         m_metaInfo->writeCRCAndActualSizeOnly(m_metaFile->getMemory());
@@ -557,7 +556,7 @@ MMBuffer MMKV::getRawDataForKey(MMKVKey_t key) {
 }
 
 mmkv::MMBuffer MMKV::getDataForKey(MMKVKey_t key) {
-    if (unlikely(m_enableKeyExpire)) {
+    if (mmkv_unlikely(m_enableKeyExpire)) {
         return getDataWithoutMTimeForKey(key);
     }
     return getRawDataForKey(key);
@@ -617,7 +616,7 @@ bool MMKV::setDataForKey(MMBuffer &&data, MMKVKey_t key, bool isDataHolder) {
             } else {
                 kvHolder = KeyValueHolderCrypt(std::move(data));
             }
-            if (likely(!m_enableKeyExpire)) {
+            if (mmkv_likely(!m_enableKeyExpire)) {
                 itr->second = std::move(kvHolder);
             } else {
                 itr = m_dicCrypt->find(key);
@@ -670,9 +669,9 @@ bool MMKV::setDataForKey(MMBuffer &&data, MMKVKey_t key, bool isDataHolder) {
                             return true;
                         }
                     } catch (std::exception &exception) {
-                        MMKVError("compareBeforeSet exception: %s", exception.what());
+                        MMKVWarning("compareBeforeSet exception: %s", exception.what());
                     } catch (...) {
-                        MMKVError("compareBeforeSet fail");
+                        MMKVWarning("compareBeforeSet fail");
                     }
                 } else {
                     if (oldValueData == data) {
@@ -683,7 +682,7 @@ bool MMKV::setDataForKey(MMBuffer &&data, MMKVKey_t key, bool isDataHolder) {
             }
 
             bool onlyOneKey = !m_isInterProcess && m_dic->size() == 1;
-            if (likely(!m_enableKeyExpire)) {
+            if (mmkv_likely(!m_enableKeyExpire)) {
                 KVHolderRet_t ret;
                 if (onlyOneKey) {
                     ret = overrideDataWithKey(data, itr->second, isDataHolder);
@@ -732,6 +731,14 @@ bool MMKV::setDataForKey(MMBuffer &&data, MMKVKey_t key, bool isDataHolder) {
     return true;
 }
 
+template <typename T>
+static void eraseHelper(T& container, std::string_view key) {
+    auto itr = container.find(key);
+    if (itr != container.end()) {
+        container.erase(itr);
+    }
+}
+
 bool MMKV::removeDataForKey(MMKVKey_t key) {
     if (isKeyEmpty(key)) {
         return false;
@@ -745,7 +752,7 @@ bool MMKV::removeDataForKey(MMKVKey_t key) {
 #    ifdef MMKV_APPLE
             auto ret = appendDataWithKey(nan, key, itr->second);
             if (ret.first) {
-                if (unlikely(m_enableKeyExpire)) {
+                if (mmkv_unlikely(m_enableKeyExpire)) {
                     // filterExpiredKeys() may invalid itr
                     itr = m_dicCrypt->find(key);
                     if (itr == m_dicCrypt->end()) {
@@ -759,8 +766,8 @@ bool MMKV::removeDataForKey(MMKVKey_t key) {
 #    else
             auto ret = appendDataWithKey(nan, key);
             if (ret.first) {
-                if (unlikely(m_enableKeyExpire)) {
-                    m_dicCrypt->erase(key);
+                if (mmkv_unlikely(m_enableKeyExpire)) {
+                    eraseHelper(*m_dicCrypt, key);
                 } else {
                     m_dicCrypt->erase(itr);
                 }
@@ -775,10 +782,10 @@ bool MMKV::removeDataForKey(MMKVKey_t key) {
         if (itr != m_dic->end()) {
             m_hasFullWriteback = false;
             static MMBuffer nan;
-            auto ret = likely(!m_enableKeyExpire) ? appendDataWithKey(nan, itr->second) : appendDataWithKey(nan, key);
+            auto ret = mmkv_likely(!m_enableKeyExpire) ? appendDataWithKey(nan, itr->second) : appendDataWithKey(nan, key);
             if (ret.first) {
 #ifdef MMKV_APPLE
-                if (unlikely(m_enableKeyExpire)) {
+                if (mmkv_unlikely(m_enableKeyExpire)) {
                     // filterExpiredKeys() may invalid itr
                     itr = m_dic->find(key);
                     if (itr == m_dic->end()) {
@@ -789,9 +796,9 @@ bool MMKV::removeDataForKey(MMKVKey_t key) {
                 m_dic->erase(itr);
                 [oldKey release];
 #else
-                if (unlikely(m_enableKeyExpire)) {
+                if (mmkv_unlikely(m_enableKeyExpire)) {
                     // filterExpiredKeys() may invalid itr
-                    m_dic->erase(key);
+                    eraseHelper(*m_dic, key);
                 } else {
                     m_dic->erase(itr);
                 }
@@ -903,17 +910,22 @@ KVHolderRet_t MMKV::doOverrideDataWithKey(const MMBuffer &data,
         } else {
             m_crypter->resetIV();
         }
-        if (KeyValueHolderCrypt::isValueStoredAsOffset(valueLength)) {
-            m_crypter->getCurStatus(t_status);
-        }
     }
 #endif
     try {
         // write ItemSizeHolder
         m_output->setPosition(0);
-        m_output->writeRawVarint32(ItemSizeHolder);
+        m_output->writeUInt32(AESCrypt::randomItemSizeHolder(ItemSizeHolderSize));
         m_actualSize = ItemSizeHolderSize;
-
+#ifndef MMKV_DISABLE_CRYPT
+        if (m_crypter) {
+            auto ptr = (uint8_t *) m_file->getMemory() + Fixed32Size;
+            m_crypter->encrypt(ptr, ptr, m_actualSize);
+            if (KeyValueHolderCrypt::isValueStoredAsOffset(valueLength)) {
+                m_crypter->getCurStatus(t_status);
+            }
+        }
+#endif
         if (isKeyEncoded) {
             m_output->writeRawData(keyData);
         } else {
@@ -933,13 +945,13 @@ KVHolderRet_t MMKV::doOverrideDataWithKey(const MMBuffer &data,
 
     auto offset = static_cast<uint32_t>(m_actualSize);
     m_actualSize += size;
-    auto ptr = (uint8_t *) m_file->getMemory() + Fixed32Size;
 #ifndef MMKV_DISABLE_CRYPT
     if (m_crypter) {
-        m_crypter->encrypt(ptr, ptr, m_actualSize);
+        auto ptr = (uint8_t *) m_file->getMemory() + Fixed32Size + offset;
+        m_crypter->encrypt(ptr, ptr, size);
     }
 #endif
-    recaculateCRCDigestOnly();
+    recalculateCRCDigestOnly();
 
     return make_pair(true, KeyValueHolder(originKeyLength, valueLength, offset));
 }
@@ -1044,7 +1056,7 @@ bool MMKV::fullWriteback(AESCrypt *newCrypter, bool onlyWhileExpire) {
         return false;
     }
 
-    if (unlikely(m_enableKeyExpire)) {
+    if (mmkv_unlikely(m_enableKeyExpire)) {
         auto expiredCount = filterExpiredKeys();
         if (onlyWhileExpire && expiredCount == 0) {
             return true;
@@ -1120,7 +1132,7 @@ memmoveDictionary(MMKVMap &dic, CodedOutputData *output, uint8_t *ptr, AESCrypt
         }
     }
     // hold the fake size of dictionary's serialization result
-    output->writeRawVarint32(ItemSizeHolder);
+    output->writeUInt32(AESCrypt::randomItemSizeHolder(ItemSizeHolderSize));
     auto writtenSize = static_cast<size_t>(writePtr - originOutputPtr);
 #ifndef MMKV_DISABLE_CRYPT
     if (encrypter) {
@@ -1151,14 +1163,16 @@ static void memmoveDictionary(MMKVMapCrypt &dic,
         }
         sort(vec.begin(), vec.end(), [](auto left, auto right) { return left->offset < right->offset; });
     }
-    auto sizeHolder = ItemSizeHolder, sizeHolderSize = ItemSizeHolderSize;
+    auto sizeHolderSize = ItemSizeHolderSize;
+    auto sizeHolder = AESCrypt::randomItemSizeHolder(sizeHolderSize);
     if (!vec.empty()) {
         auto smallestOffset = vec.front()->offset;
         if (smallestOffset != ItemSizeHolderSize && smallestOffset <= 5) {
             sizeHolderSize = smallestOffset;
             assert(sizeHolderSize != 0);
             static const uint32_t ItemSizeHolders[] = {0, 0x0f, 0xff, 0xffff, 0xffffff, 0xffffffff};
-            sizeHolder = ItemSizeHolders[sizeHolderSize];
+            sizeHolder = AESCrypt::randomItemSizeHolder(sizeHolderSize);
+            assert(sizeHolder >= ItemSizeHolders[sizeHolderSize] && sizeHolder <= ItemSizeHolders[sizeHolderSize]);
         }
     }
     output->writeRawVarint32(static_cast<int32_t>(sizeHolder));
@@ -1222,7 +1236,7 @@ static void memmoveDictionary(MMKVMapCrypt &dic,
 
 static void fullWriteBackWholeData(MMBuffer allData, size_t totalSize, CodedOutputData *output) {
     auto originOutputPtr = output->curWritePointer();
-    output->writeRawVarint32(ItemSizeHolder);
+    output->writeUInt32(AESCrypt::randomItemSizeHolder(ItemSizeHolderSize));
     if (allData.length() > 0) {
         auto dataSize = CodedInputData(allData.getPtr(), allData.length()).readUInt32();
         if (dataSize > 0) {
@@ -1270,9 +1284,9 @@ bool MMKV::doFullWriteBack(pair<MMBuffer, size_t> prepared, AESCrypt *newCrypter
 
     m_actualSize = totalSize;
     if (encrypter) {
-        recaculateCRCDigestWithIV(newIV);
+        recalculateCRCDigestWithIV(newIV);
     } else {
-        recaculateCRCDigestWithIV(nullptr);
+        recalculateCRCDigestWithIV(nullptr);
     }
     m_hasFullWriteback = true;
     // make sure lastConfirmedMetaInfo is saved if needed
@@ -1305,7 +1319,7 @@ bool MMKV::doFullWriteBack(pair<MMBuffer, size_t> prepared, AESCrypt *, bool nee
     }
 
     m_actualSize = totalSize;
-    recaculateCRCDigestWithIV(nullptr);
+    recalculateCRCDigestWithIV(nullptr);
     m_hasFullWriteback = true;
     // make sure lastConfirmedMetaInfo is saved if needed
     if (needSync) {
@@ -1751,7 +1765,7 @@ mmkv::MMBuffer MMKV::getDataWithoutMTimeForKey(MMKVKey_t key) {
 #ifdef MMKV_APPLE
             MMKVInfo("deleting expired key [%@] in mmkv [%s], due date %u", key, m_mmapID.c_str(), time);
 #else
-            MMKVInfo("deleting expired key [%s] in mmkv [%s], due date %u", key.c_str(), m_mmapID.c_str(), time);
+            MMKVInfo("deleting expired key [%s] in mmkv [%s], due date %u", key.data(), m_mmapID.c_str(), time);
 #endif
             removeValueForKey(key);
             return MMBuffer();

package/MMKV/Core/MMKV_OSX.cpp

@@ -35,6 +35,7 @@
 #    include <sys/utsname.h>
 #    include <sys/sysctl.h>
 #    include "MMKV_OSX.h"
+#    include "MMKVLog.h"
 
 #    ifdef MMKV_IOS
 #        include <sys/mman.h>
@@ -139,7 +140,7 @@ bool MMKV::set(NSObject<NSCoding> *__unsafe_unretained obj, MMKVKey_t key, uint3
     if (tmpData) {
         // delay write the size needed for encoding tmpData
         // avoid memory copying
-        if (likely(!m_enableKeyExpire)) {
+        if (mmkv_likely(!m_enableKeyExpire)) {
             return setDataForKey(MMBuffer(tmpData, MMBufferNoCopy), key, true);
         } else {
             MMBuffer data(tmpData, MMBufferNoCopy);
@@ -167,7 +168,7 @@ bool MMKV::set(NSObject<NSCoding> *__unsafe_unretained obj, MMKVKey_t key, uint3
                     return false;
                 }
                 if (archived.length > 0) {
-                    if (likely(!m_enableKeyExpire)) {
+                    if (mmkv_likely(!m_enableKeyExpire)) {
                         return setDataForKey(MMBuffer(archived, MMBufferNoCopy), key);
                     } else {
                         MMBuffer data(archived, MMBufferNoCopy);
@@ -259,35 +260,21 @@ MMKV::appendDataWithKey(const MMBuffer &data, MMKVKey_t key, const KeyValueHolde
 
 pair<bool, KeyValueHolder>
 MMKV::overrideDataWithKey(const MMBuffer &data, MMKVKey_t key, const KeyValueHolderCrypt &kvHolder, bool isDataHolder) {
-    size_t old_actualSize = m_actualSize;
-    size_t old_position = m_output->getPosition();
-    // only one key in dict, do not append, just rewrite from beginning
-    m_actualSize = 0;
-    m_output->setPosition(0);
-
-    auto m_tmpDic = m_dic;
-    auto m_tmpDicCrypt = m_dicCrypt;
-    if (m_crypter) {
-        m_dicCrypt = new MMKVMapCrypt();
-    } else {
-        m_dic = new MMKVMap();
+    if (kvHolder.type != KeyValueHolderType_Offset) {
+        return overrideDataWithKey(data, key, isDataHolder);
     }
+    SCOPED_LOCK(m_exclusiveProcessLock);
 
-    auto ret = appendDataWithKey(data, key, kvHolder, isDataHolder);
-    if (!ret.first) {
-        // rollback
-        m_actualSize = old_actualSize;
-        m_output->setPosition(old_position);
-    }
+    uint32_t keyLength = kvHolder.keySize;
+    // size needed to encode the key
+    size_t rawKeySize = keyLength + pbRawVarint32Size(keyLength);
 
-    if (m_crypter) {
-        delete m_dicCrypt;
-        m_dicCrypt = m_tmpDicCrypt;
-    } else {
-        delete m_dic;
-        m_dic = m_tmpDic;
-    }
-    return ret;
+    auto basePtr = (uint8_t *) m_file->getMemory() + Fixed32Size;
+    MMBuffer keyData(rawKeySize);
+    AESCrypt decrypter = m_crypter->cloneWithStatus(kvHolder.cryptStatus);
+    decrypter.decrypt(basePtr + kvHolder.offset, keyData.getPtr(), rawKeySize);
+
+    return doOverrideDataWithKey(data, keyData, isDataHolder, keyLength);
 }
 #    endif
 
@@ -295,7 +282,7 @@ NSArray *MMKV::allKeys(bool filterExpire) {
     SCOPED_LOCK(m_lock);
     checkLoadData();
 
-    if (unlikely(filterExpire && m_enableKeyExpire)) {
+    if (mmkv_unlikely(filterExpire && m_enableKeyExpire)) {
         SCOPED_LOCK(m_exclusiveProcessLock);
         fullWriteback(nullptr, true);
     }

package/MMKV/Core/MemoryFile_Android.cpp

@@ -135,32 +135,46 @@ typedef size_t (*AShmem_getSize_t)(int fd);
 #endif
 
 int ASharedMemory_create(const char *name, size_t size) {
-    int fd = -1;
 #ifndef MMKV_OHOS
-    if (g_android_api >= __ANDROID_API_O__) {
+    if (g_android_api >= __ANDROID_API_O__ || g_android_api >= __ANDROID_API_M__) {
         static auto handle = loadLibrary();
         static AShmem_create_t funcPtr =
             (handle != nullptr) ? reinterpret_cast<AShmem_create_t>(dlsym(handle, "ASharedMemory_create")) : nullptr;
         if (funcPtr) {
-            fd = funcPtr(name, size);
+            int fd = funcPtr(name, size);
             if (fd < 0) {
                 MMKVError("fail to ASharedMemory_create %s with size %zu, errno:%s", name, size, strerror(errno));
+            } else {
+                MMKVInfo("ASharedMemory_create %s with size %zu, fd:%d", name, size, fd);
+                return fd;
             }
-        } else {
+        } else if (g_android_api >= __ANDROID_API_O__) {
             MMKVWarning("fail to locate ASharedMemory_create() from loading libandroid.so");
         }
+
+        static AShmem_create_t regionFuncPtr =
+            (handle != nullptr) ? reinterpret_cast<AShmem_create_t>(dlsym(handle, "ashmem_create_region")) : nullptr;
+        if (regionFuncPtr) {
+            int fd = regionFuncPtr(name, size);
+            if (fd < 0) {
+                MMKVError("fail to ashmem_create_region %s with size %zu, errno:%s", name, size, strerror(errno));
+            } else {
+                MMKVInfo("ashmem_create_region %s with size %zu, fd:%d", name, size, fd);
+                return fd;
+            }
+        } else {
+            MMKVWarning("fail to locate ashmem_create_region() from loading libandroid.so");
+        }
     }
 #endif
+    int fd = open(ASHMEM_NAME_DEF, O_RDWR | O_CLOEXEC);
     if (fd < 0) {
-        fd = open(ASHMEM_NAME_DEF, O_RDWR | O_CLOEXEC);
-        if (fd < 0) {
-            MMKVError("fail to open ashmem:%s, %s", name, strerror(errno));
-        } else {
-            if (ioctl(fd, ASHMEM_SET_NAME, name) != 0) {
-                MMKVError("fail to set ashmem name:%s, %s", name, strerror(errno));
-            } else if (ioctl(fd, ASHMEM_SET_SIZE, size) != 0) {
-                MMKVError("fail to set ashmem:%s, size %zu, %s", name, size, strerror(errno));
-            }
+        MMKVError("fail to open ashmem:%s, %s", name, strerror(errno));
+    } else {
+        if (ioctl(fd, ASHMEM_SET_NAME, name) != 0) {
+            MMKVError("fail to set ashmem name:%s, %s", name, strerror(errno));
+        } else if (ioctl(fd, ASHMEM_SET_SIZE, size) != 0) {
+            MMKVError("fail to set ashmem:%s, size %zu, %s", name, size, strerror(errno));
         }
     }
     return fd;