FatFsStorageManager.cpp

Go to the documentation of this file.

 
#include "framework_config.h" // Must be included before DebugTrace.h to ensure framework_config.h is processed first
#include "DebugTrace.h"
TRACE_INIT(FatFsStorageManager)
 
#include "storage/FatFsStorageManager.h"
#include "storage/FatFsFileReader.h"
#include <ff_utils.h>
#include <ff_stdio.h>
 
FatFsStorageManager::FatFsStorageManager() {}
 
bool FatFsStorageManager::mount()
{
    if (mounted)
        return true;
 
    TRACE("Mounting SD card at: %s\n", mountPoint.c_str());
    mounted = ::mount(mountPoint.c_str());
 
    if (mounted && !probeMountPoint())
    {
        TRACE("SD mount appears successful, but directory listing failed — treating as mount failure\n");
        mounted = false;
    }
 
    if (!mounted)
    {
        TRACE("ERROR: SD mount FAILED for %s\n", mountPoint.c_str());
    }
    else
    {
        TRACE("SD card mounted successfully\n");
    }
 
    return mounted;
}
 
bool FatFsStorageManager::unmount()
{
    ::unmount(mountPoint.c_str());
    mounted = false;
    return true;
}
 
bool FatFsStorageManager::exists(const std::string &path)
{
   TRACE("[FatFs] Checking if path exists: %s\n", path.c_str());
    if (!ensureMounted())
    {
        printf("[FatFs] SD card not mounted — cannot check path exists: %s\n", path.c_str());
        return false;
    }
    TRACE("[FatFs] Checking if exists: %s\n", resolvePath(path).c_str());
    FF_Stat_t xStat;
 
    // Use ff_stat to check if the file or directory exists
    TRACE("[FatFs] Calling ff_stat on path: %s\n",resolvePath(path).c_str());
    int err = ff_stat(resolvePath(path).c_str(), &xStat);
    TRACE("[FatFs] ff_stat returned: %d\n", err);
    if (err == FF_ERR_NONE){
        TRACE("[FatFs] Path exists: %s, size: %ld bytes\n", resolvePath(path).c_str(), xStat.st_size);
        return true;
    }
    TRACE("Path does not exist: %s\n", path.c_str());
    return false;
}
 
bool FatFsStorageManager::listDirectory(const std::string &path, std::vector<FileInfo> &out)
{
    if (!ensureMounted()) {
        TRACE("SD card not mounted — cannot list directory: %s\n", path.c_str());
        return false;
    }
    TRACE("[FatFs] Listing directory: %s\n", path.c_str());
    FF_FindData_t xFindStruct{};
    std::string searchPath = resolvePath(path.empty() ? "/" : path);
    TRACE("[FatFs] Search path: %s\n", searchPath.c_str());
    int result = ff_findfirst(searchPath.c_str(), &xFindStruct);
 
    if (result != FF_ERR_NONE) {
        printf("[FatFs] ff_findfirst failed with error: %d\n", result);
        return false;
    }
 
    do {
        if (xFindStruct.pcFileName && strlen(xFindStruct.pcFileName) > 0) {
            FileInfo info;
            info.name = xFindStruct.pcFileName;
            info.isDirectory = xFindStruct.ucAttributes & FF_FAT_ATTR_DIR;
            info.isReadOnly = xFindStruct.ucAttributes & FF_FAT_ATTR_READONLY;
            info.size = static_cast<size_t>(xFindStruct.ulFileSize);
            out.push_back(info);
        }
    } while (ff_findnext(&xFindStruct) == FF_ERR_NONE);
 
    return true;
}
 
bool FatFsStorageManager::createDirectory(const std::string &path)
{
    if (!ensureMounted())
    {
        TRACE("SD card not mounted — cannot create directory: %s\n", path.c_str());
        return false;
    }
    TRACE("[FatFs] Creating directory: %s\n", path.c_str());
    return ff_mkdir(resolvePath(path).c_str()) == FF_ERR_NONE;
}
 
