react-native-mmkv 2.7.0 → 2.9.0

package/MMKV/Core/MMKV_OSX.cpp

@@ -125,7 +125,7 @@ bool MMKV::isInBackground() {
 pair<bool, MLockPtr> guardForBackgroundWriting(void *ptr, size_t size) {
     if (g_isInBackground) {
         MLockPtr mlockPtr(ptr, size);
-        return make_pair(mlockPtr.isLocked(), move(mlockPtr));
+        return make_pair(mlockPtr.isLocked(), std::move(mlockPtr));
     } else {
         return make_pair(true, MLockPtr(nullptr, 0));
     }
@@ -134,6 +134,10 @@ pair<bool, MLockPtr> guardForBackgroundWriting(void *ptr, size_t size) {
 #    endif // MMKV_IOS
 
 bool MMKV::set(NSObject<NSCoding> *__unsafe_unretained obj, MMKVKey_t key) {
+    return set(obj, key, m_expiredInSeconds);
+}
+
+bool MMKV::set(NSObject<NSCoding> *__unsafe_unretained obj, MMKVKey_t key, uint32_t expireDuration) {
     if (isKeyEmpty(key)) {
         return false;
     }
@@ -152,22 +156,76 @@ bool MMKV::set(NSObject<NSCoding> *__unsafe_unretained obj, MMKVKey_t key) {
     if (tmpData) {
         // delay write the size needed for encoding tmpData
         // avoid memory copying
-        return setDataForKey(MMBuffer(tmpData, MMBufferNoCopy), key, true);
+        if (likely(!m_enableKeyExpire)) {
+            return setDataForKey(MMBuffer(tmpData, MMBufferNoCopy), key, true);
+        } else {
+            MMBuffer data(tmpData, MMBufferNoCopy);
+            if (data.length() > 0) {
+                auto tmp = MMBuffer(pbMMBufferSize(data) + Fixed32Size);
+                CodedOutputData output(tmp.getPtr(), tmp.length());
+                output.writeData(data);
+                auto time = (expireDuration != 0) ? getCurrentTimeInSecond() + expireDuration : 0;
+                output.writeRawLittleEndian32(UInt32ToInt32(time));
+                data = std::move(tmp);
+            }
+            return setDataForKey(std::move(data), key);
+        }
     } else if ([obj isKindOfClass:NSDate.class]) {
         NSDate *oDate = (NSDate *) obj;
         double time = oDate.timeIntervalSince1970;
-        return set(time, key);
+        return set(time, key, expireDuration);
     } else {
         /*if ([object conformsToProtocol:@protocol(NSCoding)])*/ {
-            auto tmp = [NSKeyedArchiver archivedDataWithRootObject:obj];
-            if (tmp.length > 0) {
-                return setDataForKey(MMBuffer(tmp, MMBufferNoCopy), key);
+            @try {
+                NSError *error = nil;
+                auto archived = [NSKeyedArchiver archivedDataWithRootObject:obj requiringSecureCoding:NO error:&error];
+                if (error) {
+                    MMKVError("fail to archive: %@", error);
+                    return false;
+                }
+                if (archived.length > 0) {
+                    if (likely(!m_enableKeyExpire)) {
+                        return setDataForKey(MMBuffer(archived, MMBufferNoCopy), key);
+                    } else {
+                        MMBuffer data(archived, MMBufferNoCopy);
+                        if (data.length() > 0) {
+                            auto tmp = MMBuffer(pbMMBufferSize(data) + Fixed32Size);
+                            CodedOutputData output(tmp.getPtr(), tmp.length());
+                            output.writeData(data);
+                            auto time = (expireDuration != 0) ? getCurrentTimeInSecond() + expireDuration : 0;
+                            output.writeRawLittleEndian32(UInt32ToInt32(time));
+                            data = std::move(tmp);
+                        }
+                        return setDataForKey(std::move(data), key);
+                    }
+                }
+            } @catch (NSException *exception) {
+                MMKVError("exception: %@", exception.reason);
             }
         }
     }
     return false;
 }
 
+static id unSecureUnArchiveObjectWithData(NSData *data) {
+    @try {
+        NSError *error = nil;
+        auto unarchiver = [[NSKeyedUnarchiver alloc] initForReadingFromData:data error:&error];
+        if (error) {
+            MMKVError("fail to init unarchiver %@", error);
+            return nil;
+        }
+
+        unarchiver.requiresSecureCoding = NO;
+        id result = [unarchiver decodeObjectForKey:NSKeyedArchiveRootObjectKey];
+        [unarchiver release];
+        return result;
+    } @catch (NSException *exception) {
+        MMKVError("exception: %@", exception.reason);
+    }
+    return nil;
+}
+
 NSObject *MMKV::getObject(MMKVKey_t key, Class cls) {
     if (isKeyEmpty(key) || !cls) {
         return nil;
@@ -186,12 +244,7 @@ NSObject *MMKV::getObject(MMKVKey_t key, Class cls) {
         } else {
             if ([cls conformsToProtocol:@protocol(NSCoding)]) {
                 auto tmp = [NSData dataWithBytesNoCopy:data.getPtr() length:data.length() freeWhenDone:NO];
-                @try {
-                    id result = [NSKeyedUnarchiver unarchiveObjectWithData:tmp];
-                    return result;
-                } @catch (NSException *exception) {
-                    MMKVError("%s", exception.reason);
-                }
+                return unSecureUnArchiveObjectWithData(tmp);
             }
         }
     }
@@ -200,8 +253,6 @@ NSObject *MMKV::getObject(MMKVKey_t key, Class cls) {
 
 #    ifndef MMKV_DISABLE_CRYPT
 
-constexpr uint32_t Fixed32Size = pbFixed32Size();
-
 pair<bool, KeyValueHolder>
 MMKV::appendDataWithKey(const MMBuffer &data, MMKVKey_t key, const KeyValueHolderCrypt &kvHolder, bool isDataHolder) {
     if (kvHolder.type != KeyValueHolderType_Offset) {

package/MMKV/Core/MemoryFile_Win32.cpp

@@ -70,20 +70,20 @@ bool File::open() {
     m_fd = CreateFile(m_path.c_str(), pair.first, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr,
                       pair.second, FILE_ATTRIBUTE_NORMAL, nullptr);
     if (!isFileValid()) {
-        MMKVError("fail to open:[%ws], %d", m_path.c_str(), GetLastError());
+        MMKVError("fail to open:[%ls], %d", m_path.c_str(), GetLastError());
         return false;
     }
-    MMKVInfo("open fd[%p], %ws", m_fd, m_path.c_str());
+    MMKVInfo("open fd[%p], %ls", m_fd, m_path.c_str());
     return true;
 }
 
 void File::close() {
     if (isFileValid()) {
-        MMKVInfo("closing fd[%p], %ws", m_fd, m_path.c_str());
+        MMKVInfo("closing fd[%p], %ls", m_fd, m_path.c_str());
         if (CloseHandle(m_fd)) {
             m_fd = INVALID_HANDLE_VALUE;
         } else {
-            MMKVError("fail to close [%ws], %d", m_path.c_str(), GetLastError());
+            MMKVError("fail to close [%ls], %d", m_path.c_str(), GetLastError());
         }
     }
 }
@@ -117,29 +117,32 @@ bool MemoryFile::truncate(size_t size) {
         m_size = ((m_size / DEFAULT_MMAP_SIZE) + 1) * DEFAULT_MMAP_SIZE;
     }
 
+    if (m_ptr) {
+        if (!UnmapViewOfFile(m_ptr)) {
+            MMKVError("fail to munmap [%ls], %d", m_diskFile.m_path.c_str(), GetLastError());
+        }
+        m_ptr = nullptr;
+    }
+    if (m_fileMapping) {
+        CloseHandle(m_fileMapping);
+        m_fileMapping = nullptr;
+    }
+
     if (!ftruncate(m_diskFile.getFd(), m_size)) {
-        MMKVError("fail to truncate [%ws] to size %zu", m_diskFile.m_path.c_str(), m_size);
+        MMKVError("fail to truncate [%ls] to size %zu", m_diskFile.m_path.c_str(), m_size);
         m_size = oldSize;
+        mmap();
         return false;
     }
     if (m_size > oldSize) {
         if (!zeroFillFile(m_diskFile.getFd(), oldSize, m_size - oldSize)) {
-            MMKVError("fail to zeroFile [%ws] to size %zu", m_diskFile.m_path.c_str(), m_size);
+            MMKVError("fail to zeroFile [%ls] to size %zu", m_diskFile.m_path.c_str(), m_size);
             m_size = oldSize;
+            mmap();
             return false;
         }
     }
 
-    if (m_ptr) {
-        if (!UnmapViewOfFile(m_ptr)) {
-            MMKVError("fail to munmap [%ws], %d", m_diskFile.m_path.c_str(), GetLastError());
-        }
-        m_ptr = nullptr;
-    }
-    if (m_fileMapping) {
-        CloseHandle(m_fileMapping);
-        m_fileMapping = nullptr;
-    }
     auto ret = mmap();
     if (!ret) {
         doCleanMemoryCache(true);
@@ -152,13 +155,13 @@ bool MemoryFile::msync(SyncFlag syncFlag) {
         if (FlushViewOfFile(m_ptr, m_size)) {
             if (syncFlag == MMKV_SYNC) {
                 if (!FlushFileBuffers(m_diskFile.getFd())) {
-                    MMKVError("fail to FlushFileBuffers [%ws]:%d", m_diskFile.m_path.c_str(), GetLastError());
+                    MMKVError("fail to FlushFileBuffers [%ls]:%d", m_diskFile.m_path.c_str(), GetLastError());
                     return false;
                 }
             }
             return true;
         }
-        MMKVError("fail to FlushViewOfFile [%ws]:%d", m_diskFile.m_path.c_str(), GetLastError());
+        MMKVError("fail to FlushViewOfFile [%ls]:%d", m_diskFile.m_path.c_str(), GetLastError());
         return false;
     }
     return false;
@@ -167,12 +170,12 @@ bool MemoryFile::msync(SyncFlag syncFlag) {
 bool MemoryFile::mmap() {
     m_fileMapping = CreateFileMapping(m_diskFile.getFd(), nullptr, PAGE_READWRITE, 0, 0, nullptr);
     if (!m_fileMapping) {
-        MMKVError("fail to CreateFileMapping [%ws], %d", m_diskFile.m_path.c_str(), GetLastError());
+        MMKVError("fail to CreateFileMapping [%ls], %d", m_diskFile.m_path.c_str(), GetLastError());
         return false;
     } else {
         m_ptr = (char *) MapViewOfFile(m_fileMapping, FILE_MAP_ALL_ACCESS, 0, 0, 0);
         if (!m_ptr) {
-            MMKVError("fail to mmap [%ws], %d", m_diskFile.m_path.c_str(), GetLastError());
+            MMKVError("fail to mmap [%ls], %d", m_diskFile.m_path.c_str(), GetLastError());
             return false;
         }
     }
@@ -182,7 +185,7 @@ bool MemoryFile::mmap() {
 
 void MemoryFile::reloadFromFile() {
     if (isFileValid()) {
-        MMKVWarning("calling reloadFromFile while the cache [%ws] is still valid", m_diskFile.m_path.c_str());
+        MMKVWarning("calling reloadFromFile while the cache [%ls] is still valid", m_diskFile.m_path.c_str());
         assert(0);
         clearMemoryCache();
     }
@@ -248,12 +251,12 @@ bool mkPath(const MMKVPath_t &str) {
         auto attribute = GetFileAttributes(path);
         if (attribute == INVALID_FILE_ATTRIBUTES) {
             if (!CreateDirectory(path, nullptr)) {
-                MMKVError("fail to create dir:%ws, %d", str.c_str(), GetLastError());
+                MMKVError("fail to create dir:%ls, %d", str.c_str(), GetLastError());
                 free(path);
                 return false;
             }
         } else if (!(attribute & FILE_ATTRIBUTE_DIRECTORY)) {
-            MMKVError("%ws attribute:%d not a directry", str.c_str(), attribute);
+            MMKVError("%ls attribute:%d not a directry", str.c_str(), attribute);
             free(path);
             return false;
         }
@@ -279,14 +282,14 @@ MMBuffer *readWholeFile(const MMKVPath_t &nsFilePath) {
             if (ReadFile(fd, buffer->getPtr(), fileLength, &readSize, nullptr)) {
                 //fileSize = readSize;
             } else {
-                MMKVWarning("fail to read %ws: %d", nsFilePath.c_str(), GetLastError());
+                MMKVWarning("fail to read %ls: %d", nsFilePath.c_str(), GetLastError());
                 delete buffer;
                 buffer = nullptr;
             }
         }
         CloseHandle(fd);
     } else {
-        MMKVWarning("fail to open %ws: %d", nsFilePath.c_str(), GetLastError());
+        MMKVWarning("fail to open %ls: %d", nsFilePath.c_str(), GetLastError());
     }
     return buffer;
 }
@@ -363,18 +366,19 @@ static pair<MMKVPath_t, MMKVFileHandle_t> createUniqueTempFile(const wchar_t *pr
         MMKVError("GetTempFileName failed %d", GetLastError());
         return {L"", INVALID_HANDLE_VALUE};
     }
-    auto hTempFile = CreateFile(szTempFileName, GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
+    auto hTempFile =
+        CreateFile(szTempFileName, GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
     if (hTempFile == INVALID_HANDLE_VALUE) {
-        MMKVError("fail to create unique temp file [%ws], %d", szTempFileName, GetLastError());
+        MMKVError("fail to create unique temp file [%ls], %d", szTempFileName, GetLastError());
         return {L"", INVALID_HANDLE_VALUE};
     }
-    MMKVDebug("create unique temp file [%ws] with fd[%p]", szTempFileName, hTempFile);
+    MMKVDebug("create unique temp file [%ls] with fd[%p]", szTempFileName, hTempFile);
     return {MMKVPath_t(szTempFileName), hTempFile};
 }
 
 bool tryAtomicRename(const MMKVPath_t &srcPath, const MMKVPath_t &dstPath) {
     if (MoveFileEx(srcPath.c_str(), dstPath.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED) == 0) {
-        MMKVError("MoveFileEx [%ws] to [%ws] failed %d", srcPath.c_str(), dstPath.c_str(), GetLastError());
+        MMKVError("MoveFileEx [%ls] to [%ls] failed %d", srcPath.c_str(), dstPath.c_str(), GetLastError());
         return false;
     }
     return true;
@@ -401,7 +405,7 @@ bool copyFileContent(const MMKVPath_t &srcPath, MMKVFileHandle_t dstFD, bool nee
     while (true) {
         DWORD sizeRead = 0;
         if (!ReadFile(srcFile.getFd(), buffer, bufferSize, &sizeRead, nullptr)) {
-            MMKVError("fail to read %ws: %d", srcPath.c_str(), GetLastError());
+            MMKVError("fail to read %ls: %d", srcPath.c_str(), GetLastError());
             goto errorOut;
         }
 
@@ -426,7 +430,7 @@ bool copyFileContent(const MMKVPath_t &srcPath, MMKVFileHandle_t dstFD, bool nee
     }
 
     ret = true;
-    MMKVInfo("copy content from %ws to fd[%d] finish", srcPath.c_str(), dstFD);
+    MMKVInfo("copy content from %ls to fd[%d] finish", srcPath.c_str(), dstFD);
 
 errorOut:
     free(buffer);
@@ -445,11 +449,11 @@ bool copyFile(const MMKVPath_t &srcPath, const MMKVPath_t &dstPath) {
 
     bool renamed = false;
     if (copyFileContent(srcPath, tmpFD, false)) {
-        MMKVInfo("copyed file [%ws] to [%ws]", srcPath.c_str(), tmpPath.c_str());
+        MMKVInfo("copyed file [%ls] to [%ls]", srcPath.c_str(), tmpPath.c_str());
         CloseHandle(tmpFD);
         renamed = tryAtomicRename(tmpPath.c_str(), dstPath.c_str());
         if (renamed) {
-            MMKVInfo("copyfile [%ws] to [%ws] finish.", srcPath.c_str(), dstPath.c_str());
+            MMKVInfo("copyfile [%ls] to [%ls] finish.", srcPath.c_str(), dstPath.c_str());
         }
     } else {
         CloseHandle(tmpFD);
@@ -468,9 +472,9 @@ bool copyFileContent(const MMKVPath_t &srcPath, const MMKVPath_t &dstPath) {
     }
     auto ret = copyFileContent(srcPath, dstFile.getFd(), false);
     if (!ret) {
-        MMKVError("fail to copyfile(): target file %ws", dstPath.c_str());
+        MMKVError("fail to copyfile(): target file %ls", dstPath.c_str());
     } else {
-        MMKVInfo("copy content from %ws to [%ws] finish", srcPath.c_str(), dstPath.c_str());
+        MMKVInfo("copy content from %ls to [%ls] finish", srcPath.c_str(), dstPath.c_str());
     }
     return ret;
 }

package/MMKV/Core/MiniPBCoder.cpp

@@ -127,8 +127,6 @@ size_t MiniPBCoder::prepareObjectForEncode(const MMBuffer &buffer) {
     return index;
 }
 
-#ifndef MMKV_DISABLE_CRYPT
-
 size_t MiniPBCoder::prepareObjectForEncode(const MMKVVector &vec) {
     m_encodeItems->push_back(PBEncodeItem());
     PBEncodeItem *encodeItem = &(m_encodeItems->back());
@@ -167,8 +165,6 @@ size_t MiniPBCoder::prepareObjectForEncode(const MMKVVector &vec) {
     return index;
 }
 
-#endif // MMKV_DISABLE_CRYPT
-
 MMBuffer MiniPBCoder::writePreparedItems(size_t index) {
     PBEncodeItem *oItem = (index < m_encodeItems->size()) ? &(*m_encodeItems)[index] : nullptr;
     if (oItem && oItem->compiledSize > 0) {
@@ -240,7 +236,7 @@ vector<string> MiniPBCoder::decodeOneVector() {
 
     while (!m_inputData->isAtEnd()) {
         auto value = m_inputData->readString();
-        v.push_back(move(value));
+        v.push_back(std::move(value));
     }
 
     return v;
@@ -259,7 +255,7 @@ void MiniPBCoder::decodeOneMap(MMKVMap &dic, size_t position, bool greedy) {
             if (key.length() > 0) {
                 m_inputData->readData(kvHolder);
                 if (kvHolder.valueSize > 0) {
-                    dictionary[key] = move(kvHolder);
+                    dictionary[key] = std::move(kvHolder);
                 } else {
                     auto itr = dictionary.find(key);
                     if (itr != dictionary.end()) {
@@ -302,7 +298,7 @@ void MiniPBCoder::decodeOneMap(MMKVMapCrypt &dic, size_t position, bool greedy)
             if (key.length() > 0) {
                 m_inputDataDecrpt->readData(kvHolder);
                 if (kvHolder.realValueSize() > 0) {
-                    dictionary[key] = move(kvHolder);
+                    dictionary[key] = std::move(kvHolder);
                 } else {
                     auto itr = dictionary.find(key);
                     if (itr != dictionary.end()) {

package/MMKV/Core/MiniPBCoder_OSX.cpp

@@ -90,7 +90,7 @@ void MiniPBCoder::decodeOneMap(MMKVMap &dic, size_t position, bool greedy) {
                 auto itr = dictionary.find(key);
                 if (itr != dictionary.end()) {
                     if (kvHolder.valueSize > 0) {
-                        itr->second = move(kvHolder);
+                        itr->second = std::move(kvHolder);
                     } else {
                         auto oldKey = itr->first;
                         dictionary.erase(itr);
@@ -98,7 +98,7 @@ void MiniPBCoder::decodeOneMap(MMKVMap &dic, size_t position, bool greedy) {
                     }
                 } else {
                     if (kvHolder.valueSize > 0) {
-                        dictionary.emplace(key, move(kvHolder));
+                        dictionary.emplace(key, std::move(kvHolder));
                         [key retain];
                     }
                 }
@@ -143,7 +143,7 @@ void MiniPBCoder::decodeOneMap(MMKVMapCrypt &dic, size_t position, bool greedy)
                 auto itr = dictionary.find(key);
                 if (itr != dictionary.end()) {
                     if (kvHolder.realValueSize() > 0) {
-                        itr->second = move(kvHolder);
+                        itr->second = std::move(kvHolder);
                     } else {
                         auto oldKey = itr->first;
                         dictionary.erase(itr);
@@ -151,7 +151,7 @@ void MiniPBCoder::decodeOneMap(MMKVMapCrypt &dic, size_t position, bool greedy)
                     }
                 } else {
                     if (kvHolder.realValueSize() > 0) {
-                        dictionary.emplace(key, move(kvHolder));
+                        dictionary.emplace(key, std::move(kvHolder));
                         [key retain];
                     }
                 }

package/MMKV/Core/PBUtility.cpp

@@ -17,7 +17,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
+#include "MMBuffer.h"
 #include "PBUtility.h"
 
 namespace mmkv {

package/MMKV/Core/PBUtility.h

@@ -147,6 +147,13 @@ static inline uint32_t pbUInt32Size(uint32_t value) {
     return pbRawVarint32Size(value);
 }
 
+static inline uint32_t pbMMBufferSize(const MMBuffer &data) {
+    auto valueLength = static_cast<uint32_t>(data.length());
+    return valueLength + pbUInt32Size(valueLength);
+}
+
+constexpr uint32_t Fixed32Size = pbFixed32Size();
+
 } // namespace mmkv
 
 #endif

package/MMKV/Core/aes/AESCrypt.h

@@ -22,7 +22,7 @@
 #define AES_CRYPT_H_
 #ifdef __cplusplus
 
-#include "MMKVPredef.h"
+#include "../MMKVPredef.h"
 #include <cstddef>
 
 #ifdef MMKV_DISABLE_CRYPT

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

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

package/README.md

@@ -76,8 +76,8 @@ cd ios && pod install
 ### Expo
 
 ```sh
-expo install react-native-mmkv
-expo prebuild
+npx expo install react-native-mmkv
+npx expo prebuild
 ```
 
 ## Usage
@@ -104,8 +104,7 @@ import { MMKV } from 'react-native-mmkv'
 export const storage = new MMKV({
   id: `user-${userId}-storage`,
   path: `${USER_DIRECTORY}/storage`,
-  encryptionKey: 'hunter2',
-  fastWrites: true
+  encryptionKey: 'hunter2'
 })
 ```
 
@@ -116,7 +115,6 @@ The following values can be configured:
 * `id`: The MMKV instance's ID. If you want to use multiple instances, use different IDs. For example, you can separate the global app's storage and a logged-in user's storage. (required if `path` or `encryptionKey` fields are specified, otherwise defaults to: `'mmkv.default'`)
 * `path`: The MMKV instance's root path. By default, MMKV stores file inside `$(Documents)/mmkv/`. You can customize MMKV's root directory on MMKV initialization (documentation: [iOS](https://github.com/Tencent/MMKV/wiki/iOS_advance#customize-location) / [Android](https://github.com/Tencent/MMKV/wiki/android_advance#customize-location))
 * `encryptionKey`: The MMKV instance's encryption/decryption key. By default, MMKV stores all key-values in plain text on file, relying on iOS's/Android's sandbox to make sure the file is encrypted. Should you worry about information leaking, you can choose to encrypt MMKV. (documentation: [iOS](https://github.com/Tencent/MMKV/wiki/iOS_advance#encryption) / [Android](https://github.com/Tencent/MMKV/wiki/android_advance#encryption))
-* `fastWrites`: Configure fast writes for MMKV. When set to `true`, all calls to `set(..)` do not overwrite the previous value to avoid storage resizing, this speeds up write speed. Only enable this if you use a small MMKV storage, as this uses more RAM.
 
 ### Set
 
@@ -194,20 +192,30 @@ A mocked MMKV instance is automatically used when testing with Jest, so you will
 * [Value-change Listeners](./docs/LISTENERS.md)
 * [Migrate from AsyncStorage](./docs/MIGRATE_FROM_ASYNC_STORAGE.md)
 * [Using MMKV with redux-persist](./docs/WRAPPER_REDUX.md)
+* [Using MMKV with recoil](./docs/WRAPPER_RECOIL.md)
 * [Using MMKV with mobx-persist-storage](./docs/WRAPPER_MOBX.md)
 * [Using MMKV with mobx-persist](./docs/WRAPPER_MOBXPERSIST.md)
 * [Using MMKV with zustand persist-middleware](./docs/WRAPPER_ZUSTAND_PERSIST_MIDDLEWARE.md)
 * [Using MMKV with jotai](./docs/WRAPPER_JOTAI.md)
+* [Using MMKV with react-query](./docs/WRAPPER_REACT_QUERY.md)
 * [How is this library different from **react-native-mmkv-storage**?](https://github.com/mrousavy/react-native-mmkv/issues/100#issuecomment-886477361)
 
+## LocalStorage and In-Memory Storage (Web)
+
+If a user chooses to disable LocalStorage in their browser, the library will automatically provide a limited in-memory storage as an alternative. However, this in-memory storage won't persist data, and users may experience data loss if they refresh the page or close their browser. To optimize user experience, consider implementing a suitable solution within your app to address this scenario.
+
 ## Limitations
 
 As the library uses JSI for synchronous native methods access, remote debugging (e.g. with Chrome) is no longer possible. Instead, you should use [Flipper](https://fbflipper.com).
 
-## Debugging
+### Flipper
 
 Use [flipper-plugin-react-native-mmkv](https://github.com/muchobien/flipper-plugin-react-native-mmkv) to debug your MMKV storage using Flipper. You can also simply `console.log` an MMKV instance.
 
+### Reactotron
+
+Use [reactotron-react-native-mmkv](https://www.npmjs.com/package/reactotron-react-native-mmkv) to automatically log writes to your MMKV storage using Reactotron. [See the docs for how to setup this plugin with Reactotron.](https://www.npmjs.com/package/reactotron-react-native-mmkv)
+
 ## Adopting at scale
 
 react-native-mmkv is provided _as is_, I work on it in my free time.

package/android/build.gradle

@@ -46,6 +46,7 @@ repositories {
 }
 
 android {
+  namespace = "com.reactnativemmkv"
   compileSdkVersion safeExtGet("compileSdkVersion", 28)
 
   // Used to override the NDK path/version on internal CI or by allowing
@@ -92,6 +93,7 @@ android {
             "META-INF",
             "META-INF/**",
             "**/libjsi.so",
+            "**/libc++_shared.so"
     ]
   }
 }

package/android/src/main/AndroidManifest.xml

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

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

@@ -2,6 +2,7 @@
 #include <jsi/jsi.h>
 #include <MMKV.h>
 #include "MmkvHostObject.h"
+#include "TypedArray.h"
 
 using namespace facebook;
 
@@ -32,6 +33,10 @@ void install(jsi::Runtime& jsiRuntime) {
                                                                          return jsi::Object::createFromHostObject(runtime, instance);
                                                                        });
     jsiRuntime.global().setProperty(jsiRuntime, "mmkvCreateNewInstance", std::move(mmkvCreateNewInstance));
+
+    // Adds the PropNameIDCache object to the Runtime. If the Runtime gets destroyed, the Object gets destroyed and the cache gets invalidated.
+    auto propNameIdCache = std::make_shared<InvalidateCacheOnDestroy>(jsiRuntime);
+    jsiRuntime.global().setProperty(jsiRuntime, "mmkvArrayBufferPropNameIdCache", jsi::Object::createFromHostObject(jsiRuntime, propNameIdCache));
 }
 
 std::string jstringToStdString(JNIEnv *env, jstring jStr) {