.. _program_listing_file_components_NVS_src_Storage.cpp:

Program Listing for File Storage.cpp
====================================

|exhale_lsh| :ref:`Return to documentation for file <file_components_NVS_src_Storage.cpp>` (``components/NVS/src/Storage.cpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   
   #include "Storage.h"
   
   #include <cstdint>
   #include "esp_log.h"
   #include "nvs_flash.h"
   #include "defaults.h"
   
   namespace storage {
   
   static const char* TAG = "NVS";
   
   esp_err_t init()
   {   
       esp_err_t err;
   
       ESP_LOGD(TAG, "Initializing NVS");
       err = nvs_flash_init();
       if (err == ESP_ERR_NVS_NO_FREE_PAGES ||
           err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
           ESP_LOGD(TAG, "NVS partition is truncated. Erasing partition...");
   
           err = nvs_flash_erase();
           if (err != ESP_OK) {
               ESP_LOGD(TAG, "Couldn't erase NVS partition");
               return err;
           }
   
           ESP_LOGD(TAG, "Retrying nvs_flash_init");
           return nvs_flash_init();
       }
   
       return err;
   }
   
   NVS::NVS() : m_is_opened(false), m_handle{0} {}
   
   NVS::~NVS()
   {
       close();
   }
   
   esp_err_t NVS::open(const char* name, nvs_open_mode open_mode)
   {
       esp_err_t err;
   
       ESP_LOGD(TAG, "Opening namespace");
   
       if (m_is_opened) close();
   
       err = nvs_open(name, open_mode, &m_handle);
       if (err != ESP_OK) {
           const char* err_str = esp_err_to_name(err);
           ESP_LOGE(TAG, "Couldn't open namespace (%s)", err_str);
           return err;
       }
   
       m_is_opened = true;
       return ESP_OK;
   }
   
   void NVS::close()
   {
       ESP_LOGD(TAG, "Closing namespace");
   
       if (m_is_opened) nvs_close(m_handle);
       m_is_opened = false;
   }
   
   esp_err_t NVS::set_bool(const char* key, bool value)
   {
       return nvs_set_u8(m_handle, key, value ? 1 : 0);
   }
   
   esp_err_t NVS::get_bool(const char* key, bool& value)
   {
       std::uint8_t v = 0;
       esp_err_t err = nvs_get_u8(m_handle, key, &v);
       if (err != ESP_OK) return err;
   
       if (v == 1) {
           value = true;
       } else {
           value = false;
       }
   
       return ESP_OK;
   }
   
   esp_err_t NVS::setString(std::string key, std::string data) 
   {
       return nvs_set_str(m_handle, key.c_str(), data.c_str());
   }
   
   esp_err_t NVS::getString(std::string key,  char* buffer, size_t* length)
   {
   
       return  nvs_get_str(m_handle, key.c_str(), buffer, length);
   }
   
   esp_err_t NVS::commit()
   {
       return nvs_commit(m_handle);
   }
   
   esp_err_t NVS::getIsConfigured(bool& is_configured)
   {
       esp_err_t err;
   
       storage::NVS app_nvs;
       err = app_nvs.open(NVS_APP_NAMESPACE, NVS_READWRITE);
       if (err != ESP_OK) {
           const char* err_str = esp_err_to_name(err);
           ESP_LOGE(TAG,
               "Couldn't open namespace \"%s\" (%s)",
               NVS_APP_NAMESPACE,
               err_str);
           return err;
       }
   
       err = app_nvs.get_bool(NVS_IS_CONFIGURED_KEY, is_configured);
       if (err == ESP_ERR_NVS_NOT_FOUND) {
           // Set is_configured to true on flash so on next init the config is
           // read directly by the ESP-IDF Wi-Fi library component.
           err = app_nvs.set_bool(NVS_IS_CONFIGURED_KEY, true);
           if (err != ESP_OK) return err;
           err = app_nvs.commit();
           if (err != ESP_OK) return err;
           // Set the return variable to "false" to forcibly set the default
           // configuration
           is_configured = false;
       } else {
           return err;
       }
   
       return ESP_OK;
   }
   
   } // namespace nvs