react-native-mmkv-dz 2.5.1

package/MMKV/Core/Core.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:Core.xcodeproj">
+   </FileRef>
+</Workspace>

package/MMKV/Core/Core.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

package/MMKV/Core/Core.xcodeproj/xcshareddata/xcschemes/Core.xcscheme

@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "1330"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "CB9563D723AB2D9500ACCD39"
+               BuildableName = "libMMKVCore.a"
+               BlueprintName = "MMKVCore"
+               ReferencedContainer = "container:Core.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <Testables>
+      </Testables>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "CB9563D723AB2D9500ACCD39"
+            BuildableName = "libMMKVCore.a"
+            BlueprintName = "MMKVCore"
+            ReferencedContainer = "container:Core.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

package/MMKV/Core/Core.xcodeproj/xcshareddata/xcschemes/MMKVWatchCore.xcscheme

@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "1330"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "CBF1904E243D70BA001C82ED"
+               BuildableName = "libMMKVCore.a"
+               BlueprintName = "MMKVWatchCore"
+               ReferencedContainer = "container:Core.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <Testables>
+      </Testables>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "CBF1904E243D70BA001C82ED"
+            BuildableName = "libMMKVCore.a"
+            BlueprintName = "MMKVWatchCore"
+            ReferencedContainer = "container:Core.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

package/MMKV/Core/InterProcessLock.cpp

@@ -0,0 +1,186 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2018 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 "InterProcessLock.h"
+#include "MMKVLog.h"
+
+#ifndef MMKV_WIN32
+#    include <sys/file.h>
+#endif
+
+namespace mmkv {
+
+bool FileLock::lock(LockType lockType) {
+    return doLock(lockType, true);
+}
+
+bool FileLock::try_lock(LockType lockType, bool *tryAgain) {
+    return doLock(lockType, false, tryAgain);
+}
+
+bool FileLock::doLock(LockType lockType, bool wait, bool *tryAgain) {
+    if (!isFileLockValid()) {
+        return false;
+    }
+    bool unLockFirstIfNeeded = false;
+
+    if (lockType == SharedLockType) {
+        // don't want shared-lock to break any existing locks
+        if (m_sharedLockCount > 0 || m_exclusiveLockCount > 0) {
+            m_sharedLockCount++;
+            return true;
+        }
+    } else {
+        // don't want exclusive-lock to break existing exclusive-locks
+        if (m_exclusiveLockCount > 0) {
+            m_exclusiveLockCount++;
+            return true;
+        }
+        // prevent deadlock
+        if (m_sharedLockCount > 0) {
+            unLockFirstIfNeeded = true;
+        }
+    }
+
+    auto ret = platformLock(lockType, wait, unLockFirstIfNeeded, tryAgain);
+    if (ret) {
+        if (lockType == SharedLockType) {
+            m_sharedLockCount++;
+        } else {
+            m_exclusiveLockCount++;
+        }
+    }
+    return ret;
+}
+
+#ifndef MMKV_WIN32
+
+static int32_t LockType2FlockType(LockType lockType) {
+    switch (lockType) {
+        case SharedLockType:
+            return LOCK_SH;
+        case ExclusiveLockType:
+            return LOCK_EX;
+    }
+    return LOCK_EX;
+}
+
+bool FileLock::platformLock(LockType lockType, bool wait, bool unLockFirstIfNeeded, bool *tryAgain) {
+#    ifdef MMKV_ANDROID
+    if (m_isAshmem) {
+        return ashmemLock(lockType, wait, unLockFirstIfNeeded, tryAgain);
+    }
+#    endif
+    auto realLockType = LockType2FlockType(lockType);
+    auto cmd = wait ? realLockType : (realLockType | LOCK_NB);
+    if (unLockFirstIfNeeded) {
+        // try lock
+        auto ret = flock(m_fd, realLockType | LOCK_NB);
+        if (ret == 0) {
+            return true;
+        }
+        // let's be gentleman: unlock my shared-lock to prevent deadlock
+        ret = flock(m_fd, LOCK_UN);
+        if (ret != 0) {
+            MMKVError("fail to try unlock first fd=%d, ret=%d, error:%s", m_fd, ret, strerror(errno));
+        }
+    }
+
+    auto ret = flock(m_fd, cmd);
+    if (ret != 0) {
+        if (tryAgain) {
+            *tryAgain = (errno == EWOULDBLOCK);
+        }
+        if (wait) {
+            MMKVError("fail to lock fd=%d, ret=%d, error:%s", m_fd, ret, strerror(errno));
+        }
+        // try recover my shared-lock
+        if (unLockFirstIfNeeded) {
+            ret = flock(m_fd, LockType2FlockType(SharedLockType));
+            if (ret != 0) {
+                // let's hope this never happen
+                MMKVError("fail to recover shared-lock fd=%d, ret=%d, error:%s", m_fd, ret, strerror(errno));
+            }
+        }
+        return false;
+    } else {
+        return true;
+    }
+}
+
+bool FileLock::platformUnLock(bool unlockToSharedLock) {
+#    ifdef MMKV_ANDROID
+    if (m_isAshmem) {
+        return ashmemUnLock(unlockToSharedLock);
+    }
+#    endif
+    int cmd = unlockToSharedLock ? LOCK_SH : LOCK_UN;
+    auto ret = flock(m_fd, cmd);
+    if (ret != 0) {
+        MMKVError("fail to unlock fd=%d, ret=%d, error:%s", m_fd, ret, strerror(errno));
+        return false;
+    } else {
+        return true;
+    }
+}
+
+#endif // MMKV_WIN32
+
+bool FileLock::unlock(LockType lockType) {
+    if (!isFileLockValid()) {
+        return false;
+    }
+    bool unlockToSharedLock = false;
+
+    if (lockType == SharedLockType) {
+        if (m_sharedLockCount == 0) {
+            return false;
+        }
+        // don't want shared-lock to break any existing locks
+        if (m_sharedLockCount > 1 || m_exclusiveLockCount > 0) {
+            m_sharedLockCount--;
+            return true;
+        }
+    } else {
+        if (m_exclusiveLockCount == 0) {
+            return false;
+        }
+        if (m_exclusiveLockCount > 1) {
+            m_exclusiveLockCount--;
+            return true;
+        }
+        // restore shared-lock when all exclusive-locks are done
+        if (m_sharedLockCount > 0) {
+            unlockToSharedLock = true;
+        }
+    }
+
+    auto ret = platformUnLock(unlockToSharedLock);
+    if (ret) {
+        if (lockType == SharedLockType) {
+            m_sharedLockCount--;
+        } else {
+            m_exclusiveLockCount--;
+        }
+    }
+    return ret;
+}
+
+} // namespace mmkv

