BaseBluetooth.h

Go to the documentation of this file.

 
#pragma once
 
#include "HardwareTypes.h"
#include <cctype>
#include <cstdint>
#include <functional>
#include <string>
#include <string_view>
#include <vector>
 
#define HF_BLUETOOTH_ERR_LIST(X)                                                                   \
  /* Success codes */                                                                              \
  X(BLUETOOTH_SUCCESS, 0, "Success")                                                               \
                                                                                                   \
  /* General errors */                                                                             \
  X(BLUETOOTH_ERR_FAILURE, 1, "General failure")                                                   \
  X(BLUETOOTH_ERR_INVALID_PARAM, 2, "Invalid parameter")                                           \
  X(BLUETOOTH_ERR_NOT_INITIALIZED, 3, "Bluetooth not initialized")                                 \
  X(BLUETOOTH_ERR_ALREADY_INITIALIZED, 4, "Bluetooth already initialized")                         \
  X(BLUETOOTH_ERR_NOT_ENABLED, 5, "Bluetooth not enabled")                                         \
  X(BLUETOOTH_ERR_ALREADY_ENABLED, 6, "Bluetooth already enabled")                                 \
  X(BLUETOOTH_ERR_NOT_CONNECTED, 7, "Bluetooth not connected")                                     \
  X(BLUETOOTH_ERR_ALREADY_CONNECTED, 8, "Bluetooth already connected")                             \
  X(BLUETOOTH_ERR_CONNECTION_FAILED, 9, "Connection failed")                                       \
  X(BLUETOOTH_ERR_DISCONNECTION_FAILED, 10, "Disconnection failed")                                \
  X(BLUETOOTH_ERR_SCAN_FAILED, 11, "Device scan failed")                                           \
  X(BLUETOOTH_ERR_PAIR_FAILED, 12, "Pairing failed")                                               \
  X(BLUETOOTH_ERR_UNPAIR_FAILED, 13, "Unpairing failed")                                           \
  X(BLUETOOTH_ERR_TIMEOUT, 14, "Operation timeout")                                                \
  X(BLUETOOTH_ERR_NO_MEMORY, 15, "Insufficient memory")                                            \
  X(BLUETOOTH_ERR_INVALID_ADDRESS, 16, "Invalid Bluetooth address")                                \
  X(BLUETOOTH_ERR_DEVICE_NOT_FOUND, 17, "Device not found")                                        \
  X(BLUETOOTH_ERR_SERVICE_NOT_FOUND, 18, "Service not found")                                      \
  X(BLUETOOTH_ERR_CHARACTERISTIC_NOT_FOUND, 19, "Characteristic not found")                        \
  X(BLUETOOTH_ERR_AUTHENTICATION_FAILED, 20, "Authentication failed")                              \
  X(BLUETOOTH_ERR_AUTHORIZATION_FAILED, 21, "Authorization failed")                                \
  X(BLUETOOTH_ERR_ENCRYPTION_FAILED, 22, "Encryption failed")                                      \
  X(BLUETOOTH_ERR_OPERATION_NOT_SUPPORTED, 23, "Operation not supported")                          \
  X(BLUETOOTH_ERR_GATT_ERROR, 24, "GATT operation error")                                          \
  X(BLUETOOTH_ERR_INVALID_STATE, 25, "Invalid state for operation")                                \
  X(BLUETOOTH_ERR_PERMISSION_DENIED, 26, "Permission denied")                                      \
  X(BLUETOOTH_ERR_BUSY, 27, "Device or operation busy")                                            \
  X(BLUETOOTH_ERR_SECURITY_ERROR, 28, "Security error")                                            \
  X(BLUETOOTH_ERR_INIT_FAILED, 29, "Initialization failed")                                        \
  X(BLUETOOTH_ERR_NOT_SUPPORTED, 30, "Operation not supported")                                    \
  X(BLUETOOTH_ERR_ALREADY_STARTED, 31, "Operation already started")                                \
  X(BLUETOOTH_ERR_CONFIG_FAILED, 32, "Configuration failed")                                       \
  X(BLUETOOTH_ERR_START_FAILED, 33, "Start operation failed")                                      \
  X(BLUETOOTH_ERR_STOP_FAILED, 34, "Stop operation failed")                                        \
  X(BLUETOOTH_ERR_CONNECTION_NOT_FOUND, 35, "Connection not found")                                \
  X(BLUETOOTH_ERR_MAX_CONNECTIONS_REACHED, 36, "Maximum connections reached")                      \
  X(BLUETOOTH_ERR_SEND_FAILED, 37, "Send operation failed")                                        \
  X(BLUETOOTH_ERR_GATT_SERVICE_ADD_FAILED, 38, "GATT service add failed")                          \
  X(BLUETOOTH_ERR_GATT_CHAR_ADD_FAILED, 39, "GATT characteristic add failed")                      \
  X(BLUETOOTH_ERR_GATT_SERVICE_NOT_FOUND, 40, "GATT service not found")                            \
  X(BLUETOOTH_ERR_GATT_SERVICE_START_FAILED, 41, "GATT service start failed")                      \
  X(BLUETOOTH_ERR_UNKNOWN, 42, "Unknown error")
 
