ndef_record.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2025 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_UNIFIED_NFC_NDEF_NDEF_RECORD_HPP
#define M5_UNIT_UNIFIED_NFC_NDEF_NDEF_RECORD_HPP
 
#include "ndef.hpp"
#include <vector>
#include <string>
 
namespace m5 {
namespace nfc {
namespace ndef {
 
class TLV;
 
enum class TNF : uint8_t {
    Empty,      
    Wellknown,  
    MIMEMedia,  
    URI,        
    External,   
    Unknown,    
    Unchanged,  
    Reserved,   
};
 
struct Attribute {
    static constexpr uint8_t MB{0x80};  
    static constexpr uint8_t ME{0x40};  
    static constexpr uint8_t CF{0x20};  
    static constexpr uint8_t SR{0x10};  
    static constexpr uint8_t IL{0x08};  
    static constexpr uint8_t TNF_MASK{0x07};  
 
 
    inline bool messageBegin() const
    {
        return value & MB;
    }
    inline bool messageEnd() const
    {
        return value & ME;
    }
    inline bool chunk() const
    {
        return value & CF;
    }
    inline bool shortRecord() const
    {
        return value & SR;
    }
    inline bool idLength() const
    {
        return value & IL;
    }
    inline TNF tnf() const
    {
        // TNF_MASK (0x07) ensures result is always a valid TNF (0..7)
        return static_cast<TNF>(value & TNF_MASK);
    }
 
 
    inline void messageBegin(const bool b)
    {
        value = (value & ~MB) | (b ? MB : 0);
    }
    inline void messageEnd(const bool b)
    {
        value = (value & ~ME) | (b ? ME : 0);
    }
    inline void chunk(const bool b)
    {
        value = (value & ~CF) | (b ? CF : 0);
    }
    inline void shortRecord(const bool b)
    {
        value = (value & ~SR) | (b ? SR : 0);
    }
    inline void idLength(const bool b)
    {
        value = (value & ~IL) | (b ? IL : 0);
    }
    inline void tnf(const TNF t)
    {
        value = (value & ~TNF_MASK) | (m5::stl::to_underlying(t) & TNF_MASK);
    }
 
    uint8_t value{};
};
 
class Record {
public:
    Record() noexcept : Record(TNF::Wellknown)
    {
    }
 
    explicit Record(const TNF tnf) noexcept
    {
        _attr.tnf(tnf);
    }
    ~Record()
    {
    }
 
 
    inline Attribute& attribute()
    {
        return _attr;
    }
    inline const Attribute& attribute() const
    {
        return _attr;
    }
    inline TNF tnf() const
    {
        return _attr.tnf();
    }
 
 
    inline const char* type() const
    {
        return _type.c_str();
    }
    inline void setType(const char* s)
    {
        if (!s) {
            M5_LIB_LOGW("Ignoring a null type string");
            _type.clear();
            return;
        }
        _type = s;
    }
 
 
    inline uint32_t identifierSize() const
    {
        return _id.size();
    }
    inline const uint8_t* identifier() const
    {
        return !_id.empty() ? _id.data() : nullptr;
    }
    inline void setIdentifier(const uint8_t* id, const uint32_t len)
    {
        if (_attr.tnf() != TNF::Empty && id && len) {
            _id = std::vector<uint8_t>(id, id + len);
            _attr.idLength(true);
        } else {
            _id.clear();
            _attr.idLength(false);
        }
    }
    inline void clearIdentifier()
    {
        setIdentifier(nullptr, 0);
    }
 
 
    std::string payloadAsString() const;
 
    inline uint32_t payloadSize() const
    {
        return _payload.size();
    }
    inline const uint8_t* payload() const
    {
        return !_payload.empty() ? _payload.data() : nullptr;
    }
    inline void setPayload(const uint8_t* data, const uint32_t len)
    {
        if (_attr.tnf() == TNF::Empty || !data || !len) {
            _payload.clear();
            _attr.shortRecord(true);
            return;
        }
        _payload = std::vector<uint8_t>(data, data + len);
        _attr.shortRecord(_payload.size() < 256);
    }
 
 
    bool setTextPayload(const char* str, const char* lang);
    bool setURIPayload(const char* uri, URIProtocol protocol);
 
    uint32_t required() const;
 
    uint32_t encode(uint8_t* buf, const uint32_t blen) const;
    uint32_t decode(const uint8_t* buf, const uint32_t blen);
 
    void clear();
 
    void dump() const;
 
protected:
    bool apply_nested_message();
    bool set_text_payload(const char* str, const char* lang);
    bool set_uri_payload(const char* uri, URIProtocol protocol);
 
private:
    Attribute _attr{};
    std::string _type{};
    std::vector<uint8_t> _payload{};
    std::vector<uint8_t> _id{};
 
    friend bool operator==(const Record& a, const Record& b);
};
 
inline bool operator==(const Record& a, const Record& b)
{
    return a._attr.value == b._attr.value && a._type == b._type && a._payload == b._payload && a._id == b._id;
}
inline bool operator!=(const Record& a, const Record& b)
{
    return !(a == b);
}
 
}  // namespace ndef
}  // namespace nfc
}  // namespace m5
#endif