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

package/MMKV/Core/MemoryFile.h

@@ -0,0 +1,194 @@
+/*
+ * 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_MAMERYFILE_H
+#define MMKV_MAMERYFILE_H
+#ifdef __cplusplus
+
+#include "MMKVPredef.h"
+#include <cstdint>
+#include <functional>
+
+#ifdef MMKV_ANDROID
+MMKVPath_t ashmemMMKVPathWithID(const MMKVPath_t &mmapID);
+
+namespace mmkv {
+extern int g_android_api;
+extern std::string g_android_tmpDir;
+
+enum FileType : bool { MMFILE_TYPE_FILE = false, MMFILE_TYPE_ASHMEM = true };
+} // namespace mmkv
+#endif // MMKV_ANDROID
+
+namespace mmkv {
+
+enum class OpenFlag : uint32_t {
+    ReadOnly = 1 << 0,
+    WriteOnly = 1 << 1,
+    ReadWrite = ReadOnly | WriteOnly,
+    Create = 1 << 2,
+    Excel = 1 << 3, // fail if Create is set but the file already exist
+    Truncate = 1 << 4,
+};
+constexpr uint32_t OpenFlagRWMask = 0x3; // mask for Read Write mode
+
+static inline OpenFlag operator | (OpenFlag left, OpenFlag right) {
+    return static_cast<OpenFlag>(static_cast<uint32_t>(left) | static_cast<uint32_t>(right));
+}
+
+static inline bool operator & (OpenFlag left, OpenFlag right) {
+    return ((static_cast<uint32_t>(left) & static_cast<uint32_t>(right)) != 0);
+}
+
+static inline OpenFlag operator & (OpenFlag left, uint32_t right) {
+    return static_cast<OpenFlag>(static_cast<uint32_t>(left) & right);
+}
+
+template <typename T>
+T roundUp(T numToRound, T multiple) {
+    return ((numToRound + multiple - 1) / multiple) * multiple;
+}
+
+class File {
+    MMKVPath_t m_path;
+    MMKVFileHandle_t m_fd;
+public:
+    const OpenFlag m_flag;
+#ifndef MMKV_ANDROID
+    explicit File(MMKVPath_t path, OpenFlag flag);
+#else
+    File(MMKVPath_t path, OpenFlag flag, size_t size = 0, FileType fileType = MMFILE_TYPE_FILE);
+    explicit File(MMKVFileHandle_t ashmemFD);
+
+    size_t m_size;
+    const FileType m_fileType;
+#endif // MMKV_ANDROID
+
+    ~File() { close(); }
+
+    bool open();
+
+    void close();
+
+    MMKVFileHandle_t getFd() { return m_fd; }
+
+    const MMKVPath_t &getPath() const { return m_path; }
+
+#ifndef MMKV_WIN32
+    bool isFileValid() const { return m_fd >= 0; }
+#else
+    bool isFileValid() const { return m_fd != INVALID_HANDLE_VALUE; }
+#endif
+
+    // get the actual file size on disk
+    size_t getActualFileSize() const;
+
+    // just forbid it for possibly misuse
+    explicit File(const File &other) = delete;
+    File &operator=(const File &other) = delete;
+
+    friend class MemoryFile;
+};
+
+class MemoryFile {
+    File m_diskFile;
+#ifdef MMKV_WIN32
+    HANDLE m_fileMapping;
+#endif
+    void *m_ptr;
+    size_t m_size;
+    const bool m_readOnly;
+
+    bool mmap();
+
+    void doCleanMemoryCache(bool forceClean);
+
+public:
+#ifndef MMKV_ANDROID
+    explicit MemoryFile(MMKVPath_t path, size_t expectedCapacity = 0, bool readOnly = false);
+#else
+    MemoryFile(MMKVPath_t path, size_t size, FileType fileType, size_t expectedCapacity = 0, bool readOnly = false);
+    explicit MemoryFile(MMKVFileHandle_t ashmemFD);
+
+    const FileType m_fileType;
+#endif // MMKV_ANDROID
+
+    ~MemoryFile() { doCleanMemoryCache(true); }
+
+    size_t getFileSize() const { return m_size; }
+
+    // get the actual file size on disk
+    size_t getActualFileSize() const { return m_diskFile.getActualFileSize(); }
+
+    void *getMemory() { return m_ptr; }
+
+    const MMKVPath_t &getPath() { return m_diskFile.getPath(); }
+
+    MMKVFileHandle_t getFd() { return m_diskFile.getFd(); }
+
+    // the newly expanded file content will be zeroed
+    bool truncate(size_t size);
+
+    bool msync(SyncFlag syncFlag);
+
+    // call this if clearMemoryCache() has been called
+    void reloadFromFile(size_t expectedCapacity = 0);
+
+    void clearMemoryCache() { doCleanMemoryCache(false); }
+
+#ifndef MMKV_WIN32
+    bool isFileValid() { return m_diskFile.isFileValid() && m_size > 0 && m_ptr; }
+#else
+    bool isFileValid() { return m_diskFile.isFileValid() && m_size > 0 && m_fileMapping && m_ptr; }
+#endif
+
+    // just forbid it for possibly misuse
+    explicit MemoryFile(const MemoryFile &other) = delete;
+    MemoryFile &operator=(const MemoryFile &other) = delete;
+};
+
+class MMBuffer;
+
+extern bool mkPath(const MMKVPath_t &path);
+extern bool isFileExist(const MMKVPath_t &nsFilePath);
+extern MMBuffer *readWholeFile(const MMKVPath_t &path);
+extern bool zeroFillFile(MMKVFileHandle_t fd, size_t startPos, size_t size);
+extern size_t getPageSize();
+
+extern bool tryAtomicRename(const MMKVPath_t &srcPath, const MMKVPath_t &dstPath);
+
+// copy file by potentially renaming target file, might change file inode
+extern bool copyFile(const MMKVPath_t &srcPath, const MMKVPath_t &dstPath);
+
+// copy file by source file content, keep file inode the same
+extern bool copyFileContent(const MMKVPath_t &srcPath, const MMKVPath_t &dstPath);
+extern bool copyFileContent(const MMKVPath_t &srcPath, MMKVFileHandle_t dstFD);
+extern bool copyFileContent(const MMKVPath_t &srcPath, MMKVFileHandle_t dstFD, bool needTruncate);
+
+enum WalkType : uint32_t {
+    WalkFile = 1 << 0,
+    WalkFolder = 1 << 1,
+};
+extern void walkInDir(const MMKVPath_t &dirPath, WalkType type, const std::function<void(const MMKVPath_t&, WalkType)> &walker);
+
+} // namespace mmkv
+
+#endif
+#endif //MMKV_MAMERYFILE_H

package/MMKV/Core/MemoryFile_Android.cpp

@@ -0,0 +1,236 @@
+/*
+ * 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 "MemoryFile.h"
+
+#ifdef MMKV_ANDROID
+
+#    include "MMBuffer.h"
+#    include "MMKVLog.h"
+#    include <cerrno>
+#    include <fcntl.h>
+#    include <sys/mman.h>
+#    include <sys/stat.h>
+#    include <unistd.h>
+
+using namespace std;
+
+constexpr char ASHMEM_NAME_DEF[] = "/dev/ashmem";
+
+namespace mmkv {
+
+// for Android Q limiting ashmem access
+extern int ASharedMemory_create(const char *name, size_t size);
+extern size_t ASharedMemory_getSize(int fd);
+extern string ASharedMemory_getName(int fd);
+
+File::File(MMKVPath_t path, OpenFlag flag, size_t size, FileType fileType)
+    : m_path(std::move(path)), m_fd(-1), m_flag(flag), m_size(0), m_fileType(fileType) {
+    if (m_fileType == MMFILE_TYPE_FILE) {
+        open();
+    } else {
+        // round up to (n * pagesize)
+        if (size < DEFAULT_MMAP_SIZE || (size % DEFAULT_MMAP_SIZE != 0)) {
+            size = ((size / DEFAULT_MMAP_SIZE) + 1) * DEFAULT_MMAP_SIZE;
+        }
+        auto filename = m_path.c_str();
+        auto ptr = strstr(filename, ASHMEM_NAME_DEF);
+        if (ptr && ptr[sizeof(ASHMEM_NAME_DEF) - 1] == '/') {
+            filename = ptr + sizeof(ASHMEM_NAME_DEF);
+        }
+        m_fd = ASharedMemory_create(filename, size);
+        if (isFileValid()) {
+            m_size = size;
+        }
+    }
+}
+
+File::File(MMKVFileHandle_t ashmemFD)
+    : m_path(), m_fd(ashmemFD), m_flag(OpenFlag::ReadWrite), m_size(0), m_fileType(MMFILE_TYPE_ASHMEM) {
+    if (isFileValid()) {
+        m_path = ASharedMemory_getName(m_fd);
+        m_size = ASharedMemory_getSize(m_fd);
+    }
+}
+
+MemoryFile::MemoryFile(string path, size_t size, FileType fileType, size_t expectedCapacity, bool isReadOnly)
+    : m_diskFile(std::move(path), isReadOnly ? OpenFlag::ReadOnly : (OpenFlag::ReadWrite | OpenFlag::Create), size, fileType),
+    m_ptr(nullptr), m_size(0), m_fileType(fileType), m_readOnly(isReadOnly) {
+    if (m_fileType == MMFILE_TYPE_FILE) {
+        reloadFromFile(expectedCapacity);
+    } else {
+        if (m_diskFile.isFileValid()) {
+            m_size = m_diskFile.m_size;
+            auto ret = mmap();
+            if (!ret) {
+                doCleanMemoryCache(true);
+            }
+        }
+    }
+}
+
+MemoryFile::MemoryFile(int ashmemFD)
+    : m_diskFile(ashmemFD), m_ptr(nullptr), m_size(0), m_fileType(MMFILE_TYPE_ASHMEM), m_readOnly(false) {
+    if (!m_diskFile.isFileValid()) {
+        MMKVError("fd %d invalid", ashmemFD);
+    } else {
+        m_size = m_diskFile.m_size;
+        MMKVInfo("ashmem name:%s, size:%zu", m_diskFile.m_path.c_str(), m_size);
+        auto ret = mmap();
+        if (!ret) {
+            doCleanMemoryCache(true);
+        }
+    }
+}
+
+} // namespace mmkv
+
+#    pragma mark - ashmem
+#    include <dlfcn.h>
+#    include <sys/ioctl.h>
+
+namespace mmkv {
+
+constexpr auto ASHMEM_NAME_LEN = 256;
+constexpr auto ASHMEM_IOC = 0x77;
+#    define ASHMEM_SET_NAME _IOW(ASHMEM_IOC, 1, char[ASHMEM_NAME_LEN])
+#    define ASHMEM_GET_NAME _IOR(ASHMEM_IOC, 2, char[ASHMEM_NAME_LEN])
+#    define ASHMEM_SET_SIZE _IOW(ASHMEM_IOC, 3, size_t)
+#    define ASHMEM_GET_SIZE _IO(ASHMEM_IOC, 4)
+
+#ifndef MMKV_OHOS
+int g_android_api = __ANDROID_API_L__;
+#endif
+std::string g_android_tmpDir = "/data/local/tmp/";
+
+#ifndef MMKV_OHOS
+void *loadLibrary() {
+    auto name = "libandroid.so";
+    static auto handle = dlopen(name, RTLD_LAZY | RTLD_LOCAL);
+    if (handle == RTLD_DEFAULT) {
+        MMKVError("unable to load library %s", name);
+    }
+    return handle;
+}
+
+typedef int (*AShmem_create_t)(const char *name, size_t size);
+typedef size_t (*AShmem_getSize_t)(int fd);
+
+#endif
+
+int ASharedMemory_create(const char *name, size_t size) {
+#ifndef MMKV_OHOS
+    if (g_android_api >= __ANDROID_API_O__ || g_android_api >= __ANDROID_API_M__) {
+        static auto handle = loadLibrary();
+        static AShmem_create_t funcPtr =
+            (handle != nullptr) ? reinterpret_cast<AShmem_create_t>(dlsym(handle, "ASharedMemory_create")) : nullptr;
+        if (funcPtr) {
+            int fd = funcPtr(name, size);
+            if (fd < 0) {
+                MMKVError("fail to ASharedMemory_create %s with size %zu, errno:%s", name, size, strerror(errno));
+            } else {
+                MMKVInfo("ASharedMemory_create %s with size %zu, fd:%d", name, size, fd);
+                return fd;
+            }
+        } else if (g_android_api >= __ANDROID_API_O__) {
+            MMKVWarning("fail to locate ASharedMemory_create() from loading libandroid.so");
+        }
+
+        static AShmem_create_t regionFuncPtr =
+            (handle != nullptr) ? reinterpret_cast<AShmem_create_t>(dlsym(handle, "ashmem_create_region")) : nullptr;
+        if (regionFuncPtr) {
+            int fd = regionFuncPtr(name, size);
+            if (fd < 0) {
+                MMKVError("fail to ashmem_create_region %s with size %zu, errno:%s", name, size, strerror(errno));
+            } else {
+                MMKVInfo("ashmem_create_region %s with size %zu, fd:%d", name, size, fd);
+                return fd;
+            }
+        } else {
+            MMKVWarning("fail to locate ashmem_create_region() from loading libandroid.so");
+        }
+    }
+#endif
+    int fd = open(ASHMEM_NAME_DEF, O_RDWR | O_CLOEXEC);
+    if (fd < 0) {
+        MMKVError("fail to open ashmem:%s, %s", name, strerror(errno));
+    } else {
+        if (ioctl(fd, ASHMEM_SET_NAME, name) != 0) {
+            MMKVError("fail to set ashmem name:%s, %s", name, strerror(errno));
+        } else if (ioctl(fd, ASHMEM_SET_SIZE, size) != 0) {
+            MMKVError("fail to set ashmem:%s, size %zu, %s", name, size, strerror(errno));
+        }
+    }
+    return fd;
+}
+
+size_t ASharedMemory_getSize(int fd) {
+    size_t size = 0;
+#ifndef MMKV_OHOS
+    if (g_android_api >= __ANDROID_API_O__) {
+        static auto handle = loadLibrary();
+        static AShmem_getSize_t funcPtr =
+            (handle != nullptr) ? reinterpret_cast<AShmem_getSize_t>(dlsym(handle, "ASharedMemory_getSize")) : nullptr;
+        if (funcPtr) {
+            size = funcPtr(fd);
+            if (size == 0) {
+                MMKVError("fail to ASharedMemory_getSize:%d, %s", fd, strerror(errno));
+            }
+        } else {
+            MMKVWarning("fail to locate ASharedMemory_create() from loading libandroid.so");
+        }
+    }
+#endif
+    if (size == 0) {
+        int tmp = ioctl(fd, ASHMEM_GET_SIZE, nullptr);
+        if (tmp < 0) {
+            MMKVError("fail to get ashmem size:%d, %s", fd, strerror(errno));
+        } else {
+            size = static_cast<size_t>(tmp);
+        }
+    }
+    return size;
+}
+
+string ASharedMemory_getName(int fd) {
+    // Android Q doesn't have ASharedMemory_getName()
+    // I've make a request to Google, https://issuetracker.google.com/issues/130741665
+    // There's nothing we can do before it's supported officially by Google
+#ifndef MMKV_OHOS
+    if (g_android_api >= __ANDROID_API_O__) {
+        return "";
+    }
+#endif
+
+    char name[ASHMEM_NAME_LEN] = {0};
+    if (ioctl(fd, ASHMEM_GET_NAME, name) != 0) {
+        MMKVError("fail to get ashmem name:%d, %s", fd, strerror(errno));
+        return "";
+    }
+    return {name};
+}
+
+} // namespace mmkv
+
+MMKVPath_t ashmemMMKVPathWithID(const MMKVPath_t &mmapID) {
+    return MMKVPath_t(ASHMEM_NAME_DEF) + MMKV_PATH_SLASH + mmapID;
+}
+
+#endif // MMKV_ANDROID

package/MMKV/Core/MemoryFile_Linux.cpp

@@ -0,0 +1,125 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2021 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 "MemoryFile.h"
+
+#if defined(MMKV_ANDROID) || defined(MMKV_LINUX)
+#    include "InterProcessLock.h"
+#    include "MMBuffer.h"
+#    include "MMKVLog.h"
+#    include "ScopedLock.hpp"
+#    include <cerrno>
+#    include <utility>
+#    include <fcntl.h>
+#    include <sys/mman.h>
+#    include <sys/stat.h>
+#    include <unistd.h>
+#    include <sys/file.h>
+#    include <dirent.h>
+#    include <cstring>
+#    include <sys/sendfile.h>
+#    include <sys/syscall.h>
+
+#ifdef MMKV_ANDROID
+#include <dlfcn.h>
+typedef int (*renameat2_t)(int old_dir_fd, const char* old_path, int new_dir_fd, const char* new_path, unsigned flags);
+#endif
+
+#ifndef RENAME_EXCHANGE
+#define RENAME_EXCHANGE (1 << 1) /* Exchange source and dest */
+#endif
+
+namespace mmkv {
+
+extern bool getFileSize(int fd, size_t &size);
+
+bool tryAtomicRename(const MMKVPath_t &srcPath, const MMKVPath_t &dstPath) {
+    bool renamed = false;
+
+    // try renameat2() first
+#if defined(SYS_renameat2) && !defined(MMKV_OHOS)
+#ifdef MMKV_ANDROID
+    static auto g_renameat2 = (renameat2_t) dlsym(RTLD_DEFAULT, "renameat2");
+    if (g_renameat2) {
+        renamed = (g_renameat2(AT_FDCWD, srcPath.c_str(), AT_FDCWD, dstPath.c_str(), RENAME_EXCHANGE) == 0);
+    }
+    if (!renamed && errno != ENOENT) {
+        MMKVWarning("fail on renameat2() [%s] to [%s], %d(%s)", srcPath.c_str(), dstPath.c_str(), errno,
+                    strerror(errno));
+    }
+#endif
+    if (!renamed) {
+        renamed = (syscall(SYS_renameat2, AT_FDCWD, srcPath.c_str(), AT_FDCWD, dstPath.c_str(), RENAME_EXCHANGE) == 0);
+    }
+    if (!renamed && errno != ENOENT) {
+        MMKVWarning("fail on syscall(SYS_renameat2) [%s] to [%s], %d(%s)", srcPath.c_str(), dstPath.c_str(), errno,
+                    strerror(errno));
+    }
+#endif // SYS_renameat2 && !MMKV_OHOS
+
+    if (!renamed) {
+        if (::rename(srcPath.c_str(), dstPath.c_str()) != 0) {
+            MMKVError("fail to rename [%s] to [%s], %d(%s)", srcPath.c_str(), dstPath.c_str(), errno, strerror(errno));
+            return false;
+        }
+    }
+
+    ::unlink(srcPath.c_str());
+    return true;
+}
+
+// do it by sendfile()
+bool copyFileContent(const MMKVPath_t &srcPath, MMKVFileHandle_t dstFD, bool needTruncate) {
+    if (dstFD < 0) {
+        return false;
+    }
+    File srcFile(srcPath, OpenFlag::ReadOnly);
+    if (!srcFile.isFileValid()) {
+        return false;
+    }
+    auto srcFileSize = srcFile.getActualFileSize();
+
+    lseek(dstFD, 0, SEEK_SET);
+    auto writtenSize = ::sendfile(dstFD, srcFile.getFd(), nullptr, srcFileSize);
+    auto ret = (writtenSize == srcFileSize);
+    if (!ret) {
+        if (writtenSize < 0) {
+            MMKVError("fail to sendfile() %s to fd[%d], %d(%s)", srcPath.c_str(), dstFD, errno, strerror(errno));
+        } else {
+            MMKVError("sendfile() %s to fd[%d], written %lld < %zu", srcPath.c_str(), dstFD, writtenSize, srcFileSize);
+        }
+    } else if (needTruncate) {
+        size_t dstFileSize = 0;
+        getFileSize(dstFD, dstFileSize);
+        if ((dstFileSize != srcFileSize) && (::ftruncate(dstFD, static_cast<off_t>(srcFileSize)) != 0)) {
+            MMKVError("fail to truncate [%d] to size [%zu], %d(%s)", dstFD, srcFileSize, errno, strerror(errno));
+            ret = false;
+        }
+    }
+
+    if (ret) {
+        MMKVInfo("copy content from %s to fd[%d] finish", srcPath.c_str(), dstFD);
+    }
+    return ret;
+}
+
+} // namespace mmkv
+
+#endif // defined(MMKV_ANDROID) || defined(MMKV_LINUX)