package/MMKV/Core/InterProcessLock.h

@@ -0,0 +1,119 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2018 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.
+ */
+
+#ifndef MMKV_INTERPROCESSLOCK_H
+#define MMKV_INTERPROCESSLOCK_H
+#ifdef __cplusplus
+
+#    include "MMKVPredef.h"
+
+#    include <fcntl.h>
+
+namespace mmkv {
+
+enum LockType {
+    SharedLockType,
+    ExclusiveLockType,
+};
+
+// a recursive POSIX file-lock wrapper
+// handles lock upgrade & downgrade correctly
+class FileLock {
+    MMKVFileHandle_t m_fd;
+    size_t m_sharedLockCount;
+    size_t m_exclusiveLockCount;
+
+    bool doLock(LockType lockType, bool wait, bool *tryAgain = nullptr);
+    bool platformLock(LockType lockType, bool wait, bool unLockFirstIfNeeded, bool *tryAgain);
+    bool platformUnLock(bool unLockFirstIfNeeded);
+
+#    ifndef MMKV_WIN32
+    bool isFileLockValid() { return m_fd >= 0; }
+#        ifdef MMKV_ANDROID
+    const bool m_isAshmem;
+    struct flock m_lockInfo;
+    bool ashmemLock(LockType lockType, bool wait, bool unLockFirstIfNeeded, bool *tryAgain);
+    bool ashmemUnLock(bool unLockFirstIfNeeded);
+#        endif
+
+#    else  // defined(MMKV_WIN32)
+    OVERLAPPED m_overLapped;
+
+    bool isFileLockValid() { return m_fd != INVALID_HANDLE_VALUE; }
+#    endif // MMKV_WIN32
+
+public:
+#    ifndef MMKV_WIN32
+#        ifndef MMKV_ANDROID
+    explicit FileLock(MMKVFileHandle_t fd) : m_fd(fd), m_sharedLockCount(0), m_exclusiveLockCount(0) {}
+#        else
+    explicit FileLock(MMKVFileHandle_t fd, bool isAshmem = false);
+#        endif // MMKV_ANDROID
+#    else      // defined(MMKV_WIN32)
+    explicit FileLock(MMKVFileHandle_t fd) : m_fd(fd), m_overLapped{}, m_sharedLockCount(0), m_exclusiveLockCount(0) {}
+#    endif     // MMKV_WIN32
+
+    bool lock(LockType lockType);
+
+    bool try_lock(LockType lockType, bool *tryAgain);
+
+    bool unlock(LockType lockType);
+
+    // just forbid it for possibly misuse
+    explicit FileLock(const FileLock &other) = delete;
+    FileLock &operator=(const FileLock &other) = delete;
+};
+
+class InterProcessLock {
+    FileLock *m_fileLock;
+    LockType m_lockType;
+
+public:
+    InterProcessLock(FileLock *fileLock, LockType lockType)
+        : m_fileLock(fileLock), m_lockType(lockType), m_enable(true) {
+        MMKV_ASSERT(m_fileLock);
+    }
+
+    bool m_enable;
+
+    void lock() {
+        if (m_enable) {
+            m_fileLock->lock(m_lockType);
+        }
+    }
+
+    bool try_lock(bool *tryAgain = nullptr) {
+        if (m_enable) {
+            return m_fileLock->try_lock(m_lockType, tryAgain);
+        }
+        return false;
+    }
+
+    void unlock() {
+        if (m_enable) {
+            m_fileLock->unlock(m_lockType);
+        }
+    }
+};
+
+} // namespace mmkv
+
+#endif // __cplusplus
+#endif // MMKV_INTERPROCESSLOCK_H

