@react-native-ohos/react-native-mmkv 3.3.1-1

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Python/libmmkv_python.cpp

@@ -0,0 +1,454 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2020 THL A29 Limited, a Tencent company.
+ * All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use
+ * this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *       https://opensource.org/licenses/BSD-3-Clause
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <MMKV/MMKV.h>
+#include <pybind11/functional.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#ifdef MMKV_WIN32
+#include <basetsd.h>
+typedef SSIZE_T ssize_t;
+#endif
+
+using namespace mmkv;
+using namespace std;
+namespace py = pybind11;
+
+static MMBuffer pyBytes2MMBuffer(const py::bytes &bytes) {
+    char *buffer = nullptr;
+    ssize_t length = 0;
+    if (PYBIND11_BYTES_AS_STRING_AND_SIZE(bytes.ptr(), &buffer, &length) == 0) {
+        return {buffer, static_cast<size_t>(length), MMBufferNoCopy};
+    }
+    return MMBuffer(0);
+}
+
+static function<void(MMKVLogLevel level, const char *file, int line, const char *function, const string &message)>
+    g_logHandler = nullptr;
+static void MyLogHandler(MMKVLogLevel level, const char *file, int line, const char *function, const string &message) {
+    if (g_logHandler) {
+        g_logHandler(level, file, line, function, message);
+    }
+}
+
+static function<MMKVRecoverStrategic(const string &mmapID, MMKVErrorType errorType)> g_errorHandler = nullptr;
+static MMKVRecoverStrategic MyErrorHandler(const string &mmapID, MMKVErrorType errorType) {
+    if (g_errorHandler) {
+        return g_errorHandler(mmapID, errorType);
+    }
+    return OnErrorDiscard;
+}
+
+static function<void(const string &mmapID)> g_contentHandler = nullptr;
+static void MyContentChangeHandler(const std::string &mmapID) {
+    if (g_contentHandler) {
+        g_contentHandler(mmapID);
+    }
+}
+
+PYBIND11_MODULE(mmkv, m) {
+    m.doc() = "An efficient, small key-value storage framework developed by WeChat Team.";
+
+    py::enum_<MMKVMode>(m, "MMKVMode", py::arithmetic())
+        .value("SingleProcess", MMKVMode::MMKV_SINGLE_PROCESS)
+        .value("MultiProcess", MMKVMode::MMKV_MULTI_PROCESS)
+        .value("ReadOnly", MMKVMode::MMKV_READ_ONLY)
+        .export_values();
+
+    py::enum_<MMKVLogLevel>(m, "MMKVLogLevel")
+        .value("NoLog", MMKVLogLevel::MMKVLogNone)
+        .value("Debug", MMKVLogLevel::MMKVLogDebug)
+        .value("Info", MMKVLogLevel::MMKVLogInfo)
+        .value("Warning", MMKVLogLevel::MMKVLogWarning)
+        .value("Error", MMKVLogLevel::MMKVLogError)
+        .export_values();
+
+    py::enum_<SyncFlag>(m, "SyncFlag")
+        .value("Sync", SyncFlag::MMKV_SYNC)
+        .value("ASync", SyncFlag::MMKV_ASYNC)
+        .export_values();
+
+    py::enum_<MMKVRecoverStrategic>(m, "MMKVRecoverStrategic")
+        .value("OnErrorDiscard", MMKVRecoverStrategic::OnErrorDiscard)
+        .value("OnErrorRecover", MMKVRecoverStrategic::OnErrorRecover)
+        .export_values();
+
+    py::enum_<MMKVErrorType>(m, "MMKVErrorType")
+        .value("CRCCheckFail", MMKVErrorType::MMKVCRCCheckFail)
+        .value("FileLength", MMKVErrorType::MMKVFileLength)
+        .export_values();
+
+    py::class_<NameSpace, unique_ptr<NameSpace>> clsNameSpace(m, "NameSpace");
+
+    clsNameSpace.def("mmkvWithID", &NameSpace::mmkvWithID,
+                "Parameters:\n"
+                "  mmapID: all instances of the same mmapID share the same data and file storage\n"
+                "  mode: pass MMKVMode.MultiProcess for a multi-process MMKV\n"
+                "  cryptKey: pass a non-empty string for an encrypted MMKV, 32 bytes at most\n"
+                "  expectedCapacity: the file size you expected when opening or creating file\n"
+                "  aes256: use AES 256 key length",
+                py::arg("mmapID"), py::arg("mode") = MMKV_SINGLE_PROCESS, py::arg("cryptKey") = string(),
+                py::arg("expectedCapacity") = 0, py::arg("aes256") = false);
+
+    clsNameSpace.def("rootDir", &NameSpace::getRootDir, "get the root directory of NameSpace");
+
+    clsNameSpace.def("backupOneToDirectory", &NameSpace::backupOneToDirectory,
+        "backup one MMKV instance from the root dir of NameSpace to dstDir",
+        py::arg("mmapID"), py::arg("dstDir"));
+
+    clsNameSpace.def("restoreOneFromDirectory", &NameSpace::restoreOneFromDirectory,
+        "restore one MMKV instance from srcDir to dstDir to the root dir of NameSpace",
+        py::arg("mmapID"), py::arg("srcDir"));
+
+    clsNameSpace.def("backupAllToDirectory", &NameSpace::backupAllToDirectory,
+        "backup all MMKV instance from the root dir of NameSpace to dstDir", py::arg("dstDir"));
+
+    clsNameSpace.def("restoreAllFromDirectory", &NameSpace::restoreAllFromDirectory,
+        "restore all MMKV instance from srcDir to the root dir of NameSpace", py::arg("srcDir"));
+
+    clsNameSpace.def("removeStorage", &NameSpace::removeStorage);
+    clsNameSpace.def("isFileValid", &NameSpace::isFileValid);
+    clsNameSpace.def("checkExist", &NameSpace::checkExist);
+
+    py::class_<MMKV, unique_ptr<MMKV, py::nodelete>> clsMMKV(m, "MMKV");
+
+    // TODO: not working
+    // clsMMKV.def(py::init(&MMKV::mmkvWithID),
+    //             py::arg("mmapID"),
+    //             py::arg("mode") = MMKV_SINGLE_PROCESS,
+    //             py::arg("cryptKey") = (string*) nullptr,
+    //             py::arg("rootDir") = (string*) nullptr);
+
+    clsMMKV.def(py::init([](const string &mmapID, MMKVMode mode, const string &cryptKey, const MMKVPath_t &rootDir,
+                            const size_t expectedCapacity, bool aes256) {
+                    string *cryptKeyPtr = (cryptKey.length() > 0) ? (string *) &cryptKey : nullptr;
+                    MMKVPath_t *rootDirPtr = (rootDir.length() > 0) ? (MMKVPath_t *) &rootDir : nullptr;
+                    return MMKV::mmkvWithID(mmapID, mode, cryptKeyPtr, rootDirPtr, expectedCapacity, aes256);
+                }),
+                "Parameters:\n"
+                "  mmapID: all instances of the same mmapID share the same data and file storage\n"
+                "  mode: pass MMKVMode.MultiProcess for a multi-process MMKV\n"
+                "  cryptKey: pass a non-empty string for an encrypted MMKV, 32 bytes at most\n"
+                "  rootDir: custom root directory",
+                "  expectedCapacity: the file size you expected when opening or creating file\n",
+                "  aes256: use AES 256 key length",
+                py::arg("mmapID"), py::arg("mode") = MMKV_SINGLE_PROCESS,
+                py::arg("cryptKey") = string(), py::arg("rootDir") = string(),
+                py::arg("expectedCapacity") = 0, py::arg("aes256") = false);
+
+    clsMMKV.def("__eq__", [](MMKV &kv, const MMKV &other) { return kv.mmapID() == other.mmapID(); });
+
+    clsMMKV.def_static(
+        "initializeMMKV",
+        [](const MMKVPath_t &rootDir, MMKVLogLevel logLevel, decltype(g_logHandler) logHandler) {
+            if (logHandler) {
+                g_logHandler = std::move(logHandler);
+                MMKV::initializeMMKV(rootDir, logLevel, MyLogHandler);
+            } else {
+                MMKV::initializeMMKV(rootDir, logLevel, nullptr);
+            }
+        },
+        "must call this before getting any MMKV instance", py::arg("rootDir"), py::arg("logLevel") = MMKVLogNone,
+        py::arg("log_handler") = nullptr);
+
+    clsMMKV.def_static(
+        "defaultMMKV",
+        [](MMKVMode mode, const string &cryptKey, bool aes256) {
+            string *cryptKeyPtr = (cryptKey.length() > 0) ? (string *) &cryptKey : nullptr;
+            return MMKV::defaultMMKV(mode, cryptKeyPtr, aes256);
+        },
+        "a generic purpose instance", py::arg("mode") = MMKV_SINGLE_PROCESS, py::arg("cryptKey") = string(),
+        py::arg("aes256") = false);
+
+    clsMMKV.def_static("nameSpace", &MMKV::nameSpace, "get a namespace with custom root dir");
+    clsMMKV.def_static("defaultNameSpace", &MMKV::defaultNameSpace, "identical with the original MMKV with the global root dir");
+
+    clsMMKV.def("mmapID", &MMKV::mmapID);
+    clsMMKV.def("isInterProcess", &MMKV::isMultiProcess);
+
+    clsMMKV.def("cryptKey", &MMKV::cryptKey);
+    clsMMKV.def("reKey", &MMKV::reKey,
+                "transform plain text into encrypted text, or vice versa with an empty cryptKey\n"
+                "Parameters:\n"
+                "  newCryptKey: 32 bytes at most\n"
+                "  aes256: use AES 256 key length",
+                py::arg("newCryptKey"), py::arg("aes256") = false);
+    clsMMKV.def("checkReSetCryptKey", &MMKV::checkReSetCryptKey,
+                "just reset cryptKey (will not encrypt or decrypt anything),\n"
+                "usually you should call this method after other process reKey() a multi-process mmkv",
+                py::arg("newCryptKey"), py::arg("aes256") = false);
+
+    // TODO: Doesn't work, why?
+    // clsMMKV.def("set", py::overload_cast<bool, const string&>(&MMKV::set), py::arg("value"), py::arg("key"));
+    clsMMKV.def("set", (bool (MMKV::*)(bool, string_view))(&MMKV::set), "encode a boolean value", py::arg("value"),
+                py::arg("key"));
+    clsMMKV.def("set", (bool (MMKV::*)(bool, string_view, uint32_t))(&MMKV::set),
+                "encode a boolean value with expiration", py::arg("value"), py::arg("key"), py::arg("expireDuration"));
+    clsMMKV.def("set", (bool (MMKV::*)(int32_t, string_view))(&MMKV::set), "encode an int32 value", py::arg("value"),
+                py::arg("key"));
+    clsMMKV.def("set", (bool (MMKV::*)(int32_t, string_view, uint32_t))(&MMKV::set),
+                "encode an int32 value with expiration", py::arg("value"), py::arg("key"), py::arg("expireDuration"));
+    clsMMKV.def("set", (bool (MMKV::*)(uint32_t, string_view))(&MMKV::set), "encode an unsigned int32 value",
+                py::arg("value"), py::arg("key"));
+    clsMMKV.def("set", (bool (MMKV::*)(uint32_t, string_view, uint32_t))(&MMKV::set),
+                "encode an unsigned int32 value with expiration", py::arg("value"), py::arg("key"),
+                py::arg("expireDuration"));
+    clsMMKV.def("set", (bool (MMKV::*)(int64_t, string_view))(&MMKV::set), "encode an int64 value", py::arg("value"),
+                py::arg("key"));
+    clsMMKV.def("set", (bool (MMKV::*)(int64_t, string_view, uint32_t))(&MMKV::set),
+                "encode an int64 value with expiration", py::arg("value"), py::arg("key"), py::arg("expireDuration"));
+    clsMMKV.def("set", (bool (MMKV::*)(uint64_t, string_view))(&MMKV::set), "encode an unsigned int64 value",
+                py::arg("value"), py::arg("key"));
+    clsMMKV.def("set", (bool (MMKV::*)(uint64_t, string_view, uint32_t))(&MMKV::set),
+                "encode an unsigned int64 value with expiration", py::arg("value"), py::arg("key"),
+                py::arg("expireDuration"));
+    //clsMMKV.def("set", (bool (MMKV::*)(float, string_view))(&MMKV::set), py::arg("value"), py::arg("key"));
+    clsMMKV.def("set", (bool (MMKV::*)(double, string_view))(&MMKV::set), "encode a float/double value",
+                py::arg("value"), py::arg("key"));
+    clsMMKV.def("set", (bool (MMKV::*)(double, string_view, uint32_t))(&MMKV::set),
+                "encode a float/double value with expiration", py::arg("value"), py::arg("key"),
+                py::arg("expireDuration"));
+    //clsMMKV.def("set", (bool (MMKV::*)(const char*, string_view))(&MMKV::set), py::arg("value"), py::arg("key"));
+    clsMMKV.def("set", (bool (MMKV::*)(const string &, string_view))(&MMKV::set),
+                "encode an UTF-8 String/bytes value", py::arg("value"), py::arg("key"));
+    clsMMKV.def("set", (bool (MMKV::*)(const string &, string_view, uint32_t))(&MMKV::set),
+                "encode an UTF-8 String/bytes value with expiration", py::arg("value"), py::arg("key"),
+                py::arg("expireDuration"));
+#if PY_MAJOR_VERSION >= 3
+    clsMMKV.def(
+        "set", [](MMKV &kv, const py::bytes &value, const string &key) { return kv.set(pyBytes2MMBuffer(value), key); },
+        "encode a bytes value", py::arg("value"), py::arg("key"));
+    clsMMKV.def(
+        "set",
+        [](MMKV &kv, const py::bytes &value, const string &key, uint32_t expireDuration) {
+            return kv.set(pyBytes2MMBuffer(value), key, expireDuration);
+        },
+        "encode a bytes value with expiration", py::arg("value"), py::arg("key"), py::arg("expireDuration"));
+#endif
+
+    clsMMKV.def("getBool", &MMKV::getBool, "decode a boolean value", py::arg("key"), py::arg("defaultValue") = false,
+                py::arg("hasValue") = nullptr);
+    clsMMKV.def("getInt", &MMKV::getInt32, "decode an int32 value", py::arg("key"), py::arg("defaultValue") = 0,
+                py::arg("hasValue") = nullptr);
+    clsMMKV.def("getUInt", &MMKV::getUInt32, "decode an unsigned int32 value", py::arg("key"),
+                py::arg("defaultValue") = 0, py::arg("hasValue") = nullptr);
+    clsMMKV.def("getLongInt", &MMKV::getInt64, "decode an int64 value", py::arg("key"), py::arg("defaultValue") = 0,
+                py::arg("hasValue") = nullptr);
+    clsMMKV.def("getLongUInt", &MMKV::getUInt64, "decode an unsigned int64 value", py::arg("key"),
+                py::arg("defaultValue") = 0, py::arg("hasValue") = nullptr);
+    //clsMMKV.def("getFloat", &MMKV::getFloat, py::arg("key"), py::arg("defaultValue") = 0);
+    clsMMKV.def("getFloat", &MMKV::getDouble, "decode a float/double value", py::arg("key"),
+                py::arg("defaultValue") = 0, py::arg("hasValue") = nullptr);
+    clsMMKV.def(
+        "getString",
+        [](MMKV &kv, const string &key, const string &defaultValue) {
+            string result;
+            if (kv.getString(key, result)) {
+                return result;
+            }
+            return defaultValue;
+        },
+        "decode an UTF-8 String/bytes value", py::arg("key"), py::arg("defaultValue") = string());
+
+    clsMMKV.def(
+        "getBytes",
+        [](MMKV &kv, const string &key, const py::bytes &defaultValue) {
+            MMBuffer result = kv.getBytes(key);
+            if (result.length() > 0) {
+                return py::bytes((const char *) result.getPtr(), result.length());
+            }
+            return defaultValue;
+        },
+        "decode a bytes value", py::arg("key"), py::arg("defaultValue") = py::bytes());
+
+    clsMMKV.def("__contains__", &MMKV::containsKey, py::arg("key"));
+    clsMMKV.def("keys", &MMKV::allKeys, py::arg("filterExpire") = false);
+
+    clsMMKV.def("count", &MMKV::count, py::arg("filterExpire") = false);
+    clsMMKV.def("totalSize", &MMKV::totalSize);
+    clsMMKV.def("actualSize", &MMKV::actualSize);
+
+    clsMMKV.def("remove", &MMKV::removeValueForKey, py::arg("key"));
+    clsMMKV.def("remove", &MMKV::removeValuesForKeys, py::arg("keys"));
+    clsMMKV.def("clearAll", &MMKV::clearAll, py::arg("keepSpace") = false, "remove all key-values");
+    clsMMKV.def("trim", &MMKV::trim, "call this method after lots of removing if you care about disk usage");
+    clsMMKV.def("importFrom", &MMKV::importFrom, "import all key-value items from others");
+    clsMMKV.def("clearMemoryCache", &MMKV::clearMemoryCache, "call this method if you are facing memory-warning",
+        py::arg("keepSpace") = false);
+
+    clsMMKV.def("sync", &MMKV::sync, py::arg("flag") = MMKV_SYNC,
+                "this call is not necessary unless you worry about unexpected shutdown of the machine (running out of "
+                "battery, etc.)");
+
+    clsMMKV.def("enableAutoKeyExpire", &MMKV::enableAutoKeyExpire, py::arg("expireDurationInSecond"),
+                "turn on auto key expiration, passing 0 means never expire");
+    clsMMKV.def("disableAutoKeyExpire", &MMKV::disableAutoKeyExpire, "turn off auto key expiration");
+
+    clsMMKV.def("enableCompareBeforeSet", &MMKV::enableCompareBeforeSet, "turn on compare before set/update");
+    clsMMKV.def("disableCompareBeforeSet", &MMKV::disableCompareBeforeSet, "turn off compare before set/update");
+
+    clsMMKV.def("lock", &MMKV::lock, "get exclusive access, won't return until the lock is obtained");
+    clsMMKV.def("unlock", &MMKV::unlock);
+    clsMMKV.def("try_lock", &MMKV::try_lock, "try to get exclusive access");
+
+    clsMMKV.def("isMultiProcess", &MMKV::isMultiProcess, "check multi-process mode");
+    clsMMKV.def("isReadOnly", &MMKV::isReadOnly, "check read-only mode");
+
+    clsMMKV.def("close", &MMKV::close, "close the instance");
+
+    clsMMKV.def_static("rootDir", &MMKV::getRootDir, "get the root directory of MMKV");
+
+    // log callback handler
+    clsMMKV.def_static(
+        "registerLogHandler",
+        [](decltype(g_logHandler) callback) {
+            g_logHandler = std::move(callback);
+            MMKV::registerLogHandler(MyLogHandler);
+        },
+        "call this method to redirect MMKV's log,\n"
+        "must call MMKV.unRegisterLogHandler() or MMKV.onExit() before exit\n"
+        "Parameters:\n"
+        "  log_handler: (logLevel: mmkv.MMKVLogLevel, file: str, line: int, function: str, message: str) -> None",
+        py::arg("log_handler"));
+    clsMMKV.def_static(
+        "unRegisterLogHandler",
+        [] {
+            g_logHandler = nullptr;
+            MMKV::unRegisterLogHandler();
+        },
+        "If you have registered a log handler, you must call this method or MMKV.onExit() before exit. "
+        "Otherwise your app/script won't exit properly.");
+
+    // error callback handler
+    clsMMKV.def_static(
+        "registerErrorHandler",
+        [](decltype(g_errorHandler) callback) {
+            g_errorHandler = std::move(callback);
+            MMKV::registerErrorHandler(MyErrorHandler);
+        },
+        "call this method to handle MMKV failure,\n"
+        "must call MMKV.unRegisterErrorHandler() or MMKV.onExit() before exit\n"
+        "Parameters:\n"
+        "  error_handler: (mmapID: str, errorType: mmkv.MMKVErrorType) -> mmkv.MMKVRecoverStrategic",
+        py::arg("error_handler"));
+    clsMMKV.def_static(
+        "unRegisterErrorHandler",
+        [] {
+            g_errorHandler = nullptr;
+            MMKV::unRegisterErrorHandler();
+        },
+        "If you have registered an error handler, you must call this method or MMKV.onExit() before exit. "
+        "Otherwise your app/script won't exit properly.");
+
+    // content change callback handler
+    clsMMKV.def("checkContentChanged", &MMKV::checkContentChanged, "check if content been changed by other process");
+    clsMMKV.def_static(
+        "registerContentChangeHandler",
+        [](decltype(g_contentHandler) callback) {
+            g_contentHandler = std::move(callback);
+            MMKV::registerContentChangeHandler(MyContentChangeHandler);
+        },
+        "register a content change handler,\n"
+        "get notified when an MMKV instance has been changed by other process (not guarantee real-time notification),\n"
+        "must call MMKV.unRegisterContentChangeHandler() or MMKV.onExit() before exit\n"
+        "Parameters:\n"
+        "  content_change_handler: (mmapID: str) -> None",
+        py::arg("content_change_handler"));
+    clsMMKV.def_static(
+        "unRegisterContentChangeHandler",
+        [] {
+            g_contentHandler = nullptr;
+            MMKV::unRegisterContentChangeHandler();
+        },
+        "If you have registered a content change handler, you must call this method or MMKV.onExit() before exit. "
+        "Otherwise your app/script won't exit properly.");
+
+    clsMMKV.def_static(
+        "onExit",
+        [] {
+            MMKV::onExit();
+            g_logHandler = nullptr;
+            g_errorHandler = nullptr;
+            g_contentHandler = nullptr;
+        },
+        "call this method before exit, especially if you have registered any callback handlers");
+
+    clsMMKV.def_static(
+        "backupOneToDirectory",
+        [](const string &mmapID, const MMKVPath_t &dstDir, const MMKVPath_t &srcDir) {
+            MMKVPath_t *srcDirPtr = (!srcDir.empty()) ? (MMKVPath_t *) &srcDir : nullptr;
+            return MMKV::backupOneToDirectory(mmapID, dstDir, srcDirPtr);
+        },
+        "backup one MMKV instance from srcDir (default to the root dir of MMKV) to dstDir", py::arg("mmapID"),
+        py::arg("dstDir"), py::arg("srcDir") = MMKVPath_t());
+
+    clsMMKV.def_static(
+        "restoreOneFromDirectory",
+        [](const string &mmapID, const MMKVPath_t &srcDir, const MMKVPath_t &dstDir) {
+            MMKVPath_t *dstDirPtr = (!dstDir.empty()) ? (MMKVPath_t *) &dstDir : nullptr;
+            return MMKV::restoreOneFromDirectory(mmapID, srcDir, dstDirPtr);
+        },
+        "restore one MMKV instance from srcDir to dstDir (default to the root dir of MMKV)", py::arg("mmapID"),
+        py::arg("srcDir"), py::arg("dstDir") = MMKVPath_t());
+
+    clsMMKV.def_static(
+        "backupAllToDirectory",
+        [](const MMKVPath_t &dstDir, const MMKVPath_t &srcDir) {
+            MMKVPath_t *srcDirPtr = (!srcDir.empty()) ? (MMKVPath_t *) &srcDir : nullptr;
+            return MMKV::backupAllToDirectory(dstDir, srcDirPtr);
+        },
+        "backup all MMKV instance from srcDir (default to the root dir of MMKV) to dstDir", py::arg("dstDir"),
+        py::arg("srcDir") = MMKVPath_t());
+
+    clsMMKV.def_static(
+        "restoreAllFromDirectory",
+        [](const MMKVPath_t &srcDir, const MMKVPath_t &dstDir) {
+            MMKVPath_t *dstDirPtr = (!dstDir.empty()) ? (MMKVPath_t *) &dstDir : nullptr;
+            return MMKV::restoreAllFromDirectory(srcDir, dstDirPtr);
+        },
+        "restore all MMKV instance from srcDir to dstDir (default to the root dir of MMKV)", py::arg("srcDir"),
+        py::arg("dstDir") = MMKVPath_t());
+
+    clsMMKV.def_static(
+        "removeStorage",
+        [](const string &mmapID, const MMKVPath_t &rootDir) {
+            MMKVPath_t *rootDirPtr = (!rootDir.empty()) ? (MMKVPath_t *) &rootDir : nullptr;
+            return MMKV::removeStorage(mmapID, rootDirPtr);
+        },
+        "remove the storage of the MMKV, including the data file & meta file (.crc)", py::arg("mmapID"),
+        py::arg("rootDir") = MMKVPath_t());
+
+    clsMMKV.def_static("isFileValid",
+       [](const string &mmapID, const MMKVPath_t &rootDir) {
+           MMKVPath_t *rootDirPtr = (!rootDir.empty()) ? (MMKVPath_t *) &rootDir : nullptr;
+           return MMKV::isFileValid(mmapID, rootDirPtr);
+       },
+       "detect if the MMKV file is valid or not", py::arg("mmapID"),
+       py::arg("rootDir") = MMKVPath_t());
+
+    clsMMKV.def_static("checkExist",
+                       [](const string &mmapID, const MMKVPath_t &rootDir) {
+                           MMKVPath_t *rootDirPtr = (!rootDir.empty()) ? (MMKVPath_t *) &rootDir : nullptr;
+                           return MMKV::checkExist(mmapID, rootDirPtr);
+                       },
+                       "check if the MMKV file is exist or not", py::arg("mmapID"),
+                       py::arg("rootDir") = MMKVPath_t());
+}

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Python/pybind11/.appveyor.yml

