espnow_protocol.cc

#include "espnow_protocol.h"
#include <esp_timer.h>
#include <esp_log.h>

#define TAG "EspNowProto"

namespace espnow {

void MessageBuilder::InitHeader(MessageHeader& header, MessageType type, const uint8_t* sender_mac) {
    header.version = 1;
    header.type = static_cast<uint8_t>(type);
    header.timestamp = esp_timer_get_time() / 1000; // Convert to milliseconds
    if (sender_mac) {
        memcpy(header.sender_mac, sender_mac, 6);
    } else {
        memset(header.sender_mac, 0, 6);
    }
}

bool MessageBuilder::BuildPairingRequest(
    Message& msg,
    const uint8_t* sender_mac,
    const std::string& device_uuid,
    const std::string& device_name,
    const std::string& agentmail_inbox,
    int8_t rssi)
{
    if (device_uuid.length() >= ESPNOW_UUID_LEN ||
        device_name.length() >= ESPNOW_NAME_LEN ||
        agentmail_inbox.length() >= ESPNOW_INBOX_LEN) {
        ESP_LOGE(TAG, "String length exceeds limits");
        return false;
    }

    memset(&msg, 0, sizeof(Message));
    InitHeader(msg.header, kMessageTypePairingRequest, sender_mac);
    msg.header.payload_size = sizeof(PairingRequestPayload);

    strncpy(msg.payload.pairing_request.device_uuid, device_uuid.c_str(), ESPNOW_UUID_LEN - 1);
    strncpy(msg.payload.pairing_request.device_name, device_name.c_str(), ESPNOW_NAME_LEN - 1);
    strncpy(msg.payload.pairing_request.agentmail_inbox, agentmail_inbox.c_str(), ESPNOW_INBOX_LEN - 1);
    msg.payload.pairing_request.rssi = rssi;

    return true;
}

bool MessageBuilder::BuildPairingResponse(
    Message& msg,
    const uint8_t* sender_mac,
    const std::string& device_uuid,
    const std::string& device_name,
    const std::string& agentmail_inbox,
    bool accepted)
{
    if (device_uuid.length() >= ESPNOW_UUID_LEN ||
        device_name.length() >= ESPNOW_NAME_LEN ||
        agentmail_inbox.length() >= ESPNOW_INBOX_LEN) {
        ESP_LOGE(TAG, "String length exceeds limits");
        return false;
    }

    memset(&msg, 0, sizeof(Message));
    InitHeader(msg.header, kMessageTypePairingResponse, sender_mac);
    msg.header.payload_size = sizeof(PairingResponsePayload);

    strncpy(msg.payload.pairing_response.device_uuid, device_uuid.c_str(), ESPNOW_UUID_LEN - 1);
    strncpy(msg.payload.pairing_response.device_name, device_name.c_str(), ESPNOW_NAME_LEN - 1);
    strncpy(msg.payload.pairing_response.agentmail_inbox, agentmail_inbox.c_str(), ESPNOW_INBOX_LEN - 1);
    msg.payload.pairing_response.accepted = accepted ? 1 : 0;

    return true;
}

bool MessageBuilder::BuildTextMessage(
    Message& msg,
    const uint8_t* sender_mac,
    const std::string& sender_uuid,
    const std::string& sender_name,
    const std::string& text)
{
    if (sender_uuid.length() >= ESPNOW_UUID_LEN ||
        sender_name.length() >= ESPNOW_NAME_LEN ||
        text.length() >= ESPNOW_TEXT_LEN) {
        ESP_LOGE(TAG, "String length exceeds limits");
        return false;
    }

    memset(&msg, 0, sizeof(Message));
    InitHeader(msg.header, kMessageTypeTextMessage, sender_mac);
    msg.header.payload_size = sizeof(TextMessagePayload);

    strncpy(msg.payload.text_message.sender_uuid, sender_uuid.c_str(), ESPNOW_UUID_LEN - 1);
    strncpy(msg.payload.text_message.sender_name, sender_name.c_str(), ESPNOW_NAME_LEN - 1);
    strncpy(msg.payload.text_message.message_text, text.c_str(), ESPNOW_TEXT_LEN - 1);

    return true;
}

bool MessageBuilder::BuildMetadataUpdate(
    Message& msg,
    const uint8_t* sender_mac,
    const std::string& device_uuid,
    const std::string& device_name,
    const std::string& agentmail_inbox)
{
    if (device_uuid.length() >= ESPNOW_UUID_LEN ||
        device_name.length() >= ESPNOW_NAME_LEN ||
        agentmail_inbox.length() >= ESPNOW_INBOX_LEN) {
        ESP_LOGE(TAG, "String length exceeds limits");
        return false;
    }

    memset(&msg, 0, sizeof(Message));
    InitHeader(msg.header, kMessageTypeMetadataUpdate, sender_mac);
    msg.header.payload_size = sizeof(MetadataUpdatePayload);

    strncpy(msg.payload.metadata_update.device_uuid, device_uuid.c_str(), ESPNOW_UUID_LEN - 1);
    strncpy(msg.payload.metadata_update.device_name, device_name.c_str(), ESPNOW_NAME_LEN - 1);
    strncpy(msg.payload.metadata_update.agentmail_inbox, agentmail_inbox.c_str(), ESPNOW_INBOX_LEN - 1);

    return true;
}

bool MessageBuilder::BuildHeartbeat(
    Message& msg,
    const uint8_t* sender_mac,
    uint32_t uptime_seconds,
    int8_t rssi,
    uint8_t battery_level)
{
    memset(&msg, 0, sizeof(Message));
    InitHeader(msg.header, kMessageTypeHeartbeat, sender_mac);
    msg.header.payload_size = sizeof(HeartbeatPayload);

    msg.payload.heartbeat.uptime_seconds = uptime_seconds;
    msg.payload.heartbeat.rssi = rssi;
    msg.payload.heartbeat.battery_level = battery_level;

    return true;
}

bool MessageBuilder::BuildUnpair(
    Message& msg,
    const uint8_t* sender_mac,
    const std::string& device_uuid,
    uint8_t reason)
{
    if (device_uuid.length() >= ESPNOW_UUID_LEN) {
        ESP_LOGE(TAG, "UUID length exceeds limit");
        return false;
    }

    memset(&msg, 0, sizeof(Message));
    InitHeader(msg.header, kMessageTypeUnpair, sender_mac);
    msg.header.payload_size = sizeof(UnpairPayload);

    strncpy(msg.payload.unpair.device_uuid, device_uuid.c_str(), ESPNOW_UUID_LEN - 1);
    msg.payload.unpair.reason = reason;

    return true;
}

bool MessageBuilder::ValidateMessage(const Message& msg, size_t recv_len) {
    // Check minimum size
    if (recv_len < sizeof(MessageHeader)) {
        ESP_LOGE(TAG, "Message too small: %zu bytes", recv_len);
        return false;
    }

    // Check version
    if (msg.header.version != 1) {
        ESP_LOGE(TAG, "Unsupported protocol version: %d", msg.header.version);
        return false;
    }

    // Check message type
    if (msg.header.type < kMessageTypePairingRequest || msg.header.type > kMessageTypeUnpair) {
        ESP_LOGE(TAG, "Invalid message type: %d", msg.header.type);
        return false;
    }

    // Check payload size
    size_t expected_size = sizeof(MessageHeader) + msg.header.payload_size;
    if (recv_len < expected_size) {
        ESP_LOGE(TAG, "Incomplete message: received %zu, expected %zu", recv_len, expected_size);
        return false;
    }

    return true;
}

const char* MessageBuilder::MessageTypeToString(MessageType type) {
    switch (type) {
        case kMessageTypePairingRequest: return "PairingRequest";
        case kMessageTypePairingResponse: return "PairingResponse";
        case kMessageTypeTextMessage: return "TextMessage";
        case kMessageTypeMetadataUpdate: return "MetadataUpdate";
        case kMessageTypeHeartbeat: return "Heartbeat";
        case kMessageTypeUnpair: return "Unpair";
        default: return "Unknown";
    }
}

} // namespace espnow