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

package/MMKV/Core/MiniPBCoder.cpp

@@ -23,6 +23,8 @@
 #include "CodedInputDataCrypt.h"
 #include "CodedOutputData.h"
 #include "PBEncodeItem.hpp"
+#include "PBUtility.h"
+#include "MMKVLog.h"
 
 #ifdef MMKV_APPLE
 #    if __has_feature(objc_arc)
@@ -76,6 +78,24 @@ void MiniPBCoder::writeRootObject() {
                 break;
             }
 #ifndef MMKV_APPLE
+#ifdef MMKV_HAS_CPP20
+            case PBEncodeItemType_Int32: {
+                m_outputData->writeInt32(encodeItem->value.int32Value);
+                break;
+            }
+            case PBEncodeItemType_UInt32: {
+                m_outputData->writeUInt32(encodeItem->value.uint32Value);
+                break;
+            }
+            case PBEncodeItemType_Int64: {
+                m_outputData->writeInt64(encodeItem->value.int64Value);
+                break;
+            }
+            case PBEncodeItemType_UInt64: {
+                m_outputData->writeUInt64(encodeItem->value.uint64Value);
+                break;
+            }
+#endif // MMKV_HAS_CPP20
             case PBEncodeItemType_String: {
                 m_outputData->writeString(*(encodeItem->value.strValue));
                 break;
@@ -166,15 +186,23 @@ size_t MiniPBCoder::prepareObjectForEncode(const MMKVVector &vec) {
 }
 
 MMBuffer MiniPBCoder::writePreparedItems(size_t index) {
-    PBEncodeItem *oItem = (index < m_encodeItems->size()) ? &(*m_encodeItems)[index] : nullptr;
-    if (oItem && oItem->compiledSize > 0) {
-        m_outputBuffer = new MMBuffer(oItem->compiledSize);
-        m_outputData = new CodedOutputData(m_outputBuffer->getPtr(), m_outputBuffer->length());
+    try {
+        PBEncodeItem *oItem = (index < m_encodeItems->size()) ? &(*m_encodeItems)[index] : nullptr;
+        if (oItem && oItem->compiledSize > 0) {
+            m_outputBuffer = new MMBuffer(oItem->compiledSize);
+            m_outputData = new CodedOutputData(m_outputBuffer->getPtr(), m_outputBuffer->length());
 
-        writeRootObject();
-    }
+            writeRootObject();
+        }
 
-    return std::move(*m_outputBuffer);
+        return std::move(*m_outputBuffer);
+    } catch (const std::exception &exception) {
+        MMKVError("%s", exception.what());
+        return MMBuffer();
+    } catch (...) {
+        MMKVError("encode fail");
+        return MMBuffer();
+    }
 }
 
 MMBuffer MiniPBCoder::encodeDataWithObject(const MMBuffer &obj) {
@@ -210,7 +238,7 @@ size_t MiniPBCoder::prepareObjectForEncode(const string &str) {
     return index;
 }
 
-size_t MiniPBCoder::prepareObjectForEncode(const vector<string> &v) {
+size_t MiniPBCoder::prepareObjectForEncode(const MMKV_STRING_CONTAINER &v) {
     m_encodeItems->push_back(PBEncodeItem());
     PBEncodeItem *encodeItem = &(m_encodeItems->back());
     size_t index = m_encodeItems->size() - 1;
@@ -232,6 +260,110 @@ size_t MiniPBCoder::prepareObjectForEncode(const vector<string> &v) {
     return index;
 }
 
+#ifdef MMKV_HAS_CPP20
+
+size_t MiniPBCoder::prepareObjectForEncode(const std::span<const int32_t> &vec) {
+    m_encodeItems->push_back(PBEncodeItem());
+    PBEncodeItem *encodeItem = &(m_encodeItems->back());
+    size_t index = m_encodeItems->size() - 1;
+    {
+        encodeItem->type = PBEncodeItemType_Container;
+        encodeItem->value.bufferValue = nullptr;
+
+        for (const auto value : vec) {
+            PBEncodeItem item;
+            item.type = PBEncodeItemType_Int32;
+            item.value.int32Value = value;
+            item.compiledSize = pbInt32Size(value);
+
+            (*m_encodeItems)[index].valueSize += item.compiledSize;
+            m_encodeItems->push_back(std::move(item));
+        }
+
+        encodeItem = &(*m_encodeItems)[index];
+    }
+    encodeItem->compiledSize = pbRawVarint32Size(encodeItem->valueSize) + encodeItem->valueSize;
+
+    return index;
+}
+
+size_t MiniPBCoder::prepareObjectForEncode(const std::span<const uint32_t> &vec) {
+    m_encodeItems->push_back(PBEncodeItem());
+    PBEncodeItem *encodeItem = &(m_encodeItems->back());
+    size_t index = m_encodeItems->size() - 1;
+    {
+        encodeItem->type = PBEncodeItemType_Container;
+        encodeItem->value.bufferValue = nullptr;
+
+        for (const auto value : vec) {
+            PBEncodeItem item;
+            item.type = PBEncodeItemType_UInt32;
+            item.value.uint32Value = value;
+            item.compiledSize = pbUInt32Size(value);
+
+            (*m_encodeItems)[index].valueSize += item.compiledSize;
+            m_encodeItems->push_back(std::move(item));
+        }
+
+        encodeItem = &(*m_encodeItems)[index];
+    }
+    encodeItem->compiledSize = pbRawVarint32Size(encodeItem->valueSize) + encodeItem->valueSize;
+
+    return index;
+}
+
+size_t MiniPBCoder::prepareObjectForEncode(const std::span<const int64_t> &vec) {
+    m_encodeItems->push_back(PBEncodeItem());
+    PBEncodeItem *encodeItem = &(m_encodeItems->back());
+    size_t index = m_encodeItems->size() - 1;
+    {
+        encodeItem->type = PBEncodeItemType_Container;
+        encodeItem->value.bufferValue = nullptr;
+
+        for (const auto value : vec) {
+            PBEncodeItem item;
+            item.type = PBEncodeItemType_Int64;
+            item.value.int64Value = value;
+            item.compiledSize = pbInt64Size(value);
+
+            (*m_encodeItems)[index].valueSize += item.compiledSize;
+            m_encodeItems->push_back(std::move(item));
+        }
+
+        encodeItem = &(*m_encodeItems)[index];
+    }
+    encodeItem->compiledSize = pbRawVarint32Size(encodeItem->valueSize) + encodeItem->valueSize;
+
+    return index;
+}
+
+size_t MiniPBCoder::prepareObjectForEncode(const std::span<const uint64_t> &vec) {
+    m_encodeItems->push_back(PBEncodeItem());
+    PBEncodeItem *encodeItem = &(m_encodeItems->back());
+    size_t index = m_encodeItems->size() - 1;
+    {
+        encodeItem->type = PBEncodeItemType_Container;
+        encodeItem->value.bufferValue = nullptr;
+
+        for (const auto value : vec) {
+            PBEncodeItem item;
+            item.type = PBEncodeItemType_UInt64;
+            item.value.uint64Value = value;
+            item.compiledSize = pbUInt64Size(value);
+
+            (*m_encodeItems)[index].valueSize += item.compiledSize;
+            m_encodeItems->push_back(std::move(item));
+        }
+
+        encodeItem = &(*m_encodeItems)[index];
+    }
+    encodeItem->compiledSize = pbRawVarint32Size(encodeItem->valueSize) + encodeItem->valueSize;
+
+    return index;
+}
+
+#endif // MMKV_HAS_CPP20
+
 vector<string> MiniPBCoder::decodeOneVector() {
     vector<string> v;
 
@@ -245,6 +377,132 @@ vector<string> MiniPBCoder::decodeOneVector() {
     return v;
 }
 
+#ifdef MMKV_HAS_CPP20
+
+bool MiniPBCoder::decodeOneVector(std::vector<bool> &result) {
+    try {
+        auto size = m_inputData->readInt32();
+        result.reserve(size / pbBoolSize());
+
+        while (!m_inputData->isAtEnd()) {
+            auto value = m_inputData->readBool();
+            result.push_back(value);
+        }
+        return true;
+    } catch (std::exception &exception) {
+        MMKVError("%s", exception.what());
+    } catch (...) {
+        MMKVError("decode fail");
+    }
+    return false;
+}
+
+bool MiniPBCoder::decodeOneVector(std::vector<int32_t> &result) {
+    try {
+        m_inputData->readInt32();
+
+        while (!m_inputData->isAtEnd()) {
+            auto value = m_inputData->readInt32();
+            result.push_back(value);
+        }
+        return true;
+    } catch (std::exception &exception) {
+        MMKVError("%s", exception.what());
+    } catch (...) {
+        MMKVError("decode fail");
+    }
+    return false;
+}
+
+bool MiniPBCoder::decodeOneVector(std::vector<uint32_t> &result) {
+    try {
+        m_inputData->readInt32();
+
+        while (!m_inputData->isAtEnd()) {
+            auto value = m_inputData->readUInt32();
+            result.push_back(value);
+        }
+        return true;
+    } catch (std::exception &exception) {
+        MMKVError("%s", exception.what());
+    } catch (...) {
+        MMKVError("decode fail");
+    }
+    return false;
+}
+
+bool MiniPBCoder::decodeOneVector(std::vector<int64_t> &result) {
+    try {
+        m_inputData->readInt32();
+
+        while (!m_inputData->isAtEnd()) {
+            auto value = m_inputData->readInt64();
+            result.push_back(value);
+        }
+        return true;
+    } catch (std::exception &exception) {
+        MMKVError("%s", exception.what());
+    } catch (...) {
+        MMKVError("decode fail");
+    }
+    return false;
+}
+
+bool MiniPBCoder::decodeOneVector(std::vector<uint64_t> &result) {
+    try {
+        m_inputData->readInt32();
+
+        while (!m_inputData->isAtEnd()) {
+            auto value = m_inputData->readUInt64();
+            result.push_back(value);
+        }
+        return true;
+    } catch (std::exception &exception) {
+        MMKVError("%s", exception.what());
+    } catch (...) {
+        MMKVError("decode fail");
+    }
+    return false;
+}
+
+bool MiniPBCoder::decodeOneVector(std::vector<float> &result) {
+    try {
+        auto size = m_inputData->readInt32();
+        result.reserve(size / pbFloatSize());
+
+        while (!m_inputData->isAtEnd()) {
+            auto value = m_inputData->readFloat();
+            result.push_back(value);
+        }
+        return true;
+    } catch (std::exception &exception) {
+        MMKVError("%s", exception.what());
+    } catch (...) {
+        MMKVError("decode fail");
+    }
+    return false;
+}
+
+bool MiniPBCoder::decodeOneVector(std::vector<double> &result) {
+    try {
+        auto size = m_inputData->readInt32();
+        result.reserve(size / pbDoubleSize());
+
+        while (!m_inputData->isAtEnd()) {
+            auto value = m_inputData->readDouble();
+            result.push_back(value);
+        }
+        return true;
+    } catch (std::exception &exception) {
+        MMKVError("%s", exception.what());
+    } catch (...) {
+        MMKVError("decode fail");
+    }
+    return false;
+}
+
+#endif // MMKV_HAS_CPP20
+
 void MiniPBCoder::decodeOneMap(MMKVMap &dic, size_t position, bool greedy) {
     auto block = [position, this](MMKVMap &dictionary) {
         if (position) {
@@ -344,7 +602,48 @@ vector<string> MiniPBCoder::decodeVector(const MMBuffer &oData) {
     return oCoder.decodeOneVector();
 }
 
-#endif // MMKV_APPLE
+#ifdef MMKV_HAS_CPP20
+MMBuffer MiniPBCoder::getEncodeData(const std::vector<bool> &value) {
+    auto valueLength = static_cast<uint32_t>(value.size() * pbBoolSize());
+    auto size = pbRawVarint32Size(valueLength) + valueLength;
+    auto buffer = MMBuffer(size);
+    CodedOutputData output(buffer.getPtr(), size);
+    output.writeUInt32(valueLength);
+
+    for (auto single : value) {
+        output.writeBool(single);
+    }
+    return buffer;
+}
+
+MMBuffer MiniPBCoder::getEncodeData(const std::span<const float> &value) {
+    auto valueLength = static_cast<uint32_t>(value.size() * pbFloatSize());
+    auto size = pbRawVarint32Size(valueLength) + valueLength;
+    auto buffer = MMBuffer(size);
+    CodedOutputData output(buffer.getPtr(), size);
+    output.writeUInt32(valueLength);
+
+    for (auto single : value) {
+        output.writeFloat(single);
+    }
+    return buffer;
+}
+
+MMBuffer MiniPBCoder::getEncodeData(const std::span<const double> &value) {
+    auto valueLength = static_cast<uint32_t>(value.size() * pbDoubleSize());
+    auto size = pbRawVarint32Size(valueLength) + valueLength;
+    auto buffer = MMBuffer(size);
+    CodedOutputData output(buffer.getPtr(), size);
+    output.writeUInt32(valueLength);
+
+    for (auto single : value) {
+        output.writeDouble(single);
+    }
+    return buffer;
+}
+#endif // MMKV_HAS_CPP20
+
+#endif // !MMKV_APPLE
 
 void MiniPBCoder::decodeMap(MMKVMap &dic, const MMBuffer &oData, size_t position) {
     MiniPBCoder oCoder(&oData);

package/MMKV/Core/MiniPBCoder.h

@@ -24,12 +24,15 @@
 
 #include "MMKVPredef.h"
 
-#include "KeyValueHolder.h"
 #include "MMBuffer.h"
-#include "MMBuffer.h"
-#include "MMKVLog.h"
-#include "PBUtility.h"
 #include <cstdint>
+#ifdef MMKV_HAS_CPP20
+#  include <span>
+#  define MMKV_STRING_CONTAINER std::span<const std::string>
+#else
+#  define MMKV_STRING_CONTAINER std::vector<std::string>
+#endif
+
 
 namespace mmkv {
 
@@ -72,27 +75,37 @@ class MiniPBCoder {
 
 #ifndef MMKV_APPLE
     size_t prepareObjectForEncode(const std::string &str);
-    size_t prepareObjectForEncode(const std::vector<std::string> &vector);
-
+    size_t prepareObjectForEncode(const MMKV_STRING_CONTAINER &vector);
     std::vector<std::string> decodeOneVector();
+#ifdef MMKV_HAS_CPP20
+    size_t prepareObjectForEncode(const std::span<const int32_t> &vec);
+    size_t prepareObjectForEncode(const std::span<const uint32_t> &vec);
+    size_t prepareObjectForEncode(const std::span<const int64_t> &vec);
+    size_t prepareObjectForEncode(const std::span<const uint64_t> &vec);
+
+    bool decodeOneVector(std::vector<bool> &result);
+    bool decodeOneVector(std::vector<int32_t> &result);
+    bool decodeOneVector(std::vector<uint32_t> &result);
+    bool decodeOneVector(std::vector<int64_t> &result);
+    bool decodeOneVector(std::vector<uint64_t> &result);
+    bool decodeOneVector(std::vector<float> &result);
+    bool decodeOneVector(std::vector<double> &result);
+
+    // special case for fixed size types
+    MMBuffer getEncodeData(const std::vector<bool> &obj);
+    MMBuffer getEncodeData(const std::span<const float> &obj);
+    MMBuffer getEncodeData(const std::span<const double> &obj);
+#endif // MMKV_HAS_CPP20
 #else
     // NSString, NSData, NSDate
     size_t prepareObjectForEncode(__unsafe_unretained NSObject *obj);
-#endif
+#endif // MMKV_APPLE
 
 public:
     template <typename T>
     static MMBuffer encodeDataWithObject(const T &obj) {
-        try {
-            MiniPBCoder pbcoder;
-            return pbcoder.getEncodeData(obj);
-        } catch (const std::exception &exception) {
-            MMKVError("%s", exception.what());
-            return MMBuffer();
-        } catch (...) {
-            MMKVError("encode fail");
-            return MMBuffer();
-        }
+        MiniPBCoder pbCoder;
+        return pbCoder.getEncodeData(obj);
     }
 
     // opt encoding a single MMBuffer
@@ -114,6 +127,12 @@ public:
 
 #ifndef MMKV_APPLE
     static std::vector<std::string> decodeVector(const MMBuffer &oData);
+
+    template <typename T>
+    static bool decodeVector(const MMBuffer &oData, std::vector<T> &result) {
+        MiniPBCoder oCoder(&oData);
+        return oCoder.decodeOneVector(result);
+    }
 #else
     // NSString, NSData, NSDate
     static NSObject *decodeObject(const MMBuffer &oData, Class cls);

package/MMKV/Core/MiniPBCoder_OSX.cpp

@@ -19,6 +19,7 @@
  */
 
 #include "MiniPBCoder.h"
+#include "MMKVLog.h"
 
 #ifdef MMKV_APPLE
 

package/MMKV/Core/PBEncodeItem.hpp

@@ -36,6 +36,15 @@ enum PBEncodeItemType {
     PBEncodeItemType_Container,
 #ifndef MMKV_APPLE
     PBEncodeItemType_String,
+#ifdef MMKV_HAS_CPP20
+    PBEncodeItemType_Int32,
+    PBEncodeItemType_UInt32,
+    PBEncodeItemType_Int64,
+    PBEncodeItemType_UInt64,
+//    PBEncodeItemType_Bool,
+//    PBEncodeItemType_Float,
+//    PBEncodeItemType_Double,
+#endif // MMKV_HAS_CPP20
 #else
     PBEncodeItemType_NSString,
     PBEncodeItemType_NSData,
@@ -50,6 +59,15 @@ struct PBEncodeItem {
     union {
         const MMBuffer *bufferValue;
 #ifndef MMKV_APPLE
+#ifdef MMKV_HAS_CPP20
+//        bool boolValue;
+        int32_t int32Value;
+        int64_t int64Value;
+        uint32_t uint32Value;
+        uint64_t uint64Value;
+#endif // MMKV_HAS_CPP20
+        //        float floatValue;
+//        double doubleValue;
         const std::string *strValue;
 #else
         void *objectValue;

package/MMKV/Core/PBUtility.h

@@ -26,18 +26,6 @@
 
 #include <cstdint>
 
-#ifndef MMKV_WIN32
-#    ifndef likely
-#        define unlikely(x) (__builtin_expect(bool(x), 0))
-#        define likely(x) (__builtin_expect(bool(x), 1))
-#    endif
-#else
-#    ifndef likely
-#        define unlikely(x) (x)
-#        define likely(x) (x)
-#    endif
-#endif
-
 namespace mmkv {
 
 template <typename T, typename P>

package/MMKV/Core/ThreadLock.cpp

@@ -38,10 +38,8 @@ ThreadLock::ThreadLock() : m_lock({}) {
 }
 
 ThreadLock::~ThreadLock() {
-#ifdef MMKV_OHOS
-    // OHOS's pthread is buggy, check for POC: https://gist.github.com/lingol/622af352e090e0490ebacfe3a38b9221 
     pthread_mutex_unlock(&m_lock);
-#endif
+
     pthread_mutex_destroy(&m_lock);
 }
 

package/MMKV/Core/aes/AESCrypt.cpp

@@ -25,12 +25,25 @@
 #include <cstring>
 #include <ctime>
 
+namespace mmkv {
+
+// assuming size in [1, 5]
+uint32_t AESCrypt::randomItemSizeHolder(uint32_t size) {
+    constexpr uint32_t ItemSizeHolders[] = {0, 0x80, 0x4000, 0x200000, 0x10000000, 0};
+    auto ItemSizeHolderMin = ItemSizeHolders[size - 1];
+    auto ItemSizeHolderMax = ItemSizeHolders[size] - 1;
+
+    srand((unsigned) time(nullptr));
+    auto result = static_cast<uint32_t>(rand());
+    result = result % (ItemSizeHolderMax - ItemSizeHolderMin + 1);
+    result += ItemSizeHolderMin;
+    return result;
+}
+
 #ifndef MMKV_DISABLE_CRYPT
 
 using namespace openssl;
 
-namespace mmkv {
-
 AESCrypt::AESCrypt(const void *key, size_t keyLength, const void *iv, size_t ivLength) {
     if (key && keyLength > 0) {
         memcpy(m_key, key, (keyLength > AES_KEY_LEN) ? AES_KEY_LEN : keyLength);
@@ -161,8 +174,6 @@ AESCrypt AESCrypt::cloneWithStatus(const AESCryptStatus &status) const {
     return AESCrypt(*this, status);
 }
 
-} // namespace mmkv
-
 #    ifdef MMKV_DEBUG
 
 #        include "../MMKVLog.h"
@@ -170,8 +181,17 @@ AESCrypt AESCrypt::cloneWithStatus(const AESCryptStatus &status) const {
 
 namespace mmkv {
 
+void testRandomPlaceHolder() {
+    for (uint32_t size = 1; size < 6; size++) {
+        auto holder = AESCrypt::randomItemSizeHolder(size);
+        MMKVInfo("holder 0x%x for size %u", holder, size);
+    }
+}
+
 // check if AESCrypt is encrypt-decrypt full-duplex
 void AESCrypt::testAESCrypt() {
+    testRandomPlaceHolder();
+
     const uint8_t plainText[] = "Hello, OpenSSL-mmkv::AESCrypt::testAESCrypt() with AES CFB 128.";
     constexpr size_t textLength = sizeof(plainText) - 1;
 
@@ -250,7 +270,7 @@ void AESCrypt::testAESCrypt() {
     delete[] decryptText;
 }
 
-} // namespace mmkv
-
 #    endif // MMKV_DEBUG
 #endif     // MMKV_DISABLE_CRYPT
+
+} // namespace mmkv

package/MMKV/Core/aes/AESCrypt.h

@@ -29,7 +29,10 @@
 #ifdef MMKV_DISABLE_CRYPT
 
 namespace mmkv {
-class AESCrypt;
+class AESCrypt {
+public:
+    static uint32_t randomItemSizeHolder(uint32_t size);
+};
 }
 
 #else
@@ -88,6 +91,7 @@ public:
     void getKey(void *output) const;
 
     static void fillRandomIV(void *vector);
+    static uint32_t randomItemSizeHolder(uint32_t size);
 
     // just forbid it for possibly misuse
     explicit AESCrypt(const AESCrypt &other) = delete;

package/MMKV/Core/core.vcxproj

@@ -156,7 +156,7 @@
       <AdditionalOptions>%(AdditionalOptions) /machine:X86</AdditionalOptions>
     </Lib>
     <PostBuildEvent>
-      <Command>for %%f in ("$(ProjectDir)MMKV.h", "$(ProjectDir)MMBuffer.h",  "$(ProjectDir)MMKVPredef.h") do xcopy /y /i %%f "$(OutDir)\include\MMKV\"</Command>
+      <Command>for %%f in ("$(ProjectDir)MMKV.h", "$(ProjectDir)MMBuffer.h",  "$(ProjectDir)MMKVPredef.h", "$(ProjectDir)MiniPBCoder.h") do xcopy /y /i %%f "$(OutDir)\include\MMKV\"</Command>
     </PostBuildEvent>
     <PostBuildEvent>
       <Message>Copying Headers</Message>
@@ -196,7 +196,7 @@
       <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
     </Lib>
     <PostBuildEvent>
-      <Command>for %%f in ("$(ProjectDir)MMKV.h", "$(ProjectDir)MMBuffer.h",  "$(ProjectDir)MMKVPredef.h") do xcopy /y /i %%f "$(OutDir)\include\MMKV\"</Command>
+      <Command>for %%f in ("$(ProjectDir)MMKV.h", "$(ProjectDir)MMBuffer.h",  "$(ProjectDir)MMKVPredef.h", "$(ProjectDir)MiniPBCoder.h") do xcopy /y /i %%f "$(OutDir)\include\MMKV\"</Command>
     </PostBuildEvent>
     <PostBuildEvent>
       <Message>Copying Headers</Message>
@@ -236,7 +236,7 @@
       <AdditionalOptions>%(AdditionalOptions) /machine:X86</AdditionalOptions>
     </Lib>
     <PostBuildEvent>
-      <Command>for %%f in ("$(ProjectDir)MMKV.h", "$(ProjectDir)MMBuffer.h",  "$(ProjectDir)MMKVPredef.h") do xcopy /y /i %%f "$(OutDir)\include\MMKV\"</Command>
+      <Command>for %%f in ("$(ProjectDir)MMKV.h", "$(ProjectDir)MMBuffer.h",  "$(ProjectDir)MMKVPredef.h", "$(ProjectDir)MiniPBCoder.h") do xcopy /y /i %%f "$(OutDir)\include\MMKV\"</Command>
     </PostBuildEvent>
     <PostBuildEvent>
       <Message>Copying Headers</Message>
@@ -276,7 +276,7 @@
       <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
     </Lib>
     <PostBuildEvent>
-      <Command>for %%f in ("$(ProjectDir)MMKV.h", "$(ProjectDir)MMBuffer.h",  "$(ProjectDir)MMKVPredef.h") do xcopy /y /i %%f "$(OutDir)\include\MMKV\"</Command>
+      <Command>for %%f in ("$(ProjectDir)MMKV.h", "$(ProjectDir)MMBuffer.h",  "$(ProjectDir)MMKVPredef.h", "$(ProjectDir)MiniPBCoder.h") do xcopy /y /i %%f "$(OutDir)\include\MMKV\"</Command>
     </PostBuildEvent>
     <PostBuildEvent>
       <Message>Copying Headers</Message>

package/MMKV/Core/crc32/Checksum.h

@@ -39,7 +39,10 @@ uLong crc32(uLong crc, const Bytef *buf, z_size_t len);
 #else // MMKV_EMBED_ZLIB
 
 #    include <zlib.h>
-
+// some old version of zlib doesn't define z_size_t
+#    ifndef z_size_t
+       typedef size_t z_size_t;
+#    endif
 #    define ZLIB_CRC32(crc, buf, len) ::crc32(crc, buf, static_cast<uInt>(len))
 
 #endif // MMKV_EMBED_ZLIB

package/android/CMakeLists.txt

@@ -9,7 +9,6 @@ add_library(
         react-native-mmkv
         SHARED
         src/main/cpp/AndroidLogger.cpp
-        src/main/cpp/cpp-adapter.cpp
         ../cpp/MmkvHostObject.cpp
         ../cpp/NativeMmkvModule.cpp
 )

package/android/src/main/java/com/mrousavy/mmkv/MmkvPlatformContextModule.java

@@ -1,5 +1,7 @@
 package com.mrousavy.mmkv;
 
+import androidx.annotation.Nullable;
+
 import com.facebook.react.bridge.ReactApplicationContext;
 
 public class MmkvPlatformContextModule extends NativeMmkvPlatformContextSpec {
@@ -14,4 +16,11 @@ public class MmkvPlatformContextModule extends NativeMmkvPlatformContextSpec {
     public String getBaseDirectory() {
         return context.getFilesDir().getAbsolutePath() + "/mmkv";
     }
+
+    @Nullable
+    @Override
+    public String getAppGroupDirectory() {
+        // AppGroups do not exist on Android. It's iOS only.
+        return null;
+    }
 }