@@ -0,0 +1,35 @@
+version: 1.0.{build}
+image:
+- Visual Studio 2017
+test: off
+skip_branch_with_pr: true
+build:
+  parallel: true
+platform:
+- x86
+environment:
+  matrix:
+  - PYTHON: 38
+    CONFIG: Debug
+install:
+- ps: |
+    $env:CMAKE_GENERATOR = "Visual Studio 15 2017"
+    if ($env:PLATFORM -eq "x64") { $env:PYTHON = "$env:PYTHON-x64" }
+    $env:PATH = "C:\Python$env:PYTHON\;C:\Python$env:PYTHON\Scripts\;$env:PATH"
+    python -W ignore -m pip install --upgrade pip wheel
+    python -W ignore -m pip install pytest numpy --no-warn-script-location pytest-timeout
+- ps: |
+    Start-FileDownload 'https://gitlab.com/libeigen/eigen/-/archive/3.3.7/eigen-3.3.7.zip'
+    7z x eigen-3.3.7.zip -y > $null
+    $env:CMAKE_INCLUDE_PATH = "eigen-3.3.7;$env:CMAKE_INCLUDE_PATH"
+build_script:
+- cmake -G "%CMAKE_GENERATOR%" -A "%CMAKE_ARCH%"
+    -DCMAKE_CXX_STANDARD=14
+    -DPYBIND11_WERROR=ON
+    -DDOWNLOAD_CATCH=ON
+    -DCMAKE_SUPPRESS_REGENERATION=1
+    .
+- set MSBuildLogger="C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
+- cmake --build . --config %CONFIG% --target pytest -- /m /v:m /logger:%MSBuildLogger%
+- cmake --build . --config %CONFIG% --target cpptest -- /m /v:m /logger:%MSBuildLogger%
+on_failure: if exist "tests\test_cmake_build" type tests\test_cmake_build\*.log*

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Python/pybind11/.clang-format

