react-native-mmkv 2.11.0 → 2.12.0

package/MMKV/Core/MMKV_OSX.cpp

@@ -33,9 +33,10 @@
 #    include "ThreadLock.h"
 #    include "aes/AESCrypt.h"
 #    include <sys/utsname.h>
+#    include <sys/sysctl.h>
+#    include "MMKV_OSX.h"
 
 #    ifdef MMKV_IOS
-#        include "MMKV_OSX.h"
 #        include <sys/mman.h>
 #    endif
 
@@ -53,9 +54,6 @@ using namespace mmkv;
 extern ThreadLock *g_instanceLock;
 extern MMKVPath_t g_rootDir;
 
-enum { UnKnown = 0, PowerMac = 1, Mac, iPhone, iPod, iPad, AppleTV, AppleWatch };
-static void GetAppleMachineInfo(int &device, int &version);
-
 MMKV_NAMESPACE_BEGIN
 
 #    ifdef MMKV_IOS
@@ -86,24 +84,9 @@ MLockPtr::~MLockPtr() {
     }
 }
 
-#    endif
-
-extern ThreadOnceToken_t once_control;
-extern void initialize();
+bool MLockPtr::isMLockPtrEnabled = true;
 
-void MMKV::minimalInit(MMKVPath_t defaultRootDir) {
-    ThreadLock::ThreadOnce(&once_control, initialize);
-
-    // crc32 instruction requires A10 chip, aka iPhone 7 or iPad 6th generation
-    int device = 0, version = 0;
-    GetAppleMachineInfo(device, version);
-    MMKVInfo("Apple Device:%d, version:%d", device, version);
-
-    g_rootDir = defaultRootDir;
-    mkPath(g_rootDir);
-
-    MMKVInfo("default root dir: " MMKV_PATH_FORMAT, g_rootDir.c_str());
-}
+#    endif
 
 #    ifdef MMKV_IOS
 