package/MMKV/Core/MemoryFile_OSX.cpp

@@ -0,0 +1,142 @@
+/*
+ * 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 "MemoryFile.h"
+#include "MMKVLog.h"
+
+#ifdef MMKV_IOS
+
+using namespace std;
+
+namespace mmkv {
+
+void tryResetFileProtection(const string &path) {
+    @autoreleasepool {
+        NSString *nsPath = [NSString stringWithUTF8String:path.c_str()];
+        NSDictionary *attr = [[NSFileManager defaultManager] attributesOfItemAtPath:nsPath error:nullptr];
+        NSString *protection = [attr valueForKey:NSFileProtectionKey];
+        MMKVInfo("protection on [%@] is %@", nsPath, protection);
+        if ([protection isEqualToString:NSFileProtectionCompleteUntilFirstUserAuthentication] == NO) {
+            NSMutableDictionary *newAttr = [NSMutableDictionary dictionaryWithDictionary:attr];
+            [newAttr setObject:NSFileProtectionCompleteUntilFirstUserAuthentication forKey:NSFileProtectionKey];
+            NSError *err = nil;
+            [[NSFileManager defaultManager] setAttributes:newAttr ofItemAtPath:nsPath error:&err];
+            if (err != nil) {
+                MMKVError("fail to set attribute %@ on [%@]: %@", NSFileProtectionCompleteUntilFirstUserAuthentication,
+                          nsPath, err);
+            }
+        }
+    }
+}
+
+} // namespace mmkv
+
+#endif // MMKV_IOS
+
+#ifdef MMKV_APPLE
+
+#include <copyfile.h>
+#include <unistd.h>
+
+namespace mmkv {
+
+bool tryAtomicRename(const char *src, const char *dst) {
+    bool renamed = false;
+
+    // try atomic swap first
+    if (@available(iOS 10.0, watchOS 3.0, macOS 10.12, *)) {
+        // renameat2() equivalent
+        if (renamex_np(src, dst, RENAME_SWAP) == 0) {
+            renamed = true;
+        } else if (errno != ENOENT) {
+            MMKVError("fail to renamex_np %s to %s, %s", src, dst, strerror(errno));
+        }
+    }
+
+    if (!renamed) {
+        // try old style rename
+        if (rename(src, dst) != 0) {
+            MMKVError("fail to rename %s to %s, %s", src, dst, strerror(errno));
+            return false;
+        }
+    }
+
+    ::unlink(src);
+
+    return true;
+}
+
+bool copyFile(const MMKVPath_t &srcPath, const MMKVPath_t &dstPath) {
+    // prepare a temp file for atomic rename, avoid data corruption of suddent crash
+    NSString *uniqueFileName = [NSString stringWithFormat:@"mmkv_%zu", (size_t) NSDate.timeIntervalSinceReferenceDate];
+    NSString *tmpFile = [NSTemporaryDirectory() stringByAppendingPathComponent:uniqueFileName];
+    if (copyfile(srcPath.c_str(), tmpFile.UTF8String, nullptr, COPYFILE_UNLINK | COPYFILE_CLONE) != 0) {
+        MMKVError("fail to copyfile [%s] to [%s], %s", srcPath.c_str(), tmpFile.UTF8String, strerror(errno));
+        return false;
+    }
+    MMKVInfo("copyfile [%s] to [%s]", srcPath.c_str(), tmpFile.UTF8String);
+
+    if (tryAtomicRename(tmpFile.UTF8String, dstPath.c_str())) {
+        MMKVInfo("copyfile [%s] to [%s] finish.", srcPath.c_str(), dstPath.c_str());
+        return true;
+    }
+    unlink(tmpFile.UTF8String);
+    return false;
+}
+
+bool copyFileContent(const MMKVPath_t &srcPath, const MMKVPath_t &dstPath) {
+    File dstFile(dstPath, OpenFlag::WriteOnly | OpenFlag::Create | OpenFlag::Truncate);
+    if (!dstFile.isFileValid()) {
+        return false;
+    }
+    if (copyFileContent(srcPath, dstFile.getFd())) {
+        MMKVInfo("copy content from %s to fd[%s] finish", srcPath.c_str(), dstPath.c_str());
+        return true;
+    }
+    MMKVError("fail to copyfile(): target file %s", dstPath.c_str());
+    return false;
+}
+
+bool copyFileContent(const MMKVPath_t &srcPath, MMKVFileHandle_t dstFD) {
+    if (dstFD < 0) {
+        return false;
+    }
+
+    File srcFile(srcPath, OpenFlag::ReadOnly);
+    if (!srcFile.isFileValid()) {
+        return false;
+    }
+
+    // sendfile() equivalent
+    if (::fcopyfile(srcFile.getFd(), dstFD, nullptr, COPYFILE_ALL) == 0) {
+        MMKVInfo("copy content from %s to fd[%d] finish", srcPath.c_str(), dstFD);
+        return true;
+    }
+    MMKVError("fail to copyfile(): %d(%s), source file %s", errno, strerror(errno), srcPath.c_str());
+    return false;
+}
+
+bool copyFileContent(const MMKVPath_t &srcPath, MMKVFileHandle_t dstFD, bool needTruncate) {
+    return copyFileContent(srcPath, dstFD);
+}
+
+} // namespace mmkv
+
+#endif // MMKV_APPLE