#define X(name, value, desc) name = value,
enum class hf_bluetooth_err_t : hf_u8_t { HF_BLUETOOTH_ERR_LIST(X) };
#undef X
 
constexpr std::string_view HfBluetoothErrToString(hf_bluetooth_err_t err) noexcept {
  switch (err) {
#define X(NAME, VALUE, DESC)                                                                       \
  case hf_bluetooth_err_t::NAME:                                                                   \
    return DESC;
    HF_BLUETOOTH_ERR_LIST(X)
#undef X
  default:
    return HfBluetoothErrToString(hf_bluetooth_err_t::BLUETOOTH_ERR_UNKNOWN);
  }
}
 
enum class hf_bluetooth_mode_t : hf_u8_t {
  HF_BLUETOOTH_MODE_DISABLED = 0, 
  HF_BLUETOOTH_MODE_CLASSIC = 1,  
  HF_BLUETOOTH_MODE_BLE = 2,      
  HF_BLUETOOTH_MODE_DUAL = 3      
};
 
enum class hf_bluetooth_device_type_t : hf_u8_t {
  HF_BLUETOOTH_DEVICE_TYPE_UNKNOWN = 0, 
  HF_BLUETOOTH_DEVICE_TYPE_CLASSIC = 1, 
  HF_BLUETOOTH_DEVICE_TYPE_BLE = 2,     
  HF_BLUETOOTH_DEVICE_TYPE_DUAL = 3     
};
 
enum class hf_bluetooth_state_t : hf_u8_t {
  HF_BLUETOOTH_STATE_DISABLED = 0,      
  HF_BLUETOOTH_STATE_ENABLED = 1,       
  HF_BLUETOOTH_STATE_SCANNING = 2,      
  HF_BLUETOOTH_STATE_CONNECTING = 3,    
  HF_BLUETOOTH_STATE_CONNECTED = 4,     
  HF_BLUETOOTH_STATE_DISCONNECTING = 5, 
  HF_BLUETOOTH_STATE_PAIRING = 6,       
  HF_BLUETOOTH_STATE_PAIRED = 7         
};
 
enum class hf_bluetooth_security_t : hf_u8_t {
  HF_BLUETOOTH_SECURITY_NONE = 0,            
  HF_BLUETOOTH_SECURITY_UNAUTHENTICATED = 1, 
  HF_BLUETOOTH_SECURITY_AUTHENTICATED = 2,   
  HF_BLUETOOTH_SECURITY_AUTHORIZED = 3,      
  HF_BLUETOOTH_SECURITY_ENCRYPTED = 4,       
  HF_BLUETOOTH_SECURITY_AUTHENTICATED_SC = 5 
};
 
enum class hf_bluetooth_scan_type_t : hf_u8_t {
  HF_BLUETOOTH_SCAN_TYPE_PASSIVE = 0, 
  HF_BLUETOOTH_SCAN_TYPE_ACTIVE = 1   
};
 
enum class hf_bluetooth_scan_mode_t : hf_u8_t {
  HF_BLUETOOTH_SCAN_MODE_GENERAL_INQUIRY = 0, 
  HF_BLUETOOTH_SCAN_MODE_LE_GENERAL = 1,      
  HF_BLUETOOTH_SCAN_MODE_LE_LIMITED = 2       
};
 
enum class hf_bluetooth_connection_type_t : hf_u8_t {
  HF_BLUETOOTH_CONNECTION_TYPE_AUTO = 0,    
  HF_BLUETOOTH_CONNECTION_TYPE_CLASSIC = 1, 
  HF_BLUETOOTH_CONNECTION_TYPE_BLE = 2      
};
 