package/MMKV/Core/InterProcessLock_Android.cpp

@@ -0,0 +1,103 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2019 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 "InterProcessLock.h"
+
+#ifdef MMKV_ANDROID
+#    include "MMKVLog.h"
+#    include <sys/file.h>
+#    include <unistd.h>
+
+namespace mmkv {
+
+FileLock::FileLock(MMKVFileHandle_t fd, bool isAshmem)
+    : m_fd(fd), m_sharedLockCount(0), m_exclusiveLockCount(0), m_isAshmem(isAshmem) {
+    m_lockInfo.l_type = F_WRLCK;
+    m_lockInfo.l_start = 0;
+    m_lockInfo.l_whence = SEEK_SET;
+    m_lockInfo.l_len = 0;
+    m_lockInfo.l_pid = 0;
+}
+
+static short LockType2FlockType(LockType lockType) {
+    switch (lockType) {
+        case SharedLockType:
+            return F_RDLCK;
+        case ExclusiveLockType:
+            return F_WRLCK;
+    }
+}
+
+bool FileLock::ashmemLock(LockType lockType, bool wait, bool unLockFirstIfNeeded, bool *tryAgain) {
+    m_lockInfo.l_type = LockType2FlockType(lockType);
+    if (unLockFirstIfNeeded) {
+        // try lock
+        auto ret = fcntl(m_fd, F_SETLK, &m_lockInfo);
+        if (ret == 0) {
+            return true;
+        }
+        // lets be gentleman: unlock my shared-lock to prevent deadlock
+        auto type = m_lockInfo.l_type;
+        m_lockInfo.l_type = F_UNLCK;
+        ret = fcntl(m_fd, F_SETLK, &m_lockInfo);
+        if (ret != 0) {
+            MMKVError("fail to try unlock first fd=%d, ret=%d, error:%s", m_fd, ret, strerror(errno));
+        }
+        m_lockInfo.l_type = type;
+    }
+
+    int cmd = wait ? F_SETLKW : F_SETLK;
+    auto ret = fcntl(m_fd, cmd, &m_lockInfo);
+    if (ret != 0) {
+        if (tryAgain) {
+            *tryAgain = (errno == EAGAIN);
+        }
+        if (wait) {
+            MMKVError("fail to lock fd=%d, ret=%d, error:%s", m_fd, ret, strerror(errno));
+        }
+        // try recover my shared-lock
+        if (unLockFirstIfNeeded) {
+            m_lockInfo.l_type = LockType2FlockType(SharedLockType);
+            ret = fcntl(m_fd, cmd, &m_lockInfo);
+            if (ret != 0) {
+                // let's hope this never happen
+                MMKVError("fail to recover shared-lock fd=%d, ret=%d, error:%s", m_fd, ret, strerror(errno));
+            }
+        }
+        return false;
+    } else {
+        return true;
+    }
+}
+
+bool FileLock::ashmemUnLock(bool unlockToSharedLock) {
+    m_lockInfo.l_type = static_cast<short>(unlockToSharedLock ? F_RDLCK : F_UNLCK);
+    auto ret = fcntl(m_fd, F_SETLK, &m_lockInfo);
+    if (ret != 0) {
+        MMKVError("fail to unlock fd=%d, ret=%d, error:%s", m_fd, ret, strerror(errno));
+        return false;
+    } else {
+        return true;
+    }
+}
+
+} // namespace mmkv
+
+#endif // MMKV_ANDROID