@@ -123,7 +106,7 @@ bool MMKV::isInBackground() {
 }
 
 pair<bool, MLockPtr> guardForBackgroundWriting(void *ptr, size_t size) {
-    if (g_isInBackground) {
+    if (g_isInBackground && MLockPtr::isMLockPtrEnabled) {
         MLockPtr mlockPtr(ptr, size);
         return make_pair(mlockPtr.isLocked(), std::move(mlockPtr));
     } else {
@@ -189,9 +172,9 @@ bool MMKV::set(NSObject<NSCoding> *__unsafe_unretained obj, MMKVKey_t key, uint3
                     } else {
                         MMBuffer data(archived, MMBufferNoCopy);
                         if (data.length() > 0) {
-                            auto tmp = MMBuffer(pbMMBufferSize(data) + Fixed32Size);
+                            auto tmp = MMBuffer(data.length() + Fixed32Size);
                             CodedOutputData output(tmp.getPtr(), tmp.length());
-                            output.writeData(data);
+                            output.writeRawData(data); // NSKeyedArchiver has its own size management
                             auto time = (expireDuration != 0) ? getCurrentTimeInSecond() + expireDuration : 0;
                             output.writeRawLittleEndian32(UInt32ToInt32(time));
                             data = std::move(tmp);
@@ -240,6 +223,8 @@ NSObject *MMKV::getObject(MMKVKey_t key, Class cls) {
                 return result;
             } catch (std::exception &exception) {
                 MMKVError("%s", exception.what());
+            } catch (...) {
+                MMKVError("decode fail");
             }
         } else {
             if ([cls conformsToProtocol:@protocol(NSCoding)]) {
@@ -271,12 +256,50 @@ MMKV::appendDataWithKey(const MMBuffer &data, MMKVKey_t key, const KeyValueHolde
 
     return doAppendDataWithKey(data, keyData, isDataHolder, keyLength);
 }
+
+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();
+    }
+
+    auto ret = appendDataWithKey(data, key, kvHolder, isDataHolder);
+    if (!ret.first) {
+        // rollback
+        m_actualSize = old_actualSize;
+        m_output->setPosition(old_position);
+    }
+
+    if (m_crypter) {
+        delete m_dicCrypt;
+        m_dicCrypt = m_tmpDicCrypt;
+    } else {
+        delete m_dic;
+        m_dic = m_tmpDic;
+    }
+    return ret;
+}
 #    endif
 
-NSArray *MMKV::allKeys() {
+NSArray *MMKV::allKeys(bool filterExpire) {
     SCOPED_LOCK(m_lock);
     checkLoadData();
 
+    if (unlikely(filterExpire && m_enableKeyExpire)) {
+        SCOPED_LOCK(m_exclusiveProcessLock);
+        fullWriteback(nullptr, true);
+    }
+
     NSMutableArray *keys = [NSMutableArray array];
     if (m_crypter) {
         for (const auto &pair : *m_dicCrypt) {
@@ -359,11 +382,7 @@ void MMKV::enumerateKeys(EnumerateBlock block) {
     MMKVInfo("enumerate [%s] finish", m_mmapID.c_str());
 }
 
-MMKV_NAMESPACE_END
-
-#    include <sys/sysctl.h>
-
-static void GetAppleMachineInfo(int &device, int &version) {
+void GetAppleMachineInfo(int &device, int &version) {
     device = UnKnown;
     version = 0;
 
@@ -401,4 +420,6 @@ static void GetAppleMachineInfo(int &device, int &version) {
     }
 }
 
+MMKV_NAMESPACE_END
+
 #endif // MMKV_APPLE

package/MMKV/Core/MMKV_OSX.h

@@ -21,10 +21,10 @@
 #pragma once
 #include "MMKVPredef.h"
 
-#if defined(MMKV_IOS) && defined(__cplusplus)
-
 MMKV_NAMESPACE_BEGIN
 
+#if defined(MMKV_IOS) && defined(__cplusplus)
+
 class MLockPtr {
     size_t m_lockDownSize;
     uint8_t *m_lockedPtr;
@@ -39,6 +39,8 @@ public:
         return (m_lockedPtr != nullptr);
     }
 
+    static bool isMLockPtrEnabled;
+
     // just forbid it for possibly misuse
     explicit MLockPtr(const MLockPtr &other) = delete;
     MLockPtr &operator=(const MLockPtr &other) = delete;
@@ -46,6 +48,10 @@ public:
 
 std::pair<bool, MLockPtr> guardForBackgroundWriting(void *ptr, size_t size);
 
-MMKV_NAMESPACE_END
-
 #endif
+
+enum { UnKnown = 0, PowerMac = 1, Mac, iPhone, iPod, iPad, AppleTV, AppleWatch };
+
+void GetAppleMachineInfo(int &device, int &version);
+
+MMKV_NAMESPACE_END

package/MMKV/Core/MemoryFile.cpp

@@ -49,8 +49,8 @@ File::File(MMKVPath_t path, OpenFlag flag) : m_path(std::move(path)), m_fd(-1),
     open();
 }
 
-MemoryFile::MemoryFile(MMKVPath_t path) : m_diskFile(std::move(path), OpenFlag::ReadWrite | OpenFlag::Create), m_ptr(nullptr), m_size(0) {
-    reloadFromFile();
+MemoryFile::MemoryFile(MMKVPath_t path, size_t expectedCapacity) : m_diskFile(std::move(path), OpenFlag::ReadWrite | OpenFlag::Create), m_ptr(nullptr), m_size(0) {
+    reloadFromFile(expectedCapacity);
 }
 #    endif // !defined(MMKV_ANDROID)
 
@@ -154,6 +154,16 @@ bool MemoryFile::truncate(size_t size) {
         if (!zeroFillFile(m_diskFile.m_fd, oldSize, m_size - oldSize)) {
             MMKVError("fail to zeroFile [%s] to size %zu, %s", m_diskFile.m_path.c_str(), m_size, strerror(errno));
             m_size = oldSize;
+
+            // redo ftruncate to its previous size
+            int status = ::ftruncate(m_diskFile.m_fd, static_cast<off_t>(m_size));
+            if (status != 0) {
+                MMKVError("failed to truncate back [%s] to size %zu, %s", m_diskFile.m_path.c_str(), m_size, strerror(errno));
+            } else {
+                MMKVError("success to truncate [%s] back to size %zu", m_diskFile.m_path.c_str(), m_size);
+                MMKVError("after truncate, file size = %zu", getActualFileSize());
+            }
+
             return false;
         }
     }
@@ -182,17 +192,18 @@ 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);
     if (m_ptr == MAP_FAILED) {
         MMKVError("fail to mmap [%s], %s", m_diskFile.m_path.c_str(), strerror(errno));
         m_ptr = nullptr;
         return false;
     }
-
+    MMKVInfo("mmap to address [%p], oldPtr [%p], [%s]", m_ptr, oldPtr, m_diskFile.m_path.c_str());
     return true;
 }
 
-void MemoryFile::reloadFromFile() {
+void MemoryFile::reloadFromFile(size_t expectedCapacity) {
 #    ifdef MMKV_ANDROID
     if (m_fileType == MMFILE_TYPE_ASHMEM) {
         return;
@@ -201,20 +212,25 @@ void MemoryFile::reloadFromFile() {
     if (isFileValid()) {
         MMKVWarning("calling reloadFromFile while the cache [%s] is still valid", m_diskFile.m_path.c_str());
         MMKV_ASSERT(0);
-        clearMemoryCache();
+        doCleanMemoryCache(false);
     }
 
     if (!m_diskFile.open()) {
         MMKVError("fail to open:%s, %s", m_diskFile.m_path.c_str(), strerror(errno));
     } else {
         FileLock fileLock(m_diskFile.m_fd);
-        InterProcessLock lock(&fileLock, ExclusiveLockType);
+        InterProcessLock lock(&fileLock, SharedLockType);
         SCOPED_LOCK(&lock);
 
         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 < DEFAULT_MMAP_SIZE || (m_size % DEFAULT_MMAP_SIZE != 0)) {
-            size_t roundSize = ((m_size / DEFAULT_MMAP_SIZE) + 1) * DEFAULT_MMAP_SIZE;
+        if (m_size < expectedSize || (m_size % DEFAULT_MMAP_SIZE != 0)) {
+            InterProcessLock exclusiveLock(&fileLock, ExclusiveLockType);
+            SCOPED_LOCK(&exclusiveLock);
+
+            size_t roundSize = ((m_size / DEFAULT_MMAP_SIZE) + 1) * DEFAULT_MMAP_SIZE;;
+            roundSize = std::max<size_t>(expectedSize, roundSize);
             truncate(roundSize);
         } else {
             auto ret = mmap();
@@ -271,15 +287,19 @@ extern bool mkPath(const MMKVPath_t &str) {
         if (stat(path, &sb) != 0) {
             if (errno != ENOENT || mkdir(path, 0777) != 0) {
                 MMKVWarning("%s : %s", path, strerror(errno));
-                free(path);
-                return false;
+                // there's report that some Android devices might not have access permission on parent dir
+                if (done) {
+                    free(path);
+                    return false;
+                }
+                goto LContinue;
             }
         } else if (!S_ISDIR(sb.st_mode)) {
             MMKVWarning("%s: %s", path, strerror(ENOTDIR));
             free(path);
             return false;
         }
-
+LContinue:
         *slash = '/';
     }
     free(path);

package/MMKV/Core/MemoryFile.h

@@ -55,6 +55,11 @@ static inline bool operator & (OpenFlag left, OpenFlag right) {
     return ((static_cast<uint32_t>(left) & static_cast<uint32_t>(right)) != 0);
 }
 
+template <typename T>
+T roundUp(T numToRound, T multiple) {
+    return ((numToRound + multiple - 1) / multiple) * multiple;
+}
+
 class File {
     MMKVPath_t m_path;
     MMKVFileHandle_t m_fd;
@@ -110,9 +115,9 @@ class MemoryFile {
 
 public:
 #ifndef MMKV_ANDROID
-    explicit MemoryFile(MMKVPath_t path);
+    explicit MemoryFile(MMKVPath_t path, size_t expectedCapacity = 0);
 #else
-    MemoryFile(MMKVPath_t path, size_t size, FileType fileType);
+    MemoryFile(MMKVPath_t path, size_t size, FileType fileType, size_t expectedCapacity = 0);
     explicit MemoryFile(MMKVFileHandle_t ashmemFD);
 
     const FileType m_fileType;
@@ -137,7 +142,7 @@ public:
     bool msync(SyncFlag syncFlag);
 
     // call this if clearMemoryCache() has been called
-    void reloadFromFile();
+    void reloadFromFile(size_t expectedCapacity = 0);
 
     void clearMemoryCache() { doCleanMemoryCache(false); }
 

package/MMKV/Core/MemoryFile_Android.cpp

@@ -70,10 +70,10 @@ File::File(MMKVFileHandle_t ashmemFD)
     }
 }
 
-MemoryFile::MemoryFile(string path, size_t size, FileType fileType)
+MemoryFile::MemoryFile(string path, size_t size, FileType fileType, size_t expectedCapacity)
     : m_diskFile(std::move(path), OpenFlag::ReadWrite | OpenFlag::Create, size, fileType), m_ptr(nullptr), m_size(0), m_fileType(fileType) {
     if (m_fileType == MMFILE_TYPE_FILE) {
-        reloadFromFile();
+        reloadFromFile(expectedCapacity);
     } else {
         if (m_diskFile.isFileValid()) {
             m_size = m_diskFile.m_size;

package/MMKV/Core/MemoryFile_OSX.cpp

@@ -53,7 +53,6 @@ void tryResetFileProtection(const string &path) {
 #ifdef MMKV_APPLE
 
 #include <copyfile.h>
-#include <mach/mach_time.h>
 
 namespace mmkv {
 
@@ -85,7 +84,7 @@ bool tryAtomicRename(const char *src, const char *dst) {
 
 bool copyFile(const MMKVPath_t &srcPath, const MMKVPath_t &dstPath) {
     // prepare a temp file for atomic rename, avoid data corruption of suddent crash
-    NSString *uniqueFileName = [NSString stringWithFormat:@"mmkv_%llu", mach_absolute_time()];
+    NSString *uniqueFileName = [NSString stringWithFormat:@"mmkv_%zu", (size_t) NSDate.timeIntervalSinceReferenceDate];
     NSString *tmpFile = [NSTemporaryDirectory() stringByAppendingPathComponent:uniqueFileName];
     if (copyfile(srcPath.c_str(), tmpFile.UTF8String, nullptr, COPYFILE_UNLINK | COPYFILE_CLONE) != 0) {
         MMKVError("fail to copyfile [%s] to [%s], %s", srcPath.c_str(), tmpFile.UTF8String, strerror(errno));
@@ -125,7 +124,7 @@ bool copyFileContent(const MMKVPath_t &srcPath, MMKVFileHandle_t dstFD) {
     }
 
     // sendfile() equivalent
-    if (::fcopyfile(srcFile.getFd(), dstFD, nullptr, COPYFILE_ACL | COPYFILE_STAT | COPYFILE_XATTR | COPYFILE_DATA) == 0) {
+    if (::fcopyfile(srcFile.getFd(), dstFD, nullptr, COPYFILE_ALL) == 0) {
         MMKVInfo("copy content from %s to fd[%d] finish", srcPath.c_str(), dstFD);
         return true;
     }

package/MMKV/Core/MemoryFile_Win32.cpp

@@ -94,12 +94,12 @@ size_t File::getActualFileSize() const {
     return size;
 }
 
-MemoryFile::MemoryFile(MMKVPath_t path)
+MemoryFile::MemoryFile(MMKVPath_t path, size_t expectedCapacity)
     : m_diskFile(std::move(path), OpenFlag::ReadWrite | OpenFlag::Create)
     , m_fileMapping(nullptr)
     , m_ptr(nullptr)
     , m_size(0) {
-    reloadFromFile();
+    reloadFromFile(expectedCapacity);
 }
 
 bool MemoryFile::truncate(size_t size) {
@@ -178,12 +178,13 @@ bool MemoryFile::mmap() {
             MMKVError("fail to mmap [%ls], %d", m_diskFile.m_path.c_str(), GetLastError());
             return false;
         }
+        MMKVInfo("mmap to address [%p], [%ls]", m_ptr, m_diskFile.m_path.c_str());
     }
 
     return true;
 }
 
-void MemoryFile::reloadFromFile() {
+void MemoryFile::reloadFromFile(size_t expectedCapacity) {
     if (isFileValid()) {
         MMKVWarning("calling reloadFromFile while the cache [%ls] is still valid", m_diskFile.m_path.c_str());
         assert(0);
@@ -196,9 +197,11 @@ void MemoryFile::reloadFromFile() {
         SCOPED_LOCK(&lock);
 
         mmkv::getFileSize(m_diskFile.getFd(), 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 < DEFAULT_MMAP_SIZE || (m_size % DEFAULT_MMAP_SIZE != 0)) {
-            size_t roundSize = ((m_size / DEFAULT_MMAP_SIZE) + 1) * DEFAULT_MMAP_SIZE;
+        if (m_size < expectedSize || (m_size % DEFAULT_MMAP_SIZE != 0)) {
+            size_t roundSize = ((m_size / DEFAULT_MMAP_SIZE) + 1) * DEFAULT_MMAP_SIZE;;
+            roundSize = std::max<size_t>(expectedSize, roundSize);
             truncate(roundSize);
         } else {
             auto ret = mmap();

package/MMKV/Core/MiniPBCoder.cpp

@@ -188,6 +188,9 @@ MMBuffer MiniPBCoder::encodeDataWithObject(const MMBuffer &obj) {
     } catch (const std::exception &exception) {
         MMKVError("%s", exception.what());
         return MMBuffer();
+    } catch (...) {
+        MMKVError("prepare encode fail");
+        return MMBuffer();
     }
 }
 
@@ -271,6 +274,8 @@ void MiniPBCoder::decodeOneMap(MMKVMap &dic, size_t position, bool greedy) {
             block(dic);
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("prepare encode fail");
         }
     } else {
         try {
@@ -279,6 +284,8 @@ void MiniPBCoder::decodeOneMap(MMKVMap &dic, size_t position, bool greedy) {
             dic.swap(tmpDic);
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("prepare encode fail");
         }
     }
 }
@@ -314,6 +321,8 @@ void MiniPBCoder::decodeOneMap(MMKVMapCrypt &dic, size_t position, bool greedy)
             block(dic);
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("prepare encode fail");
         }
     } else {
         try {
@@ -322,6 +331,8 @@ void MiniPBCoder::decodeOneMap(MMKVMapCrypt &dic, size_t position, bool greedy)
             dic.swap(tmpDic);
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("prepare encode fail");
         }
     }
 }

package/MMKV/Core/MiniPBCoder.h

@@ -89,6 +89,9 @@ public:
         } catch (const std::exception &exception) {
             MMKVError("%s", exception.what());
             return MMBuffer();
+        } catch (...) {
+            MMKVError("encode fail");
+            return MMBuffer();
         }
     }
 

package/MMKV/Core/MiniPBCoder_OSX.cpp

@@ -111,6 +111,8 @@ void MiniPBCoder::decodeOneMap(MMKVMap &dic, size_t position, bool greedy) {
             block(dic);
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("decode fail");
         }
     } else {
         try {
@@ -122,6 +124,8 @@ void MiniPBCoder::decodeOneMap(MMKVMap &dic, size_t position, bool greedy) {
             }
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("decode fail");
         }
     }
 }
@@ -164,6 +168,8 @@ void MiniPBCoder::decodeOneMap(MMKVMapCrypt &dic, size_t position, bool greedy)
             block(dic);
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("decode fail");
         }
     } else {
         try {
@@ -175,6 +181,8 @@ void MiniPBCoder::decodeOneMap(MMKVMapCrypt &dic, size_t position, bool greedy)
             }
         } catch (std::exception &exception) {
             MMKVError("%s", exception.what());
+        } catch (...) {
+            MMKVError("decode fail");
         }
     }
 }

package/MMKV/Core/ThreadLock.cpp

@@ -59,6 +59,11 @@ void ThreadLock::unlock() {
     }
 }
 
+bool ThreadLock::try_lock() {
+    auto ret = pthread_mutex_trylock(&m_lock);
+    return (ret == 0);
+}
+
 void ThreadLock::ThreadOnce(ThreadOnceToken_t *onceToken, void (*callback)()) {
     pthread_once(onceToken, callback);
 }

package/MMKV/Core/ThreadLock.h

@@ -61,6 +61,10 @@ public:
     void lock();
     void unlock();
 
+#ifndef MMKV_WIN32
+    bool try_lock();
+#endif
+
     static void ThreadOnce(ThreadOnceToken_t *onceToken, void (*callback)(void));
 
 #ifdef MMKV_WIN32

package/MMKV/Core/aes/openssl/openssl_aes-armv4.S

@@ -161,7 +161,9 @@ AES_Te:
 
 /* void openssl_aes_arm_encrypt(const uint8_t *in, uint8_t *out, const AES_KEY *key) {
 */
+#ifndef __APPLE__
 .type openssl_aes_arm_encrypt, %function
+#endif
 #ifndef __linux__
 .globl	_openssl_aes_arm_encrypt
 #ifdef __thumb2__
@@ -423,7 +425,9 @@ Lenc_loop:
 	ldr	pc,[sp],#4		// pop and return
 
 
+#ifndef __APPLE__
 .type openssl_aes_arm_set_encrypt_key, %function
+#endif
 #ifndef __linux__
 .globl	_openssl_aes_arm_set_encrypt_key
 #ifdef __thumb2__
@@ -737,7 +741,9 @@ Labrt:
 .word	0xe12fff1e			// interoperable with Thumb ISA:-)
 #endif
 
+#ifndef __APPLE__
 .type     openssl_aes_arm_set_decrypt_key, %function
+#endif
 #ifndef __linux__
 .globl    _openssl_aes_arm_set_decrypt_key
 #ifdef __thumb2__
@@ -957,7 +963,9 @@ AES_Td:
 .byte    0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
 
 
+#ifndef __APPLE__
 .type openssl_aes_arm_decrypt, %function
+#endif
 // void AES_decrypt(const uint8_t *in, uint8_t *out, const AES_KEY *key) {
 #ifndef __linux__
 .globl    _openssl_aes_arm_decrypt

package/MMKV/Core/core.vcxproj

@@ -65,7 +65,7 @@
   </ItemGroup>
   <PropertyGroup Label="Globals">
     <ProjectGuid>{32CD39C9-37B5-3D38-A3D9-45E13F4AF9C5}</ProjectGuid>
-    <WindowsTargetPlatformVersion>10.0.17763.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
     <Keyword>Win32Proj</Keyword>
     <Platform>Win32</Platform>
     <ProjectName>core</ProjectName>
@@ -75,12 +75,12 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <CharacterSet>Unicode</CharacterSet>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <CharacterSet>Unicode</CharacterSet>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">

package/MMKV/README.md

@@ -1,6 +1,6 @@
 [![license](https://img.shields.io/badge/license-BSD_3-brightgreen.svg?style=flat)](https://github.com/Tencent/MMKV/blob/master/LICENSE.TXT)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/Tencent/MMKV/pulls)
-[![Release Version](https://img.shields.io/badge/release-1.3.0-brightgreen.svg)](https://github.com/Tencent/MMKV/releases)
+[![Release Version](https://img.shields.io/badge/release-1.3.3-brightgreen.svg)](https://github.com/Tencent/MMKV/releases)
 [![Platform](https://img.shields.io/badge/Platform-%20Android%20%7C%20iOS%2FmacOS%20%7C%20Win32%20%7C%20POSIX-brightgreen.svg)](https://github.com/Tencent/MMKV/wiki/home)
 
 中文版本请参看[这里](./README_CN.md)
@@ -28,8 +28,8 @@ Add the following lines to `build.gradle` on your app module:
 
 ```gradle
 dependencies {
-    implementation 'com.tencent:mmkv:1.3.0'
-    // replace "1.3.0" with any available version
+    implementation 'com.tencent:mmkv:1.3.3'
+    // replace "1.3.3" with any available version
 }
 ```
 

package/android/build.gradle

@@ -1,3 +1,9 @@
+import com.android.Version
+
+def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
+def agpVersionMajor = agpVersion.tokenize('.')[0].toInteger()
+def androidManifestPath = agpVersionMajor >= 7 ? 'src/main/AndroidManifest.xml' : 'src/hasNamespace/AndroidManifest.xml'
+
 buildscript {
   repositories {
     maven {
@@ -46,16 +52,23 @@ repositories {
 }
 
 android {
-  namespace = "com.reactnativemmkv"
   compileSdkVersion safeExtGet("compileSdkVersion", 28)
-  def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
+  if (agpVersionMajor >= 7) {
+    namespace = "com.reactnativemmkv"
+  }
 
-  if (agpVersion.tokenize('.')[0].toInteger() >= 8) {
+  if (agpVersionMajor >= 8) {
       buildFeatures {
           buildConfig = true
       }
   }
 
+  sourceSets {
+    main {
+      manifest.srcFile androidManifestPath
+    }
+  }
+
   // Used to override the NDK path/version on internal CI or by allowing
   // users to customize the NDK path/version from their root project (e.g. for M1 support)
   if (rootProject.hasProperty("ndkPath")) {

package/android/src/hasNamespace/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -66,7 +66,13 @@ extern "C" JNIEXPORT void JNICALL Java_com_reactnativemmkv_MmkvModule_nativeInst
                                                                                     jobject clazz,
                                                                                     jlong jsiPtr,
                                                                                     jstring path) {
-  MMKV::initializeMMKV(jstringToStdString(env, path));
+#if DEBUG
+  MMKVLogLevel logLevel = MMKVLogDebug;
+#else
+  MMKVLogLevel logLevel = MMKVLogError;
+#endif
+  std::string storageDirectory = jstringToStdString(env, path);
+  MMKV::initializeMMKV(storageDirectory, logLevel);
 
   auto runtime = reinterpret_cast<jsi::Runtime*>(jsiPtr);
   if (runtime) {