cs_Storage.h

Go to the documentation of this file.

/*
 * Author: Crownstone Team
 * Copyright: Crownstone (https://crownstone.rocks)
 * Date: 24 Nov., 2014
 * License: LGPLv3+, Apache License 2.0, and/or MIT (triple-licensed)
 */
#pragma once
 
#include <ble/cs_Nordic.h>
#include <common/cs_Types.h>
#include <components/libraries/fds/fds.h>
#include <storage/cs_StateData.h>
#include <util/cs_Utils.h>
#include <test/cs_TestAccess.h>
 
#include <vector>
 
enum cs_storage_operation_t {
    CS_STORAGE_OP_READ,
    CS_STORAGE_OP_WRITE,
    CS_STORAGE_OP_REMOVE,
    CS_STORAGE_OP_REMOVE_ALL_VALUES_WITH_ID,
    CS_STORAGE_OP_GC,
};
 
typedef void (*cs_storage_error_callback_t)(cs_storage_operation_t operation, CS_TYPE type, cs_state_id_t id);
 
class Storage {
    friend class TestAccess<Storage>;
public:
    static Storage& getInstance() {
        static Storage instance;
        return instance;
    }
 
    cs_ret_code_t init();
 
    inline bool isInitialized() { return _initialized; }
    bool isBusy();
 
    void setErrorCallback(cs_storage_error_callback_t callback);
 
    cs_ret_code_t findFirst(CS_TYPE type, cs_state_id_t& id);
 
    cs_ret_code_t findNext(CS_TYPE type, cs_state_id_t& id);
 
    cs_ret_code_t read(cs_state_data_t& data);
 
    cs_ret_code_t readV3ResetCounter(cs_state_data_t& data);
 
    cs_ret_code_t readFirst(cs_state_data_t& data);
 
    cs_ret_code_t readNext(cs_state_data_t& data);
 
    cs_ret_code_t write(const cs_state_data_t& data);
 
    cs_ret_code_t remove(CS_TYPE type, cs_state_id_t id);
 
    cs_ret_code_t remove(CS_TYPE type);
 
    cs_ret_code_t remove(cs_state_id_t id);
 
    cs_ret_code_t factoryReset();
 
    cs_ret_code_t garbageCollect();
 
    cs_ret_code_t eraseAllPages();
 
    cs_ret_code_t erasePages(const CS_TYPE doneEvent, void* startAddress, void* endAddress);
 
    uint8_t* allocate(size16_t& size);
 
    void handleFileStorageEvent(fds_evt_t const* p_fds_evt);
 
    void handleFlashOperationSuccess();
 
    void handleFlashOperationError();
 
private:
    Storage() = default;
    Storage(Storage const&) = delete;
    void operator=(Storage const&) = delete;
 
    bool _initialized                          = false;
    bool _registeredFds                        = false;
    cs_storage_error_callback_t _errorCallback = NULL;
 
    fds_find_token_t _findToken;
    CS_TYPE _currentSearchType   = CS_TYPE::CONFIG_DO_NOT_USE;
 
    bool _collectingGarbage      = false;
    bool _removingFile           = false;
    bool _performingFactoryReset = false;
    std::vector<uint16_t> _busyRecordKeys;
 
    uint32_t _erasePage     = 0;
 
    uint32_t _eraseEndPage  = 0;
 
    CS_TYPE _eraseDoneEvent = CS_TYPE::CONFIG_DO_NOT_USE;
 
    cs_ret_code_t findNextInternal(uint16_t recordKey, uint16_t& fileId);
 
    cs_ret_code_t readNextInternal(uint16_t recordKey, uint16_t& fileId, uint8_t* buf, uint16_t size);
 
    cs_ret_code_t readRecord(fds_record_desc_t recordDesc, uint8_t* buf, uint16_t size, uint16_t& fileId);
 
    ret_code_t writeInternal(const cs_state_data_t& data);
 
    ret_code_t garbageCollectInternal();
 
    bool isErasingPages();
 
    void eraseNextPage();
 
    cs_ret_code_t continueFactoryReset();
 
    size16_t getPaddedSize(size16_t size);
 
    uint16_t getFileId(cs_state_id_t valueId);
 
    cs_state_id_t getStateId(uint16_t fileId);
 
    bool isValidRecordKey(uint16_t recordKey);
    bool isValidFileId(uint16_t fileId);
 
    void initSearch(CS_TYPE type);
 
    void initSearch();
 
    //  ret_code_t exists(cs_file_id_t fileId, uint16_t recordKey, bool & result);
 
    ret_code_t exists(cs_file_id_t file_id, uint16_t recordKey, fds_record_desc_t& record_desc, bool& result);
 
    void setBusy(uint16_t recordKey);
    void clearBusy(uint16_t recordKey);
    bool isBusy(uint16_t recordKey);
 
 
    cs_ret_code_t getErrorCode(ret_code_t code);
 
    void handleWriteEvent(fds_evt_t const* p_fds_evt);
    void handleRemoveRecordEvent(fds_evt_t const* p_fds_evt);
    void handleRemoveFileEvent(fds_evt_t const* p_fds_evt);
    void handleGarbageCollectionEvent(fds_evt_t const* p_fds_evt);
};