react-native-mmkv 1.6.1 → 2.0.1

package/MMKV/Core/MemoryFile_Win32.cpp

@@ -28,6 +28,7 @@
 #    include "ScopedLock.hpp"
 #    include "ThreadLock.h"
 #    include <cassert>
+#    include <strsafe.h>
 
 using namespace std;
 
@@ -36,13 +37,73 @@ namespace mmkv {
 static bool getFileSize(MMKVFileHandle_t fd, size_t &size);
 static bool ftruncate(MMKVFileHandle_t file, size_t size);
 
-MemoryFile::MemoryFile(const MMKVPath_t &path)
-    : m_name(path), m_fd(INVALID_HANDLE_VALUE), m_fileMapping(nullptr), m_ptr(nullptr), m_size(0) {
+File::File(MMKVPath_t path, OpenFlag flag) : m_path(std::move(path)), m_fd(INVALID_HANDLE_VALUE), m_flag(flag) {
+    open();
+}
+
+static pair<int, int> OpenFlag2NativeFlag(OpenFlag flag) {
+    int access = 0, create = OPEN_EXISTING;
+    if (flag & OpenFlag::ReadWrite) {
+        access = (GENERIC_READ | GENERIC_WRITE);
+    } else if (flag & OpenFlag::ReadOnly) {
+        access |= GENERIC_READ;
+    } else if (flag & OpenFlag::WriteOnly) {
+        access |= GENERIC_WRITE;
+    }
+    if (flag & OpenFlag::Create) {
+        create = OPEN_ALWAYS;
+    }
+    if (flag & OpenFlag::Excel) {
+        access = CREATE_NEW;
+    }
+    if (flag & OpenFlag::Truncate) {
+        access = CREATE_ALWAYS;
+    }
+    return {access, create};
+}
+
+bool File::open() {
+    if (isFileValid()) {
+        return true;
+    }
+    auto pair = OpenFlag2NativeFlag(m_flag);
+    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());
+        return false;
+    }
+    MMKVInfo("open fd[%p], %ws", m_fd, m_path.c_str());
+    return true;
+}
+
+void File::close() {
+    if (isFileValid()) {
+        MMKVInfo("closing fd[%p], %ws", 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());
+        }
+    }
+}
+
+size_t File::getActualFileSize() const {
+    size_t size = 0;
+    mmkv::getFileSize(m_fd, size);
+    return size;
+}
+
+MemoryFile::MemoryFile(MMKVPath_t path)
+    : m_diskFile(std::move(path), OpenFlag::ReadWrite | OpenFlag::Create)
+    , m_fileMapping(nullptr)
+    , m_ptr(nullptr)
+    , m_size(0) {
     reloadFromFile();
 }
 
 bool MemoryFile::truncate(size_t size) {
-    if (m_fd < 0) {
+    if (!m_diskFile.isFileValid()) {
         return false;
     }
     if (size == m_size) {
@@ -56,14 +117,14 @@ bool MemoryFile::truncate(size_t size) {
         m_size = ((m_size / DEFAULT_MMAP_SIZE) + 1) * DEFAULT_MMAP_SIZE;
     }
 
-    if (!ftruncate(m_fd, m_size)) {
-        MMKVError("fail to truncate [%ws] to size %zu", m_name.c_str(), m_size);
+    if (!ftruncate(m_diskFile.getFd(), m_size)) {
+        MMKVError("fail to truncate [%ws] to size %zu", m_diskFile.m_path.c_str(), m_size);
         m_size = oldSize;
         return false;
     }
     if (m_size > oldSize) {
-        if (!zeroFillFile(m_fd, oldSize, m_size - oldSize)) {
-            MMKVError("fail to zeroFile [%ws] to size %zu", m_name.c_str(), m_size);
+        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);
             m_size = oldSize;
             return false;
         }
@@ -71,7 +132,7 @@ bool MemoryFile::truncate(size_t size) {
 
     if (m_ptr) {
         if (!UnmapViewOfFile(m_ptr)) {
-            MMKVError("fail to munmap [%ws], %d", m_name.c_str(), GetLastError());
+            MMKVError("fail to munmap [%ws], %d", m_diskFile.m_path.c_str(), GetLastError());
         }
         m_ptr = nullptr;
     }
@@ -90,28 +151,28 @@ bool MemoryFile::msync(SyncFlag syncFlag) {
     if (m_ptr) {
         if (FlushViewOfFile(m_ptr, m_size)) {
             if (syncFlag == MMKV_SYNC) {
-                if (!FlushFileBuffers(m_fd)) {
-                    MMKVError("fail to FlushFileBuffers [%ws]:%d", m_name.c_str(), GetLastError());
+                if (!FlushFileBuffers(m_diskFile.getFd())) {
+                    MMKVError("fail to FlushFileBuffers [%ws]:%d", m_diskFile.m_path.c_str(), GetLastError());
                     return false;
                 }
             }
             return true;
         }
-        MMKVError("fail to FlushViewOfFile [%ws]:%d", m_name.c_str(), GetLastError());
+        MMKVError("fail to FlushViewOfFile [%ws]:%d", m_diskFile.m_path.c_str(), GetLastError());
         return false;
     }
     return false;
 }
 
 bool MemoryFile::mmap() {
-    m_fileMapping = CreateFileMapping(m_fd, nullptr, PAGE_READWRITE, 0, 0, nullptr);
+    m_fileMapping = CreateFileMapping(m_diskFile.getFd(), nullptr, PAGE_READWRITE, 0, 0, nullptr);
     if (!m_fileMapping) {
-        MMKVError("fail to CreateFileMapping [%ws], %d", m_name.c_str(), GetLastError());
+        MMKVError("fail to CreateFileMapping [%ws], %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_name.c_str(), GetLastError());
+            MMKVError("fail to mmap [%ws], %d", m_diskFile.m_path.c_str(), GetLastError());
             return false;
         }
     }
@@ -121,22 +182,17 @@ bool MemoryFile::mmap() {
 
 void MemoryFile::reloadFromFile() {
     if (isFileValid()) {
-        MMKVWarning("calling reloadFromFile while the cache [%ws] is still valid", m_name.c_str());
+        MMKVWarning("calling reloadFromFile while the cache [%ws] is still valid", m_diskFile.m_path.c_str());
         assert(0);
         clearMemoryCache();
     }
-
-    m_fd =
-        CreateFile(m_name.c_str(), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                   nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
-    if (m_fd == INVALID_HANDLE_VALUE) {
-        MMKVError("fail to open:%ws, %d", m_name.c_str(), GetLastError());
-    } else {
-        FileLock fileLock(m_fd);
+    m_diskFile.open();
+    if (m_diskFile.isFileValid()) {
+        FileLock fileLock(m_diskFile.getFd());
         InterProcessLock lock(&fileLock, ExclusiveLockType);
         SCOPED_LOCK(&lock);
 
-        mmkv::getFileSize(m_fd, m_size);
+        mmkv::getFileSize(m_diskFile.getFd(), m_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;
@@ -159,16 +215,7 @@ void MemoryFile::doCleanMemoryCache(bool forceClean) {
         CloseHandle(m_fileMapping);
         m_fileMapping = nullptr;
     }
-    if (m_fd != INVALID_HANDLE_VALUE) {
-        CloseHandle(m_fd);
-        m_fd = INVALID_HANDLE_VALUE;
-    }
-}
-
-size_t MemoryFile::getActualFileSize() {
-    size_t size = 0;
-    mmkv::getFileSize(m_fd, size);
-    return size;
+    m_diskFile.close();
 }
 
 size_t getPageSize() {
@@ -302,6 +349,170 @@ static bool getFileSize(MMKVFileHandle_t fd, size_t &size) {
     return false;
 }
 
+static pair<MMKVPath_t, MMKVFileHandle_t> createUniqueTempFile(const wchar_t *prefix) {
+    wchar_t lpTempPathBuffer[MAX_PATH];
+    //  Gets the temp path env string (no guarantee it's a valid path).
+    auto dwRetVal = GetTempPath(MAX_PATH, lpTempPathBuffer);
+    if (dwRetVal > MAX_PATH || (dwRetVal == 0)) {
+        MMKVError("GetTempPath failed %d", GetLastError());
+        return {L"", INVALID_HANDLE_VALUE};
+    }
+    //  Generates a temporary file name.
+    wchar_t szTempFileName[MAX_PATH];
+    if (!GetTempFileName(lpTempPathBuffer, prefix, 0, szTempFileName)) {
+        MMKVError("GetTempFileName failed %d", GetLastError());
+        return {L"", INVALID_HANDLE_VALUE};
+    }
+    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());
+        return {L"", INVALID_HANDLE_VALUE};
+    }
+    MMKVDebug("create unique temp file [%ws] 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());
+        return false;
+    }
+    return true;
+}
+
+bool copyFileContent(const MMKVPath_t &srcPath, MMKVFileHandle_t dstFD, bool needTruncate) {
+    if (dstFD == INVALID_HANDLE_VALUE) {
+        return false;
+    }
+    bool ret = false;
+    File srcFile(srcPath, OpenFlag::ReadOnly);
+    if (!srcFile.isFileValid()) {
+        return false;
+    }
+    auto bufferSize = getPageSize();
+    auto buffer = (char *) malloc(bufferSize);
+    if (!buffer) {
+        MMKVError("fail to malloc size %zu, %d(%s)", bufferSize, errno, strerror(errno));
+        goto errorOut;
+    }
+    SetFilePointer(dstFD, 0, 0, FILE_BEGIN);
+
+    // the Win32 platform don't have sendfile()/fcopyfile() equivalent, do it the hard way
+    while (true) {
+        DWORD sizeRead = 0;
+        if (!ReadFile(srcFile.getFd(), buffer, bufferSize, &sizeRead, nullptr)) {
+            MMKVError("fail to read %ws: %d", srcPath.c_str(), GetLastError());
+            goto errorOut;
+        }
+
+        DWORD sizeWrite = 0;
+        if (!WriteFile(dstFD, buffer, sizeRead, &sizeWrite, nullptr)) {
+            MMKVError("fail to write fd [%d], %d", dstFD, GetLastError());
+            goto errorOut;
+        }
+
+        if (sizeRead < bufferSize) {
+            break;
+        }
+    }
+    if (needTruncate) {
+        size_t dstFileSize = 0;
+        getFileSize(dstFD, dstFileSize);
+        auto srcFileSize = srcFile.getActualFileSize();
+        if ((dstFileSize != srcFileSize) && !ftruncate(dstFD, static_cast<off_t>(srcFileSize))) {
+            MMKVError("fail to truncate [%d] to size [%zu]", dstFD, srcFileSize);
+            goto errorOut;
+        }
+    }
+
+    ret = true;
+    MMKVInfo("copy content from %ws to fd[%d] finish", srcPath.c_str(), dstFD);
+
+errorOut:
+    free(buffer);
+    return ret;
+}
+
+// copy to a temp file then rename it
+// this is the best we can do on Win32
+bool copyFile(const MMKVPath_t &srcPath, const MMKVPath_t &dstPath) {
+    auto pair = createUniqueTempFile(L"MMKV");
+    auto tmpFD = pair.second;
+    auto &tmpPath = pair.first;
+    if (tmpFD == INVALID_HANDLE_VALUE) {
+        return false;
+    }
+
+    bool renamed = false;
+    if (copyFileContent(srcPath, tmpFD, false)) {
+        MMKVInfo("copyed file [%ws] to [%ws]", 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());
+        }
+    } else {
+        CloseHandle(tmpFD);
+    }
+
+    if (!renamed) {
+        DeleteFile(tmpPath.c_str());
+    }
+    return renamed;
+}
+
+bool copyFileContent(const MMKVPath_t &srcPath, const MMKVPath_t &dstPath) {
+    File dstFile(dstPath, OpenFlag::WriteOnly | OpenFlag::Create | OpenFlag::Truncate);
+    if (!dstFile.isFileValid()) {
+        return false;
+    }
+    auto ret = copyFileContent(srcPath, dstFile.getFd(), false);
+    if (!ret) {
+        MMKVError("fail to copyfile(): target file %ws", dstPath.c_str());
+    } else {
+        MMKVInfo("copy content from %ws to [%ws] finish", srcPath.c_str(), dstPath.c_str());
+    }
+    return ret;
+}
+
+bool copyFileContent(const MMKVPath_t &srcPath, MMKVFileHandle_t dstFD) {
+    return copyFileContent(srcPath, dstFD, true);
+}
+
+void walkInDir(const MMKVPath_t &dirPath,
+               WalkType type,
+               const std::function<void(const MMKVPath_t &, WalkType)> &walker) {
+    wchar_t szDir[MAX_PATH];
+    StringCchCopy(szDir, MAX_PATH, dirPath.c_str());
+    StringCchCat(szDir, MAX_PATH, L"\\*");
+
+    WIN32_FIND_DATA ffd;
+    auto hFind = FindFirstFile(szDir, &ffd);
+    if (hFind == INVALID_HANDLE_VALUE) {
+        return;
+    }
+
+    do {
+        if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+            if (type & WalkFolder) {
+                if (wcscmp(ffd.cFileName, L".") == 0 || wcscmp(ffd.cFileName, L"..") == 0) {
+                    continue;
+                }
+                walker(dirPath + L"\\" + ffd.cFileName, WalkFolder);
+            }
+        } else if (type & WalkFile) {
+            walker(dirPath + L"\\" + ffd.cFileName, WalkFile);
+        }
+    } while (FindNextFile(hFind, &ffd) != 0);
+
+    auto dwError = GetLastError();
+    if (dwError != ERROR_NO_MORE_FILES) {
+        MMKVError("WalkInDir fail %d", dwError);
+    }
+
+    FindClose(hFind);
+}
+
 } // namespace mmkv
 
 std::wstring string2MMKVPath_t(const std::string &str) {
@@ -313,4 +524,13 @@ std::wstring string2MMKVPath_t(const std::string &str) {
     return result;
 }
 
+std::string MMKVPath_t2String(const MMKVPath_t &str) {
+    auto length = WideCharToMultiByte(CP_UTF8, 0, str.c_str(), -1, nullptr, 0, 0, 0);
+    auto buffer = new char[length];
+    WideCharToMultiByte(CP_UTF8, 0, str.c_str(), -1, buffer, length, 0, 0);
+    string result(buffer);
+    delete[] buffer;
+    return result;
+}
+
 #endif // MMKV_WIN32

package/MMKV/Core/aes/openssl/openssl_aes.h

@@ -89,13 +89,13 @@ int AES_C_set_decrypt_key(const uint8_t *userKey, const int bits, void *key);
 void AES_C_encrypt(const uint8_t *in, uint8_t *out, const void *key);
 void AES_C_decrypt(const uint8_t *in, uint8_t *out, const void *key);
 
-} // namespace openssl
-
 extern aes_set_encrypt_t AES_set_encrypt_key;
 extern aes_set_decrypt_t AES_set_decrypt_key;
 extern aes_encrypt_t AES_encrypt;
 extern aes_decrypt_t AES_decrypt;
 
+} // namespace openssl
+
 #endif // __ARM_MAX_ARCH__ <= 7
 
 #endif // __linux__

package/MMKV/Core/aes/openssl/openssl_aes_core.cpp

@@ -43,6 +43,8 @@
 
 #ifndef MMKV_DISABLE_CRYPT
 
+namespace openssl {
+
 #if (__ARM_MAX_ARCH__ > 7) && defined(__linux__)
 
 aes_set_encrypt_t AES_set_encrypt_key = openssl::AES_C_set_encrypt_key;
@@ -54,8 +56,6 @@ aes_encrypt_t AES_decrypt = openssl::AES_C_decrypt;
 
 #if (__ARM_MAX_ARCH__ <= 0) || (__ARM_MAX_ARCH__ > 7 && defined(__linux__))
 
-namespace openssl {
-
 /*-
 Te0[x] = S [x].[02, 01, 01, 03];
 Te1[x] = S [x].[03, 02, 01, 01];
@@ -1037,8 +1037,8 @@ void AES_C_decrypt(const uint8_t *in, uint8_t *out, const void *k) {
     PUTU32(out + 12, s3);
 }
 
-} // namespace openssl
-
 #endif // (__ARM_MAX_ARCH__ < 0) || (__ARM_MAX_ARCH__ > 7 && defined(__linux__))
 
+} // namespace openssl
+
 #endif // MMKV_DISABLE_CRYPT

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.2.10-brightgreen.svg)](https://github.com/Tencent/MMKV/releases)
+[![Release Version](https://img.shields.io/badge/release-1.2.12-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,12 +28,12 @@ Add the following lines to `build.gradle` on your app module:
 
 ```gradle
 dependencies {
-    implementation 'com.tencent:mmkv-static:1.2.10'
-    // replace "1.2.10" with any available version
+    implementation 'com.tencent:mmkv:1.2.12'
+    // replace "1.2.12" with any available version
 }
 ```
 
-Starting from v1.2.8, MMKV has been **migrated to Maven Central**. Older versions (<= v1.2.7) are still available on JCenter.  
+Starting from v1.2.8, MMKV has been **migrated to Maven Central**.  
 For other installation options, see [Android Setup](https://github.com/Tencent/MMKV/wiki/android_setup).
 
 ### Quick Tutorial

package/README.md

@@ -37,13 +37,13 @@
 ## Sponsors
 
 <div align="right">
-  <a href="https://getstream.io/chat/react-native-chat/tutorial/?utm_source=github&utm_medium=github_repo_content_ad&utm_content=developer&utm_campaign=github_sept2021_reactnativechat">
+  <a href="https://getstream.io/chat/react-native-chat/tutorial/?utm_source=Github&utm_medium=Github_Repo_Content_Ad&utm_content=Developer&utm_campaign=Github_Jan2022_ReactNative&utm_term=react-native-mmkv">
     <img align="right" src="https://theme.zdassets.com/theme_assets/9442057/efc3820e436f9150bc8cf34267fff4df052a1f9c.png" height="40" />
   </a>
 </div>
 
 react-native-mmkv is sponsored by **getstream.io**. <br/>
-[Try the React Native Chat tutorial 💬](https://getstream.io/chat/react-native-chat/tutorial/?utm_source=github&utm_medium=github_repo_content_ad&utm_content=developer&utm_campaign=github_sept2021_reactnativechat)
+[Try the React Native Chat tutorial 💬](https://getstream.io/chat/react-native-chat/tutorial/?utm_source=Github&utm_medium=Github_Repo_Content_Ad&utm_content=Developer&utm_campaign=Github_Jan2022_ReactNative&utm_term=react-native-mmkv)
 
 ## Benchmark
 
@@ -57,25 +57,19 @@ react-native-mmkv is sponsored by **getstream.io**. <br/>
 
 ## Installation
 
-```sh
-npm install react-native-mmkv
-```
-
-### iOS
-
-iOS installation is automatic, just run:
+### React Native
 
 ```sh
+yarn add react-native-mmkv
 cd ios && pod install
 ```
 
-### Android
-
-To correctly initialize MMKV on Android, please follow the [Installation guide](./INSTALL.md).
-
 ### Expo
 
-See this comment for more information: [mrousavy/react-native-mmkv#157 (comment)](https://github.com/mrousavy/react-native-mmkv/issues/157#issuecomment-960647481).
+```sh
+expo install react-native-mmkv
+expo prebuild
+```
 
 ## Usage
 
@@ -166,8 +160,10 @@ const userObject = JSON.parse(jsonUser)
 * [Hooks](./docs/HOOKS.md)
 * [Value-change Listeners](./docs/LISTENERS.md)
 * [Migrate from AsyncStorage](./docs/MIGRATE_FROM_ASYNC_STORAGE.md)
-* [Using MMKV with redux-persis](./docs/WRAPPER_REDUX.md)
+* [Using MMKV with redux-persist](./docs/WRAPPER_REDUX.md)
 * [Using MMKV with mobx-persist-storage](./docs/WRAPPER_MOBX.md)
+* [Using MMKV with mobx-persist](./docs/WRAPPER_MOBXPERSIST.md)
+* [How is this library different from **react-native-mmkv-storage**?](https://github.com/mrousavy/react-native-mmkv/issues/100#issuecomment-886477361)
 
 ## Limitations
 

package/android/CMakeLists.txt

@@ -17,10 +17,6 @@ if(${REACT_NATIVE_VERSION} LESS 66)
                 INCLUDE_JSI_CPP
                 "${NODE_MODULES_DIR}/react-native/ReactCommon/jsi/jsi/jsi.cpp"
         )
-        set (
-                INCLUDE_JSIDYNAMIC_CPP
-                "${NODE_MODULES_DIR}/react-native/ReactCommon/jsi/jsi/JSIDynamic.cpp"
-        )
 endif()
 
 add_library(reactnativemmkv  # <-- Library name
@@ -28,7 +24,6 @@ add_library(reactnativemmkv  # <-- Library name
         src/main/cpp/cpp-adapter.cpp
         src/main/cpp/MmkvHostObject.cpp
         ${INCLUDE_JSI_CPP} # only on older RN versions
-        ${INCLUDE_JSIDYNAMIC_CPP} # only on older RN versions
 )
 
 set_target_properties(
@@ -38,7 +33,7 @@ set_target_properties(
         POSITION_INDEPENDENT_CODE ON
 )
 
-file (GLOB LIBRN_DIR "${BUILD_DIR}/react-native-0*/jni/${ANDROID_ABI}")
+file (GLOB LIBRN_DIR "${PREBUILT_DIR}/${ANDROID_ABI}")
 
 find_library(
         log-lib

package/android/build.gradle

@@ -46,6 +46,12 @@ def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties['Mmkv_' + name]).toInteger()
 }
 
+def reactNativeArchitectures() {
+    def value = project.getProperties().get("reactNativeArchitectures")
+    return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def sourceBuild = false
 def defaultDir = null
 def androidSourcesDir = null
 def androidSourcesName = 'React Native sources'
@@ -53,6 +59,10 @@ def androidSourcesName = 'React Native sources'
 if (rootProject.ext.has('reactNativeAndroidRoot')) {
   defaultDir = rootProject.ext.get('reactNativeAndroidRoot')
   androidSourcesDir = defaultDir.parentFile.toString()
+} else if (findProject(':ReactAndroid') != null) {
+    sourceBuild = true
+    defaultDir = project(':ReactAndroid').projectDir
+    androidSourcesDir = defaultDir.parentFile.toString()
 } else {
   defaultDir = file("$nodeModules/react-native/android")
   androidSourcesDir = defaultDir.parentFile.toString()
@@ -64,6 +74,11 @@ if (!defaultDir.exists()) {
     )
 }
 
+def prebuiltDir = sourceBuild
+    ? "$nodeModules/react-native/ReactAndroid/src/main/jni/prebuilt/lib"
+    : "$buildDir/react-native-0*/jni"
+
+
 def reactProperties = new Properties()
 file("$nodeModules/react-native/ReactAndroid/gradle.properties").withInputStream { reactProperties.load(it) }
 def REACT_NATIVE_VERSION = reactProperties.getProperty("VERSION_NAME").split("\\.")[1].toInteger()
@@ -81,12 +96,15 @@ android {
     externalNativeBuild {
       cmake {
         cppFlags "-fexceptions", "-frtti", "-std=c++1y", "-DONANDROID"
-        abiFilters 'x86', 'x86_64', 'armeabi-v7a', 'arm64-v8a'
         arguments '-DANDROID_STL=c++_shared',
                   "-DREACT_NATIVE_VERSION=${REACT_NATIVE_VERSION}",
-                  "-DNODE_MODULES_DIR=${nodeModules}"
+                  "-DNODE_MODULES_DIR=${nodeModules}",
+                  "-DPREBUILT_DIR=${prebuiltDir}"
       }
     }
+    ndk {
+      abiFilters (*reactNativeArchitectures())
+    }
   }
 
   dexOptions {
@@ -141,8 +159,10 @@ dependencies {
   //noinspection GradleDynamicVersion
   extractJNI("com.facebook.fbjni:fbjni:+")
 
-  def rnAAR = fileTree("${defaultDir.toString()}").matching({ it.include "**/**/*.aar" }).singleFile
-  extractJNI(files(rnAAR))
+  if (!sourceBuild) {
+    def rnAAR = fileTree("${defaultDir.toString()}").matching({ it.include "**/**/*.aar" }).singleFile
+    extractJNI(files(rnAAR))
+  }
 }
 
 // third-party-ndk deps headers
@@ -311,10 +331,22 @@ task extractJNIFiles {
 }
 extractJNIFiles.mustRunAfter extractAARHeaders
 
-tasks.whenTaskAdded { task ->
-  if (!task.name.contains('Clean') && (task.name.contains('externalNative') || task.name.contains('CMake'))) {
-    task.dependsOn(extractAARHeaders)
-    task.dependsOn(extractJNIFiles)
-    task.dependsOn(prepareThirdPartyNdkHeaders)
+def nativeBuildDependsOn(dependsOnTask, variant) {
+  def buildTasks = tasks.findAll({ task ->
+      !task.name.contains("Clean") && (task.name.contains("externalNative") || task.name.contains("CMake")) })
+  if (variant != null) {
+    buildTasks = buildTasks.findAll({ task -> task.name.contains(variant) })
+  }
+  buildTasks.forEach { task -> task.dependsOn(dependsOnTask) }
+}
+
+afterEvaluate {
+  if (sourceBuild) {
+    nativeBuildDependsOn(":ReactAndroid:packageReactNdkDebugLibsForBuck", "Debug")
+    nativeBuildDependsOn(":ReactAndroid:packageReactNdkReleaseLibsForBuck", "Rel")
+  } else {
+    nativeBuildDependsOn(extractAARHeaders, null)
+    nativeBuildDependsOn(extractJNIFiles, null)
+    nativeBuildDependsOn(prepareThirdPartyNdkHeaders, null)
   }
 }

package/android/src/main/java/com/reactnativemmkv/MmkvModule.java

@@ -1,24 +1,49 @@
 package com.reactnativemmkv;
 
+import android.util.Log;
+
 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 
 import com.facebook.react.bridge.JavaScriptContextHolder;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.module.annotations.ReactModule;
 
+@ReactModule(name = MmkvModule.NAME)
 public class MmkvModule extends ReactContextBaseJavaModule {
-  static {
-    System.loadLibrary("reactnativemmkv");
-  }
+  public static final String NAME = "MMKV";
 
-  private static native void nativeInstall(long jsiPtr, String path);
-
-  public static void install(JavaScriptContextHolder jsContext, String storageDirectory) {
-    nativeInstall(jsContext.get(), storageDirectory);
+  public MmkvModule(ReactApplicationContext reactContext) {
+    super(reactContext);
   }
 
   @NonNull
   @Override
   public String getName() {
-    return "MMKV";
+    return NAME;
   }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean install(@Nullable String rootDirectory) {
+    try {
+      Log.i(NAME, "Loading C++ library...");
+      System.loadLibrary("reactnativemmkv");
+
+      JavaScriptContextHolder jsContext = getReactApplicationContext().getJavaScriptContextHolder();
+      if (rootDirectory == null) {
+        rootDirectory = getReactApplicationContext().getFilesDir().getAbsolutePath() + "/mmkv";
+      }
+      Log.i(NAME, "Installing MMKV JSI Bindings for MMKV root directory: " + rootDirectory);
+      nativeInstall(jsContext.get(), rootDirectory);
+      Log.i(NAME, "Successfully installed MMKV JSI Bindings!");
+      return true;
+    } catch (Exception exception) {
+      Log.e(NAME, "Failed to install MMKV JSI Bindings!", exception);
+      return false;
+    }
+  }
+
+  private static native void nativeInstall(long jsiPtr, String path);
 }