304 lines
10 KiB
Rust
304 lines
10 KiB
Rust
use crate::card::model::RawCard;
|
|
use crate::peripherals::Mutex;
|
|
use crate::peripherals::storage::Nvs;
|
|
use alloc::sync::Arc;
|
|
use alloc::vec::Vec;
|
|
use binary_serde::{BinarySerde, DeserializeError, Endianness};
|
|
use core::error::Error;
|
|
use core::fmt::Display;
|
|
use esp_nvs::Key;
|
|
|
|
const NVS_NAMESPACE_CARDSTORE: Key = Key::from_str("CARDSTORE");
|
|
const NVS_NAMESPACE_CARDSTORE_METADATA: Key = Key::from_str("CSMETA");
|
|
const NVS_NAMESPACE_CARDSTORE_CARDS: Key = Key::from_str("CSCARDS");
|
|
|
|
const NVS_CARDSTORE_INITIALIZED_KEY: Key = Key::from_str("INITIALIZED");
|
|
const NVS_CARDSTORE_CARDCOUNT_KEY: Key = Key::from_str("CARDCOUNT");
|
|
|
|
const NVS_CARDSTORE_DUMMY_KEY: Key = Key::from_str("DUMMY");
|
|
|
|
#[derive(Debug)]
|
|
pub enum CardStoreError {
|
|
Store(esp_nvs::error::Error),
|
|
CorruptedEntry(DeserializeError),
|
|
NoEntry(u32),
|
|
}
|
|
|
|
impl Error for CardStoreError {}
|
|
|
|
impl Display for CardStoreError {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
|
match self {
|
|
CardStoreError::Store(e) => e.fmt(f),
|
|
CardStoreError::CorruptedEntry(e) => e.fmt(f),
|
|
CardStoreError::NoEntry(uuid) => write!(f, "No Card Entry\nuuid: 0x{uuid:x}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<esp_nvs::error::Error> for CardStoreError {
|
|
fn from(error: esp_nvs::error::Error) -> CardStoreError {
|
|
CardStoreError::Store(error)
|
|
}
|
|
}
|
|
|
|
impl From<DeserializeError> for CardStoreError {
|
|
fn from(error: DeserializeError) -> CardStoreError {
|
|
CardStoreError::CorruptedEntry(error)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, BinarySerde, PartialEq, Eq, Clone)]
|
|
pub struct CardStoreMetaData {
|
|
pub creation_date: u64,
|
|
pub last_read_date: u64,
|
|
|
|
// how often a card has been read by nfc
|
|
pub read_count: u32,
|
|
}
|
|
|
|
impl CardStoreMetaData {
|
|
fn new(creation_date: u64) -> Self {
|
|
Self {
|
|
creation_date: creation_date,
|
|
last_read_date: creation_date,
|
|
read_count: 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct CardStore {
|
|
nvs: Arc<Mutex<Nvs>>,
|
|
}
|
|
|
|
impl CardStore {
|
|
pub async fn new(nvs: Arc<Mutex<Nvs>>) -> Result<Self, CardStoreError> {
|
|
if !Self::is_initialized(&nvs).await? {
|
|
log::info!("CardStore has not been initialized");
|
|
Self::initialize(&nvs).await?;
|
|
}
|
|
|
|
log::info!("CardStore has been initialized");
|
|
let card_count = nvs
|
|
.lock()
|
|
.await
|
|
.get::<u32>(&NVS_NAMESPACE_CARDSTORE, &NVS_CARDSTORE_CARDCOUNT_KEY)?;
|
|
log::info!("Cards stored in flash: {card_count}");
|
|
|
|
Ok(Self { nvs })
|
|
}
|
|
|
|
async fn is_initialized(nvs: &Mutex<Nvs>) -> Result<bool, CardStoreError> {
|
|
log::info!("check initialization");
|
|
let mut nvs_lock = nvs.lock().await;
|
|
match nvs_lock.get::<bool>(&NVS_NAMESPACE_CARDSTORE, &NVS_CARDSTORE_INITIALIZED_KEY) {
|
|
Ok(initialized) => {
|
|
log::debug!("initialization_check: initialized {initialized:?}");
|
|
return Ok(true);
|
|
}
|
|
Err(esp_nvs::error::Error::NamespaceNotFound) => {
|
|
log::debug!("initialization_check: error: namespace not found");
|
|
return Ok(false);
|
|
}
|
|
Err(esp_nvs::error::Error::KeyNotFound) => {
|
|
log::debug!("initialization_check: error: key not found");
|
|
return Ok(false);
|
|
}
|
|
Err(error) => return Err(error.into()),
|
|
};
|
|
}
|
|
|
|
// initializing cardstore with 0 cards, so that all namespaces exist and there
|
|
// are only keynotfound errors in the future
|
|
async fn initialize(nvs: &Mutex<Nvs>) -> Result<(), CardStoreError> {
|
|
log::info!("initializing card store");
|
|
|
|
Self::delete_all_cards(nvs).await?;
|
|
|
|
let mut nvs_lock = nvs.lock().await;
|
|
|
|
log::debug!("initialization: write card count");
|
|
// initialize card count
|
|
nvs_lock.set::<u32>(&NVS_NAMESPACE_CARDSTORE, &NVS_CARDSTORE_CARDCOUNT_KEY, 0)?;
|
|
|
|
// initialize card namespace
|
|
let dummy_card = RawCard::default();
|
|
let mut carddata_serialized: [u8; RawCard::SERIALIZED_SIZE] = [0; RawCard::SERIALIZED_SIZE];
|
|
dummy_card.binary_serialize(&mut carddata_serialized, Endianness::Little);
|
|
|
|
log::debug!("initialization: write dummy card");
|
|
nvs_lock.set::<&[u8]>(
|
|
&NVS_NAMESPACE_CARDSTORE_CARDS,
|
|
&NVS_CARDSTORE_DUMMY_KEY,
|
|
&carddata_serialized,
|
|
)?;
|
|
|
|
// initialize metadata namespace
|
|
log::debug!("initialization: write dummy metadata");
|
|
let dummy_metadata = CardStoreMetaData::new(0);
|
|
|
|
let mut metadata_serialized: [u8; CardStoreMetaData::SERIALIZED_SIZE] =
|
|
[0; CardStoreMetaData::SERIALIZED_SIZE];
|
|
|
|
dummy_metadata.binary_serialize(&mut metadata_serialized, Endianness::Little);
|
|
|
|
nvs_lock.set::<&[u8]>(
|
|
&NVS_NAMESPACE_CARDSTORE_METADATA,
|
|
&NVS_CARDSTORE_DUMMY_KEY,
|
|
&metadata_serialized,
|
|
)?;
|
|
|
|
// set initialized
|
|
log::debug!("initialization: write initialized");
|
|
nvs_lock.set::<bool>(
|
|
&NVS_NAMESPACE_CARDSTORE,
|
|
&NVS_CARDSTORE_INITIALIZED_KEY,
|
|
true,
|
|
)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn delete_all_cards(nvs: &Mutex<Nvs>) -> Result<(), CardStoreError> {
|
|
log::info!("delete all cards");
|
|
let mut nvs_lock = nvs.lock().await;
|
|
let keys = nvs_lock.keys().collect::<Result<Vec<_>, _>>()?;
|
|
for (namespace, key) in keys {
|
|
if namespace == NVS_NAMESPACE_CARDSTORE || namespace == NVS_NAMESPACE_CARDSTORE_METADATA
|
|
{
|
|
nvs_lock.delete(&namespace, &key)?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn load_card_count(&self) -> Result<u32, CardStoreError> {
|
|
log::debug!("load card count");
|
|
let mut nvs_lock = self.nvs.lock().await;
|
|
let result = nvs_lock.get::<u32>(&NVS_NAMESPACE_CARDSTORE, &NVS_CARDSTORE_CARDCOUNT_KEY)?;
|
|
log::debug!("card count: {result}");
|
|
Ok(result)
|
|
}
|
|
|
|
pub async fn load_raw_card(&self, uuid: u32) -> Result<Option<RawCard>, CardStoreError> {
|
|
log::debug!("load raw card\nuuid: 0x{uuid:x}");
|
|
let nvs_key = RawCard::nvs_key_from_uuid(uuid);
|
|
let mut nvs_lock = self.nvs.lock().await;
|
|
|
|
let carddata_binary: Vec<u8> = match nvs_lock.get(&NVS_NAMESPACE_CARDSTORE_CARDS, &nvs_key)
|
|
{
|
|
Ok(carddata) => carddata,
|
|
Err(esp_nvs::error::Error::KeyNotFound) => return Ok(None),
|
|
Err(error) => return Err(error.into()),
|
|
};
|
|
|
|
let carddata = RawCard::binary_deserialize(carddata_binary.as_ref(), Endianness::Little)?;
|
|
Ok(Some(carddata))
|
|
}
|
|
|
|
async fn write_card(&self, nvs_key: Key, card: &RawCard) -> Result<(), CardStoreError> {
|
|
log::debug!("writing card...\nkey: {nvs_key:?}");
|
|
let mut carddata_serialized: [u8; RawCard::SERIALIZED_SIZE] = [0; RawCard::SERIALIZED_SIZE];
|
|
card.binary_serialize(&mut carddata_serialized, Endianness::Little);
|
|
|
|
self.nvs.lock().await.set::<&[u8]>(
|
|
&NVS_NAMESPACE_CARDSTORE_CARDS,
|
|
&nvs_key,
|
|
&carddata_serialized,
|
|
)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn update_card_metadata(
|
|
&self,
|
|
nvs_key: Key,
|
|
timestamp: u64,
|
|
) -> Result<bool, CardStoreError> {
|
|
log::debug!("updating card metadata...\nkey: {nvs_key:?}\ntimestamp: {timestamp}");
|
|
let mut is_new = false;
|
|
// update metadata
|
|
let metadata: CardStoreMetaData =
|
|
if let Some(mut metadata) = self.load_card_metadata(nvs_key).await? {
|
|
log::debug!("found existing card");
|
|
metadata.last_read_date = timestamp;
|
|
metadata.read_count += 1;
|
|
metadata
|
|
} else {
|
|
log::debug!("new card");
|
|
is_new = true;
|
|
CardStoreMetaData::new(timestamp)
|
|
};
|
|
|
|
let mut metadata_serialized: [u8; CardStoreMetaData::SERIALIZED_SIZE] =
|
|
[0; CardStoreMetaData::SERIALIZED_SIZE];
|
|
|
|
metadata.binary_serialize(&mut metadata_serialized, Endianness::Little);
|
|
|
|
self.nvs.lock().await.set::<&[u8]>(
|
|
&NVS_NAMESPACE_CARDSTORE_METADATA,
|
|
&nvs_key,
|
|
&metadata_serialized,
|
|
)?;
|
|
|
|
Ok(is_new)
|
|
}
|
|
|
|
async fn increment_card_count(&self) -> Result<(), CardStoreError> {
|
|
log::debug!("incrementing card count");
|
|
let card_count: u32 = self.load_card_count().await?;
|
|
log::debug!("previous card count: {card_count}");
|
|
self.nvs.lock().await.set::<u32>(
|
|
&NVS_NAMESPACE_CARDSTORE,
|
|
&NVS_CARDSTORE_CARDCOUNT_KEY,
|
|
card_count + 1,
|
|
)?;
|
|
|
|
let card_count = self
|
|
.nvs
|
|
.lock()
|
|
.await
|
|
.get::<u32>(&NVS_NAMESPACE_CARDSTORE, &NVS_CARDSTORE_CARDCOUNT_KEY)?;
|
|
log::info!("Cards stored in flash: {card_count}");
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn save_raw_card(
|
|
&self,
|
|
card: &RawCard,
|
|
timestamp: u64,
|
|
) -> Result<(), CardStoreError> {
|
|
log::debug!("saving raw card\ntimestamp: {timestamp}");
|
|
let nvs_key = card.get_nvs_key();
|
|
|
|
self.write_card(nvs_key, card).await?;
|
|
|
|
let new_card = self.update_card_metadata(nvs_key, timestamp).await?;
|
|
|
|
if new_card {
|
|
self.increment_card_count().await?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn load_card_metadata(
|
|
&self,
|
|
nvs_key: Key,
|
|
) -> Result<Option<CardStoreMetaData>, CardStoreError> {
|
|
log::debug!("load card meta data\nkey: {nvs_key:?}");
|
|
let mut nvs_lock = self.nvs.lock().await;
|
|
let metadata_binary: Vec<u8> =
|
|
match nvs_lock.get(&NVS_NAMESPACE_CARDSTORE_METADATA, &nvs_key) {
|
|
Ok(metadata) => metadata,
|
|
Err(esp_nvs::error::Error::KeyNotFound) => return Ok(None),
|
|
Err(error) => return Err(error.into()),
|
|
};
|
|
|
|
let metadata =
|
|
CardStoreMetaData::binary_deserialize(metadata_binary.as_ref(), Endianness::Little)?;
|
|
|
|
Ok(Some(metadata))
|
|
}
|
|
}
|