package/MMKV/Core/InterProcessLock_Win32.cpp

@@ -0,0 +1,108 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2019 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 "InterProcessLock.h"
+
+#ifdef MMKV_WIN32
+#    include "MMKVLog.h"
+
+namespace mmkv {
+
+static DWORD LockType2Flag(LockType lockType) {
+    DWORD flag = 0;
+    switch (lockType) {
+        case SharedLockType:
+            flag = 0;
+            break;
+        case ExclusiveLockType:
+            flag = LOCKFILE_EXCLUSIVE_LOCK;
+            break;
+    }
+    return flag;
+}
+
+bool FileLock::platformLock(LockType lockType, bool wait, bool unLockFirstIfNeeded, bool *tryAgain) {
+    auto realLockType = LockType2Flag(lockType);
+    auto flag = wait ? realLockType : (realLockType | LOCKFILE_FAIL_IMMEDIATELY);
+    if (unLockFirstIfNeeded) {
+        /* try exclusive-lock above shared-lock will always fail in Win32
+		auto ret = LockFileEx(m_fd, realLockType | LOCKFILE_FAIL_IMMEDIATELY, 0, 1, 0, &m_overLapped);
+		if (ret) {
+			return true;
+		}*/
+        // let's be gentleman: unlock my shared-lock to prevent deadlock
+        auto ret = UnlockFileEx(m_fd, 0, 1, 0, &m_overLapped);
+        if (!ret) {
+            auto lastError = GetLastError();
+            if (lastError != ERROR_NOT_LOCKED) {
+                MMKVError("fail to try unlock first fd=%p, error:%d", m_fd, lastError);
+            }
+        }
+    }
+
+    auto ret = LockFileEx(m_fd, flag, 0, 1, 0, &m_overLapped);
+    if (!ret) {
+        if (tryAgain) {
+            *tryAgain = (GetLastError() == ERROR_LOCK_VIOLATION);
+        }
+        if (wait) {
+            MMKVError("fail to lock fd=%p, error:%d", m_fd, GetLastError());
+        }
+        // try recover my shared-lock
+        if (unLockFirstIfNeeded) {
+            ret = LockFileEx(m_fd, LockType2Flag(SharedLockType), 0, 1, 0, &m_overLapped);
+            if (!ret) {
+                // let's hope this never happen
+                MMKVError("fail to recover shared-lock fd=%p, error:%d", m_fd, GetLastError());
+            }
+        }
+        return false;
+    } else {
+        return true;
+    }
+}
+
+bool FileLock::platformUnLock(bool unlockToSharedLock) {
+    /* quote from MSDN:
+    * If the same range is locked with an exclusive and a shared lock,
+    * two unlock operations are necessary to unlock the region;
+    * the first unlock operation unlocks the exclusive lock,
+    * the second unlock operation unlocks the shared lock.
+    */
+    if (unlockToSharedLock) {
+        auto flag = LockType2Flag(SharedLockType);
+        if (!LockFileEx(m_fd, flag, 0, 1, 0, &m_overLapped)) {
+            MMKVError("fail to roll back to shared-lock, error:%d", GetLastError());
+        }
+    }
+    auto ret = UnlockFileEx(m_fd, 0, 1, 0, &m_overLapped);
+    if (!ret) {
+        auto lastError = GetLastError();
+        if (lastError != ERROR_NOT_LOCKED) {
+            MMKVError("fail to unlock fd=%p, error:%d", m_fd, lastError);
+            return false;
+        }
+    }
+    return true;
+}
+
+} // namespace mmkv
+
+#endif // MMKV_WIN32