@@ -0,0 +1,38 @@
+---
+# See all possible options and defaults with:
+# clang-format --style=llvm --dump-config
+BasedOnStyle: LLVM
+AccessModifierOffset: -4
+AllowShortLambdasOnASingleLine: true
+AlwaysBreakTemplateDeclarations: Yes
+BinPackArguments: false
+BinPackParameters: false
+BreakBeforeBinaryOperators: All
+BreakConstructorInitializers: BeforeColon
+ColumnLimit: 99
+CommentPragmas: 'NOLINT:.*|^ IWYU pragma:'
+IncludeBlocks: Regroup
+IndentCaseLabels: true
+IndentPPDirectives: AfterHash
+IndentWidth: 4
+Language: Cpp
+SpaceAfterCStyleCast: true
+Standard: Cpp11
+StatementMacros: ['PyObject_HEAD']
+TabWidth: 4
+IncludeCategories:
+  - Regex:           '<pybind11/.*'
+    Priority:        -1
+  - Regex:           'pybind11.h"$'
+    Priority:        1
+  - Regex:           '^".*/?detail/'
+    Priority:        1
+    SortPriority:    2
+  - Regex:           '^"'
+    Priority:        1
+    SortPriority:    3
+  - Regex:           '<[[:alnum:]._]+>'
+    Priority:        4
+  - Regex:           '.*'
+    Priority:        5
+...

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Python/pybind11/.clang-tidy