bool FatFsStorageManager::removeDirectory(const std::string &path)
{
    if (!ensureMounted())
    {
        TRACE("SD card not mounted — cannot remove directory: %s\n", path.c_str());
        return false;
    }
    return ff_rmdir(resolvePath(path).c_str()) == FF_ERR_NONE;
}   
 
bool FatFsStorageManager::readFile(const std::string &path, std::vector<uint8_t> &buffer)
{
    if (!ensureMounted())
    {
        TRACE("SD card not mounted — cannot read file: %s\n", path.c_str());
        return false;
    }
    FF_FILE *file = ff_fopen(resolvePath(path).c_str(), "r");
    if (!file)
        return false;
 
    ff_fseek(file, 0, SEEK_END);
    long fileSize = ff_ftell(file);
    ff_fseek(file, 0, SEEK_SET);
 
    if (fileSize < 0)
    {
        ff_fclose(file);
        return false;
    }
 
    buffer.resize(fileSize);
    ff_fread(buffer.data(), 1, fileSize, file);
    ff_fclose(file);
    return true;
}
 
bool FatFsStorageManager::writeFile(const std::string &path, const std::vector<uint8_t> &data)
{
    if (!ensureMounted())
    {
        TRACE("SD card not mounted — cannot write to file: %s\n", path.c_str());
        return false;
    }
    FF_FILE *file = ff_fopen(resolvePath(path).c_str(), "w");
    if (!file)
        return false;
 
    ff_fwrite(data.data(), 1, data.size(), file);
    ff_fclose(file);
    return true;
}
 
bool FatFsStorageManager::writeFile(const std::string& path, const unsigned char* data, size_t size)
{
    if (!ensureMounted())
    {
        TRACE("SD card not mounted — cannot write to file: %s\n", path.c_str());
        return false;
    }
 
    FF_FILE* file = ff_fopen(resolvePath(path).c_str(), "w");
    if (!file)
        return false;
 
    size_t written = ff_fwrite(data, 1, size, file);
    ff_fclose(file);
 
    return (written == size);
}
 
bool FatFsStorageManager::remove(const std::string &path)
{
    if (!ensureMounted())
    {
        TRACE("SD card not mounted — cannot remove file: %s\n", path.c_str());
        return false;
    }
    return ff_remove(resolvePath(path).c_str()) == FF_ERR_NONE;
}
 
bool FatFsStorageManager::rename(const std::string &from, const std::string &to)
{
    if (!ensureMounted())
    {
        TRACE("SD card not mounted — cannot rename file %s to file: %s\n", from.c_str(), to.c_str());
        return false;
    }
    return ff_rename(resolvePath(from).c_str(), resolvePath(to).c_str(), false) == 0;
}
 
bool FatFsStorageManager::streamFile(const std::string &path, std::function<void(const uint8_t *, size_t)> chunkCallback)
{
    if (!ensureMounted())
    {
        TRACE("SD card not mounted — cannot stream file: %s\n", path.c_str());
        return false;
    }
    FF_FILE *file = ff_fopen(resolvePath(path).c_str(), "r");
    if (!file)
        return false;
 
    uint8_t buffer[HTTP_BUFFER_SIZE];
    size_t bytes;
    while ((bytes = ff_fread(buffer, 1, sizeof(buffer), file)) > 0)
    {
        chunkCallback(buffer, bytes);
    }
 
    ff_fclose(file);
    return true;
}
 
size_t FatFsStorageManager::getFileSize(const std::string &path)
{
    if (!ensureMounted())
    {
        TRACE("SD card not mounted — cannot get file size: %s\n", path.c_str());
        return false;
    }
    FF_FILE *file = ff_fopen(resolvePath(path).c_str(), "r");
    if (!file)
        return 0;
 
    ff_fseek(file, 0, SEEK_END);
    long size = ff_ftell(file);
    ff_fclose(file);
 
    return (size >= 0) ? static_cast<size_t>(size) : 0;
}
 
