use crate::config::Config;
use crate::devices::{DeviceInfo, DeviceMemory};
use crate::data::{IoTData, BloodPressureData, HeartRateData, BatteryLevelData, DataType, DataStore, TemperatureData, PressureData, AlertData};
use crate::pairing::BluetoothPairing;
use crate::{Error, Result};
use bluer::{Address, AdapterEvent, Device, Session, Adapter};
use futures::stream::StreamExt;
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
use tokio::time::{sleep, interval, timeout};
use uuid::Uuid;
use chrono::Utc;
use tracing::{info, warn, error, debug};
use std::str::FromStr;
pub struct BleManager {
session: Session,
adapter: Adapter,
config: Config,
device_memory: Arc<DeviceMemory>,
bluetooth_pairing: Arc<BluetoothPairing>,
data_store: Arc<DataStore>,
}
impl BleManager {
pub async fn new(config: Config, device_memory: Arc<DeviceMemory>, data_store: Arc<DataStore>) -> Result<Self> {
let session = Session::new().await
.map_err(|e| Error::General(format!("Failed to create Bluetooth session: {}", e)))?;
let adapter = session.default_adapter().await
.map_err(|e| Error::General(format!("No Bluetooth adapter found: {}", e)))?;
let bluetooth_pairing = Arc::new(BluetoothPairing::new().await?);
Ok(Self {
session,
adapter,
config,
device_memory,
bluetooth_pairing,
data_store,
})
}
pub async fn start_discovery_loop(&self) -> Result<()> {
let mut discovery_interval = interval(self.config.bluetooth_scan_duration());
loop {
discovery_interval.tick().await;
if let Err(e) = self.scan_for_devices().await {
error!("Error during device scan: {}", e);
}
}
}
pub async fn scan_for_devices(&self) -> Result<Vec<DeviceInfo>> {
info!("Starting BLE scan with advertisement monitoring...");
let mut discovered_devices = Vec::new();
let discover = self.adapter.discover_devices().await?;
let mut events = discover.take(20);
let scan_result = timeout(Duration::from_secs(5), async {
while let Some(event) = events.next().await {
match event {
AdapterEvent::DeviceAdded(addr) => {
let device = self.adapter.device(addr)?;
if let Ok(name) = device.name().await {
if let Some(name) = name {
let address = addr.to_string();
let now = Utc::now().timestamp();
if let Err(e) = self.device_memory.update_device_from_discovery(
address.clone(),
name.clone(),
now
).await {
warn!("Failed to update device from discovery: {}", e);
} else {
let device_info = DeviceInfo::new(address.clone(), name.clone());
discovered_devices.push(device_info);
info!("Discovered device: {} ({})", name, address);
}
if let Err(e) = self.process_device_advertisements(&device, &address).await {
debug!("Failed to process advertisement data for {}: {}", address, e);
}
}
}
}
_ => {} }
}
Ok::<Vec<DeviceInfo>, Error>(discovered_devices.clone())
}).await;
match scan_result {
Ok(result) => {
info!("Scan completed. Found {} devices", result?.len());
Ok(discovered_devices)
}
Err(_) => {
info!("Scan timed out. Found {} devices", discovered_devices.len());
Ok(discovered_devices)
}
}
}
async fn process_device_advertisements(&self, device: &Device, device_address: &str) -> Result<()> {
if !self.should_process_device_data(device_address).await {
return Ok(());
}
if let Ok(services) = device.uuids().await {
let mut service_data = HashMap::new();
for service_uuid in services.unwrap_or_default() {
let service_str = service_uuid.to_string();
if service_str.contains("2a37") || service_str.contains("2a6d") || service_str.contains("2a6e") || service_str.contains("180f") || service_str.contains("2a46") {
let mock_data = self.generate_mock_service_data(&service_str);
service_data.insert(service_uuid, mock_data);
debug!("Found monitored service {} on device {}", service_str, device_address);
}
}
if !service_data.is_empty() {
let iot_data = self.parse_advertisement_data(device_address, &service_data).await;
for data in iot_data {
info!("Storing advertisement data: {} from {}", data.name(), device_address);
if let Err(e) = self.data_store.add_data_batch(vec![data]).await {
warn!("Failed to store advertisement data: {}", e);
}
}
}
}
Ok(())
}
fn generate_mock_service_data(&self, service_uuid: &str) -> Vec<u8> {
if service_uuid.contains("2a37") {
vec![0x00, 75]
} else if service_uuid.contains("2a6d") {
vec![0xF5, 0x03, 0x00, 0x00]
} else if service_uuid.contains("2a6e") {
vec![23, 0]
} else if service_uuid.contains("180f") {
vec![85]
} else if service_uuid.contains("2a46") {
"test_alert".as_bytes().to_vec()
} else {
Vec::new()
}
}
async fn should_process_device_data(&self, device_address: &str) -> bool {
if let Some(device_info) = self.device_memory.get_device(device_address).await {
device_info.approved
} else {
false
}
}
fn is_supported_device(&self, name: &str) -> bool {
self.config.supported_devices.iter()
.any(|pattern| name.contains(pattern))
}
pub async fn connect_and_collect_data(&self, address: &str) -> Result<Vec<IoTData>> {
let addr = Address::from_str(address)
.map_err(|e| Error::General(format!("Invalid address {}: {}", address, e)))?;
let device = self.adapter.device(addr)
.map_err(|e| Error::General(format!("Failed to get device {}: {}", address, e)))?;
let device_name = device.name().await.unwrap_or_default().unwrap_or_default();
if !device_name.is_empty() && !self.is_supported_device(&device_name) {
warn!("Device {} ({}) is not supported for data collection", device_name, address);
return Ok(Vec::new()); }
if device_name.is_empty() {
warn!("Device {} has no name, skipping data collection", address);
return Ok(Vec::new());
}
debug!("Attempting to connect to supported device: {} ({})", device_name, address);
for attempt in 1..=3 {
if device.is_connected().await.unwrap_or(false) {
break;
}
match device.connect().await {
Ok(()) => {
info!("Connected to device {} on attempt {}", address, attempt);
break;
}
Err(e) if attempt < 3 => {
warn!("Connection attempt {} failed for {}: {}", attempt, address, e);
sleep(Duration::from_millis(500)).await;
}
Err(e) => {
error!("Failed to connect to device {} after 3 attempts: {}", address, e);
return Err(Error::General(format!("Connection failed: {}", e)));
}
}
}
let data = self.collect_device_data(&device, address, &device_name).await?;
if let Err(e) = device.disconnect().await {
warn!("Failed to disconnect from device {}: {}", address, e);
}
Ok(data)
}
async fn collect_device_data(&self, device: &Device, address: &str, device_name: &str) -> Result<Vec<IoTData>> {
let mut collected_data = Vec::new();
let timestamp = Utc::now().timestamp();
if device_name.contains("A&D_UA-651BLE_") || device_name.contains("BLESmart_") {
let mut data_map = HashMap::new();
data_map.insert("sys".to_string(), serde_json::Value::Number(120.into()));
data_map.insert("dias".to_string(), serde_json::Value::Number(80.into()));
let bp_data = BloodPressureData::new(data_map, address.to_string(), timestamp);
collected_data.push(IoTData::BloodPressure(bp_data));
} else if device_name.contains("X4 Smart") {
let mut data_map = HashMap::new();
data_map.insert("rate".to_string(), serde_json::Value::Number(75.into()));
let hr_data = HeartRateData::new(data_map, address.to_string(), timestamp);
collected_data.push(IoTData::HeartRate(hr_data));
} else {
let mut data_map = HashMap::new();
data_map.insert("raw_data".to_string(), serde_json::Value::String("mock_data".to_string()));
data_map.insert("length".to_string(), serde_json::Value::Number(9.into()));
let generic_data = DataType::new(data_map, address.to_string(), timestamp, "generic".to_string());
collected_data.push(IoTData::Generic(generic_data));
}
info!("Collected {} mock data points from device {}", collected_data.len(), address);
Ok(collected_data)
}
async fn parse_characteristic_data(
&self,
address: &str,
device_name: &str,
characteristic_uuid: &Uuid,
data: &[u8],
timestamp: i64,
) -> Option<IoTData> {
if device_name.contains("A&D_UA-651BLE_") || device_name.contains("BLESmart_") {
return self.parse_blood_pressure_data(address, data, timestamp).await;
}
if device_name.contains("X4 Smart") {
return self.parse_heart_rate_data(address, data, timestamp).await;
}
let battery_uuid = Uuid::parse_str("00002a19-0000-1000-8000-00805f9b34fb").unwrap();
if characteristic_uuid == &battery_uuid {
return self.parse_battery_data(address, data, timestamp).await;
}
self.parse_generic_data(address, data, timestamp).await
}
async fn parse_blood_pressure_data(&self, address: &str, data: &[u8], timestamp: i64) -> Option<IoTData> {
if data.len() >= 4 {
let systolic = u16::from_le_bytes([data[1], data[2]]) as i32;
let diastolic = u16::from_le_bytes([data[3], data[4]]) as i32;
let mut data_map = HashMap::new();
data_map.insert("sys".to_string(), serde_json::Value::Number(systolic.into()));
data_map.insert("dias".to_string(), serde_json::Value::Number(diastolic.into()));
let bp_data = BloodPressureData::new(data_map, address.to_string(), timestamp);
Some(IoTData::BloodPressure(bp_data))
} else {
None
}
}
async fn parse_heart_rate_data(&self, address: &str, data: &[u8], timestamp: i64) -> Option<IoTData> {
if !data.is_empty() {
let heart_rate = if data[0] & 0x01 == 0 {
data[1] as i32
} else {
u16::from_le_bytes([data[1], data[2]]) as i32
};
let mut data_map = HashMap::new();
data_map.insert("rate".to_string(), serde_json::Value::Number(heart_rate.into()));
let hr_data = HeartRateData::new(data_map, address.to_string(), timestamp);
Some(IoTData::HeartRate(hr_data))
} else {
None
}
}
async fn parse_battery_data(&self, address: &str, data: &[u8], timestamp: i64) -> Option<IoTData> {
if !data.is_empty() {
let battery_level = data[0] as i32;
let mut data_map = HashMap::new();
data_map.insert("level".to_string(), serde_json::Value::Number(battery_level.into()));
let battery_data = BatteryLevelData::new(data_map, address.to_string(), timestamp);
Some(IoTData::BatteryLevel(battery_data))
} else {
None
}
}
async fn parse_generic_data(&self, address: &str, data: &[u8], timestamp: i64) -> Option<IoTData> {
if !data.is_empty() {
let mut data_map = HashMap::new();
data_map.insert("raw_data".to_string(), serde_json::Value::String(hex::encode(data)));
data_map.insert("length".to_string(), serde_json::Value::Number(data.len().into()));
let generic_data = DataType::new(data_map, address.to_string(), timestamp, "generic".to_string());
Some(IoTData::Generic(generic_data))
} else {
None
}
}
pub async fn parse_advertisement_data(&self, device_address: &str, service_data: &HashMap<uuid::Uuid, Vec<u8>>) -> Vec<IoTData> {
let mut collected_data = Vec::new();
let timestamp = chrono::Utc::now().timestamp();
let type_key_dict = [
("HEART_RATE", "00002a37-0000-1000-8000-00805f9b34fb"),
("PRESSURE", "00002a6d-0000-1000-8000-00805f9b34fb"),
("TEMPERATURE", "00002a6e-0000-1000-8000-00805f9b34fb"),
("BATTERY_LEVEL", "0000180f-0000-1000-8000-00805f9b34fb"),
("ALERT", "00002a46-0000-1000-8000-00805f9b34fb"),
];
for (data_type, uuid_str) in type_key_dict {
if let Ok(target_uuid) = uuid::Uuid::parse_str(uuid_str) {
let mut matched_data: Option<&Vec<u8>> = None;
for (service_uuid, data) in service_data {
if service_uuid.to_string().starts_with(&target_uuid.to_string()) {
matched_data = Some(data);
break;
}
}
if let Some(data) = matched_data {
let iot_data = match data_type {
"HEART_RATE" => {
let data_value = self.parse_signed_le_bytes(data);
debug!("BLE Found {}: Heart rate data: {}", uuid_str, data_value);
let mut data_map = HashMap::new();
data_map.insert("rate".to_string(), serde_json::Value::Number(data_value.into()));
Some(IoTData::HeartRate(HeartRateData::new(data_map, device_address.to_string(), timestamp)))
}
"PRESSURE" => {
let data_value = self.parse_unsigned_le_bytes(data);
debug!("BLE Found {}: Pressure data: {}", uuid_str, data_value);
let mut data_map = HashMap::new();
data_map.insert("level".to_string(), serde_json::json!(data_value as f64));
Some(IoTData::Pressure(PressureData::new(data_map, device_address.to_string(), timestamp)))
}
"TEMPERATURE" => {
let data_value = self.parse_signed_le_bytes(data);
debug!("BLE Found {}: Temperature data: {}", uuid_str, data_value);
let mut data_map = HashMap::new();
data_map.insert("level".to_string(), serde_json::json!(data_value as f64));
Some(IoTData::Temperature(TemperatureData::new(data_map, device_address.to_string(), timestamp)))
}
"BATTERY_LEVEL" => {
let data_value = self.parse_signed_le_bytes(data);
debug!("BLE Found {}: Battery level data: {}", uuid_str, data_value);
let mut data_map = HashMap::new();
data_map.insert("level".to_string(), serde_json::Value::Number(data_value.into()));
Some(IoTData::BatteryLevel(BatteryLevelData::new(data_map, device_address.to_string(), timestamp)))
}
"ALERT" => {
let data_value = self.parse_bytes_to_utf8(data);
debug!("BLE Found {}: Alert data: {:?}", uuid_str, data_value);
if let Some(alert_text) = data_value {
let mut data_map = HashMap::new();
data_map.insert("id".to_string(), serde_json::Value::String(alert_text.clone()));
Some(IoTData::Alert(AlertData::new(data_map, device_address.to_string(), timestamp)))
} else {
None
}
}
_ => None,
};
if let Some(data) = iot_data {
collected_data.push(data);
}
}
}
}
collected_data
}
fn parse_signed_le_bytes(&self, data: &[u8]) -> i32 {
match data.len() {
1 => data[0] as i8 as i32,
2 => i16::from_le_bytes([data[0], data[1]]) as i32,
4 => i32::from_le_bytes([data[0], data[1], data[2], data[3]]),
_ => {
if data.is_empty() { 0 } else { data[0] as i8 as i32 }
}
}
}
fn parse_unsigned_le_bytes(&self, data: &[u8]) -> u32 {
match data.len() {
1 => data[0] as u32,
2 => u16::from_le_bytes([data[0], data[1]]) as u32,
4 => u32::from_le_bytes([data[0], data[1], data[2], data[3]]),
_ => {
if data.is_empty() { 0 } else { data[0] as u32 }
}
}
}
fn parse_bytes_to_utf8(&self, data: &[u8]) -> Option<String> {
match String::from_utf8(data.to_vec()) {
Ok(text) => Some(text),
Err(e) => {
warn!("Failed to decode bytes to UTF-8: {}", e);
None
}
}
}
pub async fn pair_device(&self, address: &str) -> Result<bool> {
info!("Attempting to pair with device: {}", address);
let paired = self.bluetooth_pairing.pair_device(address).await?;
if paired {
self.device_memory.set_device_paired(address, true).await?;
info!("Successfully paired with device: {}", address);
} else {
warn!("Failed to pair with device: {}", address);
}
Ok(paired)
}
pub async fn unpair_device(&self, address: &str) -> Result<bool> {
info!("Unpairing device: {}", address);
let unpaired = self.bluetooth_pairing.unpair_device(address).await?;
if unpaired {
self.device_memory.set_device_paired(address, false).await?;
info!("Successfully unpaired device: {}", address);
} else {
warn!("Failed to unpair device: {}", address);
}
Ok(unpaired)
}
pub async fn is_device_paired(&self, address: &str) -> Result<bool> {
self.bluetooth_pairing.is_device_paired(address).await
}
pub async fn is_device_connected(&self, address: &str) -> Result<bool> {
let addr = Address::from_str(address)
.map_err(|e| Error::General(format!("Invalid address {}: {}", address, e)))?;
let device = self.adapter.device(addr)
.map_err(|e| Error::General(format!("Failed to get device {}: {}", address, e)))?;
device.is_connected().await
.map_err(|e| Error::General(format!("Failed to check connection status for {}: {}", address, e)))
}
pub async fn start_advertisement_monitoring_loop(&self) -> Result<()> {
info!("Starting continuous advertisement monitoring loop...");
let mut monitoring_interval = interval(Duration::from_secs(2));
loop {
monitoring_interval.tick().await;
let all_devices = self.device_memory.get_all_devices().await;
for device_info in all_devices {
if device_info.approved {
if let Ok(addr) = Address::from_str(&device_info.address) {
let device = self.adapter.device(addr).unwrap_or_else(|_| self.adapter.device(addr).unwrap());
if let Err(e) = self.process_device_advertisements(&device, &device_info.address).await {
debug!("Failed to process advertisement data for {}: {}", device_info.address, e);
}
}
}
}
}
}
}