@@ -0,0 +1,77 @@
+FormatStyle: file
+
+Checks: |
+  *bugprone*,
+  *performance*,
+  clang-analyzer-optin.cplusplus.VirtualCall,
+  clang-analyzer-optin.performance.Padding,
+  cppcoreguidelines-init-variables,
+  cppcoreguidelines-prefer-member-initializer,
+  cppcoreguidelines-pro-type-static-cast-downcast,
+  cppcoreguidelines-slicing,
+  google-explicit-constructor,
+  llvm-namespace-comment,
+  misc-definitions-in-headers,
+  misc-misplaced-const,
+  misc-non-copyable-objects,
+  misc-static-assert,
+  misc-throw-by-value-catch-by-reference,
+  misc-uniqueptr-reset-release,
+  misc-unused-parameters,
+  modernize-avoid-bind,
+  modernize-loop-convert,
+  modernize-make-shared,
+  modernize-redundant-void-arg,
+  modernize-replace-auto-ptr,
+  modernize-replace-disallow-copy-and-assign-macro,
+  modernize-replace-random-shuffle,
+  modernize-shrink-to-fit,
+  modernize-use-auto,
+  modernize-use-bool-literals,
+  modernize-use-default-member-init,
+  modernize-use-emplace,
+  modernize-use-equals-default,
+  modernize-use-equals-delete,
+  modernize-use-noexcept,
+  modernize-use-nullptr,
+  modernize-use-override,
+  modernize-use-using,
+  readability-avoid-const-params-in-decls,
+  readability-braces-around-statements,
+  readability-const-return-type,
+  readability-container-size-empty,
+  readability-delete-null-pointer,
+  readability-else-after-return,
+  readability-implicit-bool-conversion,
+  readability-inconsistent-declaration-parameter-name,
+  readability-make-member-function-const,
+  readability-misplaced-array-index,
+  readability-non-const-parameter,
+  readability-qualified-auto,
+  readability-redundant-function-ptr-dereference,
+  readability-redundant-smartptr-get,
+  readability-redundant-string-cstr,
+  readability-simplify-subscript-expr,
+  readability-static-accessed-through-instance,
+  readability-static-definition-in-anonymous-namespace,
+  readability-string-compare,
+  readability-suspicious-call-argument,
+  readability-uniqueptr-delete-release,
+  -bugprone-easily-swappable-parameters,
+  -bugprone-exception-escape,
+  -bugprone-reserved-identifier,
+  -bugprone-unused-raii,
+
+CheckOptions:
+- key:             modernize-use-equals-default.IgnoreMacros
+  value:           false
+- key:             performance-for-range-copy.WarnOnAllAutoCopies
+  value:           true
+- key:             performance-inefficient-string-concatenation.StrictMode
+  value:           true
+- key:             performance-unnecessary-value-param.AllowedTypes
+  value:           'exception_ptr$;'
+- key:             readability-implicit-bool-conversion.AllowPointerConditions
+  value:           true
+
+HeaderFilterRegex: 'pybind11/.*h'