enum class hf_bluetooth_connection_state_t : hf_u8_t {
  HF_BLUETOOTH_CONNECTION_STATE_DISCONNECTED = 0, 
  HF_BLUETOOTH_CONNECTION_STATE_CONNECTING = 1,   
  HF_BLUETOOTH_CONNECTION_STATE_CONNECTED = 2,    
  HF_BLUETOOTH_CONNECTION_STATE_ADVERTISING = 3,  
  HF_BLUETOOTH_CONNECTION_STATE_SCANNING = 4      
};
 
enum class hf_bluetooth_event_t : hf_u8_t {
  HF_BLUETOOTH_EVENT_ENABLED = 0,                    
  HF_BLUETOOTH_EVENT_DISABLED = 1,                   
  HF_BLUETOOTH_EVENT_SCAN_START = 2,                 
  HF_BLUETOOTH_EVENT_SCAN_STOP = 3,                  
  HF_BLUETOOTH_EVENT_DEVICE_FOUND = 4,               
  HF_BLUETOOTH_EVENT_PAIR_REQUEST = 5,               
  HF_BLUETOOTH_EVENT_PAIR_SUCCESS = 6,               
  HF_BLUETOOTH_EVENT_PAIR_FAILED = 7,                
  HF_BLUETOOTH_EVENT_UNPAIR_SUCCESS = 8,             
  HF_BLUETOOTH_EVENT_CONNECT_SUCCESS = 9,            
  HF_BLUETOOTH_EVENT_CONNECT_FAILED = 10,            
  HF_BLUETOOTH_EVENT_DISCONNECT = 11,                
  HF_BLUETOOTH_EVENT_DATA_RECEIVED = 12,             
  HF_BLUETOOTH_EVENT_DATA_SENT = 13,                 
  HF_BLUETOOTH_EVENT_GATT_SERVICE_DISCOVERED = 14,   
  HF_BLUETOOTH_EVENT_GATT_CHARACTERISTIC_READ = 15,  
  HF_BLUETOOTH_EVENT_GATT_CHARACTERISTIC_WRITE = 16, 
  HF_BLUETOOTH_EVENT_GATT_NOTIFICATION = 17          
};
 
struct hf_bluetooth_address_t {
  hf_u8_t addr[6]; 
  std::string ToString() const;
 
  bool FromString(const std::string& addr_str);
 
  bool IsValid() const;
};
 
struct hf_bluetooth_device_info_t {
  hf_bluetooth_address_t address;  
  std::string name;                
  hf_bluetooth_device_type_t type; 
  int8_t rssi;                     
  uint32_t class_of_device;        
  std::vector<std::string> uuids;  
  bool is_bonded;                  
  bool is_connected;               
};
 
struct hf_bluetooth_classic_config_t {
  std::string device_name;          
  bool discoverable;                
  bool connectable;                 
  uint32_t discovery_timeout_ms;    
  hf_bluetooth_security_t security; 
};
 
struct hf_bluetooth_ble_config_t {
  std::string device_name;            
  bool advertising;                   
  bool scannable;                     
  bool connectable;                   
  uint16_t advertising_interval_ms;   
  uint16_t scan_interval_ms;          
  uint16_t scan_window_ms;            
  hf_bluetooth_scan_type_t scan_type; 
  hf_bluetooth_security_t security;   
};
 
struct hf_bluetooth_gatt_service_t {
  std::string uuid; 
  bool is_primary;  
  uint16_t handle;  
};
 
struct hf_bluetooth_gatt_characteristic_t {
  std::string uuid;           
  uint16_t handle;            
  uint8_t properties;         
  std::vector<uint8_t> value; 
};
 
using hf_bluetooth_event_callback_t =
    std::function<void(hf_bluetooth_event_t event, void* event_data)>;
 
using hf_bluetooth_data_callback_t =
    std::function<void(const hf_bluetooth_address_t& address, const std::vector<uint8_t>& data)>;
 
class BaseBluetooth {
public:
  virtual ~BaseBluetooth() noexcept = default;
 
  // ========== Initialization and Configuration ==========
 
  virtual hf_bluetooth_err_t Initialize(hf_bluetooth_mode_t mode) noexcept = 0;
 
  virtual hf_bluetooth_err_t Deinitialize() noexcept = 0;
 