bool FatFsStorageManager::appendToFile(const std::string &path, const uint8_t *data, size_t size)
{
    if (!ensureMounted())
    {
        TRACE("SD card not mounted — cannot append to file: %s\n", path.c_str());
        return false;
    }
    FF_FILE *file = ff_fopen(resolvePath(path).c_str(), "a");
    if (!file)
        return false;
 
    size_t written = ff_fwrite(data, 1, size, file);
    ff_fclose(file);
    return written == size;
}
 
std::string FatFsStorageManager::resolvePath(const std::string &path) const
{
    std::string fullPath = "/" + mountPoint;
    if (!path.empty())
    {
        if (path[0] != '/')
            fullPath += "/";
        fullPath += path;
    }
 
    // Normalize duplicate slashes
    std::string normalized;
    bool lastWasSlash = false;
    for (char c : fullPath)
    {
        if (c == '/')
        {
            if (!lastWasSlash)
            {
                normalized += c;
                lastWasSlash = true;
            }
        }
        else
        {
            normalized += c;
            lastWasSlash = false;
        }
    }
 
    return normalized;
}
 
bool FatFsStorageManager::ensureMounted()
{
    if (!mounted)
    {
        return mount();
    }
    return true;
}
 
bool FatFsStorageManager::isMounted() const
{
    return mounted;
}
 
void FatFsStorageManager::refreshMountState()
{
    if (mounted && !probeMountPoint())
    {
        TRACE("SD no longer accessible — marking as unmounted\n");
        mounted = false;
    }
}
 
bool FatFsStorageManager::probeMountPoint()
{
    FF_FindData_t xFindStruct = {};
    std::string root = "/" + mountPoint;
    int result = ff_findfirst(root.c_str(), &xFindStruct);
    return result == FF_ERR_NONE;
}
 
bool FatFsStorageManager::formatStorage()
{
    if (!mounted) {
        printf("[FatFs] Cannot format: card not mounted\n");
        return false;
    }
 
    if (!format(mountPoint.c_str())) {
        printf("[FatFs] Format failed for device: %s\n", mountPoint.c_str());
        return false;
    }
 
    printf("[FatFs] Format successful for device: %s\n", mountPoint.c_str());
 
    // Optionally re-mount to refresh filesystem state
    unmount();
    mount();
 
    return mounted;
}
 
bool FatFsStorageManager::readFileString(const std::string &path, uint32_t startPosition, uint32_t length, std::string &buffer)
{
    if (!ensureMounted())
    {
        TRACE("SD card not mounted — cannot read file string: %s\n", path.c_str());
        return false;
    }
 
    FF_FILE *file = ff_fopen(resolvePath(path).c_str(), "r");
    if (!file)
    {
        TRACE("Failed to open file: %s\n", path.c_str());
        return false;
    }
 
    ff_fseek(file, 0, SEEK_END);
    size_t fileSize = ff_ftell(file);
    if (startPosition >= fileSize)
    {
        ff_fclose(file);
        buffer.clear();
        return true;
    }
 
    size_t readLength = std::min<size_t>(length, fileSize - startPosition);
    ff_fseek(file, startPosition, SEEK_SET);
 
    buffer.resize(readLength);
    size_t bytesRead = ff_fread(buffer.data(), 1, readLength, file);
    ff_fclose(file);
 
    if (bytesRead != readLength)
    {
        buffer.resize(bytesRead);
        TRACE("Read only %zu bytes from file: %s\n", bytesRead, path.c_str());
    }
 
    return true;
}
 
 
#include "storage/FatFsFileReader.h"
 
std::unique_ptr<StorageFileReader> FatFsStorageManager::openReader(const std::string& path) {
    if (!ensureMounted()) return nullptr;
 
    auto reader = std::make_unique<FatFsFileReader>();
    if (!reader->open(resolvePath(path))) return nullptr;
    return reader;
}