package/harmony/reactNativeMMKV/src/main/cpp/MMKV/Python/pybind11/.cmake-format.yaml

@@ -0,0 +1,73 @@
+parse:
+  additional_commands:
+    pybind11_add_module:
+      flags:
+        - THIN_LTO
+        - MODULE
+        - SHARED
+        - NO_EXTRAS
+        - EXCLUDE_FROM_ALL
+        - SYSTEM
+
+format:
+  line_width: 99
+  tab_size: 2
+
+  # If an argument group contains more than this many sub-groups
+  # (parg or kwarg groups) then force it to a vertical layout.
+  max_subgroups_hwrap: 2
+
+  # If a positional argument group contains more than this many
+  # arguments, then force it to a vertical layout.
+  max_pargs_hwrap: 6
+
+  # If a cmdline positional group consumes more than this many
+  # lines without nesting, then invalidate the layout (and nest)
+  max_rows_cmdline: 2
+  separate_ctrl_name_with_space: false
+  separate_fn_name_with_space: false
+  dangle_parens: false
+
+  # If the trailing parenthesis must be 'dangled' on its on
+  # 'line, then align it to this reference: `prefix`: the start'
+  # 'of the statement,  `prefix-indent`: the start of the'
+  # 'statement, plus one indentation  level, `child`: align to'
+  # the column of the arguments
+  dangle_align: prefix
+  # If the statement spelling length (including space and
+  # parenthesis) is smaller than this amount, then force reject
+  # nested layouts.
+  min_prefix_chars: 4
+
+  # If the statement spelling length (including space and
+  # parenthesis) is larger than the tab width by more than this
+  # amount, then force reject un-nested layouts.
+  max_prefix_chars: 10
+
+  # If a candidate layout is wrapped horizontally but it exceeds
+  # this many lines, then reject the layout.
+  max_lines_hwrap: 2
+
+  line_ending: unix
+
+  # Format command names consistently as 'lower' or 'upper' case
+  command_case: canonical
+
+  # Format keywords consistently as 'lower' or 'upper' case
+  # unchanged is valid too
+  keyword_case: 'upper'
+
+  # A list of command names which should always be wrapped
+  always_wrap: []
+
+  # If true, the argument lists which are known to be sortable
+  # will be sorted lexicographically
+  enable_sort: true
+
+  # If true, the parsers may infer whether or not an argument
+  # list is sortable (without annotation).
+  autosort: false
+
+# Causes a few issues - can be solved later, possibly.
+markup:
+  enable_markup: false