  virtual bool IsInitialized() const noexcept = 0;
 
  virtual hf_bluetooth_err_t Enable() noexcept = 0;
 
  virtual hf_bluetooth_err_t Disable() noexcept = 0;
 
  virtual bool IsEnabled() const noexcept = 0;
 
  virtual hf_bluetooth_err_t SetMode(hf_bluetooth_mode_t mode) noexcept = 0;
 
  virtual hf_bluetooth_mode_t GetMode() const noexcept = 0;
 
  // ========== Device Management ==========
 
  virtual hf_bluetooth_err_t GetLocalAddress(hf_bluetooth_address_t& address) const noexcept = 0;
 
  virtual hf_bluetooth_err_t SetDeviceName(const std::string& name) noexcept = 0;
 
  virtual std::string GetDeviceName() const noexcept = 0;
 
  // ========== Classic Bluetooth Operations ==========
 
  virtual hf_bluetooth_err_t ConfigureClassic(const hf_bluetooth_classic_config_t& config) noexcept = 0;
 
  virtual hf_bluetooth_err_t SetDiscoverable(bool discoverable, uint32_t timeout_ms = 0) noexcept = 0;
 
  virtual bool IsDiscoverable() const noexcept = 0;
 
  // ========== BLE Operations ==========
 
  virtual hf_bluetooth_err_t ConfigureBle(const hf_bluetooth_ble_config_t& config) noexcept = 0;
 
  virtual hf_bluetooth_err_t StartAdvertising() noexcept = 0;
 
  virtual hf_bluetooth_err_t StopAdvertising() noexcept = 0;
 
  virtual bool IsAdvertising() const noexcept = 0;
 
  // ========== Device Discovery ==========
 
  virtual hf_bluetooth_err_t StartScan(
      uint32_t duration_ms = 0,
      hf_bluetooth_scan_type_t type = hf_bluetooth_scan_type_t::HF_BLUETOOTH_SCAN_TYPE_ACTIVE) noexcept = 0;
 
  virtual hf_bluetooth_err_t StopScan() noexcept = 0;
 
  virtual bool IsScanning() const noexcept = 0;
 
  virtual hf_bluetooth_err_t GetDiscoveredDevices(
      std::vector<hf_bluetooth_device_info_t>& devices) noexcept = 0;
 
  virtual hf_bluetooth_err_t ClearDiscoveredDevices() noexcept = 0;
 
  // ========== Connection Management ==========
 
  virtual hf_bluetooth_err_t Connect(const hf_bluetooth_address_t& address,
                                     uint32_t timeout_ms = 0) noexcept = 0;
 
  virtual hf_bluetooth_err_t Disconnect(const hf_bluetooth_address_t& address) noexcept = 0;
 
  virtual bool IsConnected(const hf_bluetooth_address_t& address) const noexcept = 0;
 
  virtual hf_bluetooth_err_t GetConnectedDevices(
      std::vector<hf_bluetooth_device_info_t>& devices) noexcept = 0;
 
  // ========== Pairing and Bonding ==========
 
  virtual hf_bluetooth_err_t Pair(const hf_bluetooth_address_t& address,
                                  const std::string& pin = "") noexcept = 0;
 
  virtual hf_bluetooth_err_t Unpair(const hf_bluetooth_address_t& address) noexcept = 0;
 
  virtual bool IsPaired(const hf_bluetooth_address_t& address) const noexcept = 0;
 
  virtual hf_bluetooth_err_t GetPairedDevices(std::vector<hf_bluetooth_device_info_t>& devices) noexcept = 0;
 
  // ========== Data Transmission ==========
 
  virtual hf_bluetooth_err_t SendData(const hf_bluetooth_address_t& address,
                                      const std::vector<uint8_t>& data) noexcept = 0;
 
  virtual int GetAvailableData(const hf_bluetooth_address_t& address) const noexcept = 0;
 
  virtual hf_bluetooth_err_t ReadData(const hf_bluetooth_address_t& address,
                                      std::vector<uint8_t>& data, size_t max_bytes = 0) noexcept = 0;
 
  // ========== GATT Operations (BLE) ==========
 
  virtual hf_bluetooth_err_t DiscoverServices(
      const hf_bluetooth_address_t& address,
      std::vector<hf_bluetooth_gatt_service_t>& services) noexcept = 0;
 
  virtual hf_bluetooth_err_t DiscoverCharacteristics(
      const hf_bluetooth_address_t& address, const std::string& service_uuid,
      std::vector<hf_bluetooth_gatt_characteristic_t>& characteristics) noexcept = 0;
 
  virtual hf_bluetooth_err_t ReadCharacteristic(const hf_bluetooth_address_t& address,
                                                const std::string& service_uuid,
                                                const std::string& characteristic_uuid,
                                                std::vector<uint8_t>& value) noexcept = 0;
 
  virtual hf_bluetooth_err_t WriteCharacteristic(const hf_bluetooth_address_t& address,
                                                 const std::string& service_uuid,
                                                 const std::string& characteristic_uuid,
                                                 const std::vector<uint8_t>& value,
                                                 bool with_response = true) noexcept = 0;
 
  virtual hf_bluetooth_err_t SubscribeCharacteristic(const hf_bluetooth_address_t& address,
                                                     const std::string& service_uuid,
                                                     const std::string& characteristic_uuid,
                                                     bool enable) noexcept = 0;
 
  // ========== State and Status ==========
 
  virtual hf_bluetooth_state_t GetState() const noexcept = 0;
 
  virtual int8_t GetRssi(const hf_bluetooth_address_t& address) const noexcept = 0;
 
  // ========== Event Handling ==========
 
  virtual hf_bluetooth_err_t RegisterEventCallback(hf_bluetooth_event_callback_t callback) noexcept = 0;
 
  virtual hf_bluetooth_err_t UnregisterEventCallback() noexcept = 0;
 
  virtual hf_bluetooth_err_t RegisterDataCallback(hf_bluetooth_data_callback_t callback) noexcept = 0;
 
  virtual hf_bluetooth_err_t UnregisterDataCallback() noexcept = 0;
 
  // ========== Utility Functions ==========
 
  static std::string_view GetErrorString(hf_bluetooth_err_t error);
 
protected:
  BaseBluetooth() = default;
 
  BaseBluetooth(const BaseBluetooth&) = delete;
 
  BaseBluetooth& operator=(const BaseBluetooth&) = delete;
};
 
inline std::string_view BaseBluetooth::GetErrorString(hf_bluetooth_err_t error) {
#define X(name, value, desc)                                                                       \
  case hf_bluetooth_err_t::name:                                                                   \
    return desc;
  switch (error) {
    HF_BLUETOOTH_ERR_LIST(X)
  default:
    return HfBluetoothErrToString(hf_bluetooth_err_t::BLUETOOTH_ERR_UNKNOWN);
  }
#undef X
}
 
inline std::string hf_bluetooth_address_t::ToString() const {
  char buffer[18];
  snprintf(buffer, sizeof(buffer), "%02X:%02X:%02X:%02X:%02X:%02X", addr[0], addr[1], addr[2],
           addr[3], addr[4], addr[5]);
  return std::string(buffer);
}
 
inline bool hf_bluetooth_address_t::FromString(const std::string& addr_str) {
  if (addr_str.length() != 17)
    return false;
 
  // Validate format: XX:XX:XX:XX:XX:XX
  for (size_t i = 0; i < addr_str.length(); ++i) {
    if (i % 3 == 2) {
      if (addr_str[i] != ':')
        return false;
    } else {
      if (!std::isxdigit(addr_str[i]))
        return false;
    }
  }
 
  // Parse using no-exceptions approach with manual hex conversion
  for (int i = 0; i < 6; i++) {
    size_t pos = i * 3;
    const char* hex_start = addr_str.c_str() + pos;
 
    // Manual hex conversion without exceptions
    unsigned int value = 0;
    for (int j = 0; j < 2; j++) {
      char c = hex_start[j];
      if (c >= '0' && c <= '9') {
        value = (value << 4) + (c - '0');
      } else if (c >= 'A' && c <= 'F') {
        value = (value << 4) + (c - 'A' + 10);
      } else if (c >= 'a' && c <= 'f') {
        value = (value << 4) + (c - 'a' + 10);
      } else {
        return false; // Invalid hex character
      }
    }
 
    if (value > 255)
      return false;
    addr[i] = static_cast<uint8_t>(value);
  }
 
  return true;
}
 
inline bool hf_bluetooth_address_t::IsValid() const {
  for (int i = 0; i < 6; i++) {
    if (addr[i] != 0)
      return true;
  }
  return false;
}