qualia_core_db/net/acoustic_ble_mesh/
ble.rs

1//! BLE transport and BLE Mesh: nodes, addressing, capabilities, the mesh
2//! network/provisioning/configuration/security stack, advertiser, scanner,
3//! and connection management for short-range communication.
4
5use super::*;
6
7/// BLE network for short-range communication
8pub struct BleNetwork {
9    nodes: HashMap<String, BleNode>,
10    mesh_manager: BleMeshManager,
11    advertiser: BleAdvertiser,
12    scanner: BleScanner,
13    connection_manager: BleConnectionManager,
14}
15
16/// BLE node
17#[derive(Debug, Clone)]
18pub struct BleNode {
19    pub node_id: String,
20    pub address: BleAddress,
21    pub capabilities: BleCapabilities,
22    pub role: BleRole,
23    pub connection_state: ConnectionState,
24    pub rssi: i8,
25    pub battery_level: f64,
26}
27
28/// BLE address
29#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
30pub struct BleAddress {
31    pub address: [u8; 6],
32    pub address_type: BleAddressType,
33}
34
35/// BLE address types
36#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
37pub enum BleAddressType {
38    Public,
39    Random,
40    ResolvablePrivate,
41    NonResolvablePrivate,
42}
43
44/// BLE capabilities
45#[derive(Debug, Clone, Serialize, Deserialize)]
46pub struct BleCapabilities {
47    pub max_connections: u8,
48    pub data_length: u16,
49    pub phy_types: Vec<BlePhyType>,
50    pub features: Vec<BleFeature>,
51}
52
53/// BLE PHY types
54#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
55pub enum BlePhyType {
56    LE1M,
57    LE2M,
58    LECoded,
59}
60
61/// BLE features
62#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
63pub enum BleFeature {
64    ExtendedAdvertising,
65    LE2MPHY,
66    LEDataPacketLengthExtension,
67    LLPrivacy,
68    LEExtendedScannerFilterPolicies,
69}
70
71/// BLE roles
72#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
73pub enum BleRole {
74    Peripheral,
75    Central,
76    Observer,
77    Broadcaster,
78}
79
80/// Connection states
81#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
82pub enum ConnectionState {
83    Disconnected,
84    Connecting,
85    Connected,
86    Disconnecting,
87}
88
89/// BLE mesh manager
90pub struct BleMeshManager {
91    mesh_network: BleMeshNetwork,
92    provisioning_manager: ProvisioningManager,
93    configuration_manager: ConfigurationManager,
94    message_handler: MeshMessageHandler,
95}
96
97/// BLE mesh network
98#[derive(Debug, Clone)]
99pub struct BleMeshNetwork {
100    pub network_id: String,
101    pub network_key: [u8; 16],
102    pub iv_index: u32,
103    pub seq_num: u32,
104    pub nodes: HashMap<u16, MeshNode>,
105    pub elements: HashMap<u16, Vec<MeshElement>>,
106}
107
108/// Mesh node
109#[derive(Debug, Clone)]
110pub struct MeshNode {
111    pub unicast_address: u16,
112    pub device_key: [u8; 16],
113    pub composition_data: CompositionData,
114    pub default_ttl: u8,
115    pub features: NodeFeatures,
116}
117
118/// Composition data
119#[derive(Debug, Clone)]
120pub struct CompositionData {
121    pub cid: u16,
122    pub pid: u16,
123    pub vid: u16,
124    pub crpl: u16,
125    pub features: NodeFeatures,
126    pub elements: Vec<Element>,
127}
128
129/// Node features
130#[derive(Debug, Clone)]
131pub struct NodeFeatures {
132    pub relay: bool,
133    pub proxy: bool,
134    pub friend: bool,
135    pub low_power: bool,
136}
137
138/// Element
139#[derive(Debug, Clone)]
140pub struct Element {
141    pub location: u16,
142    pub sig_models: Vec<u16>,
143    pub vendor_models: Vec<u16>,
144}
145
146/// Mesh element
147#[derive(Debug, Clone)]
148pub struct MeshElement {
149    pub element_index: u8,
150    pub location: u16,
151    pub models: Vec<MeshModel>,
152}
153
154/// Mesh model
155#[derive(Debug, Clone)]
156pub struct MeshModel {
157    pub model_id: u16,
158    pub vendor_id: Option<u16>,
159    pub publication: Option<Publication>,
160    pub subscriptions: Vec<u16>,
161}
162
163/// Publication
164#[derive(Debug, Clone)]
165pub struct Publication {
166    pub address: u16,
167    pub app_key_index: u12,
168    pub credential_flag: bool,
169    pub ttl: u8,
170    pub period: u8,
171    pub retransmit: Retransmit,
172}
173
174/// Retransmit
175#[derive(Debug, Clone)]
176pub struct Retransmit {
177    pub count: u3,
178    pub interval: u5,
179}
180
181/// Provisioning manager
182pub struct ProvisioningManager {
183    provisioning_protocol: ProvisioningProtocol,
184    provisioning_data: ProvisioningData,
185    oob_data: Option<OobData>,
186}
187
188/// Provisioning protocols
189#[derive(Debug, Clone, PartialEq)]
190pub enum ProvisioningProtocol {
191    PBADV,
192    PBGATT,
193    PBNOOB,
194    PBALERT,
195}
196
197/// Provisioning data
198#[derive(Debug, Clone)]
199pub struct ProvisioningData {
200    pub network_key: [u8; 16],
201    pub net_key_index: u12,
202    pub flags: u8,
203    pub iv_index: u32,
204    pub unicast_address: u16,
205}
206
207/// OOB data
208#[derive(Debug, Clone)]
209pub struct OobData {
210    pub oob_type: OobType,
211    pub data: Vec<u8>,
212}
213
214/// OOB types
215#[derive(Debug, Clone, PartialEq)]
216pub enum OobType {
217    Static,
218    Output,
219    Input,
220    None,
221}
222
223/// Configuration manager
224pub struct ConfigurationManager {
225    config_database: ConfigDatabase,
226    config_models: Vec<ConfigModel>,
227    access_control: AccessControl,
228}
229
230/// Config database
231#[derive(Debug, Clone)]
232pub struct ConfigDatabase {
233    pub app_keys: HashMap<u12, AppKey>,
234    pub subnet_list: Vec<Subnet>,
235    pub virtual_addresses: HashMap<u16, VirtualAddress>,
236}
237
238/// App key
239#[derive(Debug, Clone)]
240pub struct AppKey {
241    pub key: [u8; 16],
242    pub net_key_index: u12,
243    pub aid: u4,
244}
245
246/// Subnet
247#[derive(Debug, Clone)]
248pub struct Subnet {
249    pub net_key_index: u12,
250    pub app_key_indices: Vec<u12>,
251    pub kr_flag: bool,
252    pub phase: u8,
253}
254
255/// Virtual address
256#[derive(Debug, Clone)]
257pub struct VirtualAddress {
258    pub address: u16,
259    pub label_uuid: [u8; 16],
260}
261
262/// Config model
263#[derive(Debug, Clone)]
264pub struct ConfigModel {
265    pub model_id: u16,
266    pub opcode: u16,
267    pub parameters: Vec<ConfigParameter>,
268}
269
270/// Config parameter
271#[derive(Debug, Clone)]
272pub struct ConfigParameter {
273    pub name: String,
274    pub value: ConfigValue,
275}
276
277/// Config values
278#[derive(Debug, Clone)]
279pub enum ConfigValue {
280    U8(u8),
281    U16(u16),
282    U32(u32),
283    Buffer(Vec<u8>),
284}
285
286/// Access control
287#[derive(Debug, Clone)]
288pub struct AccessControl {
289    pub access_list: Vec<AccessEntry>,
290    pub default_policy: AccessPolicy,
291}
292
293/// Access entry
294#[derive(Debug, Clone)]
295pub struct AccessEntry {
296    pub address: u16,
297    pub permissions: Vec<Permission>,
298}
299
300/// Permissions
301#[derive(Debug, Clone, PartialEq)]
302pub enum Permission {
303    Read,
304    Write,
305    Subscribe,
306    Publish,
307    Admin,
308}
309
310/// Access policies
311#[derive(Debug, Clone, PartialEq)]
312pub enum AccessPolicy {
313    Allow,
314    Deny,
315    RequireAuth,
316}
317
318/// Mesh message handler
319pub struct MeshMessageHandler {
320    message_queue: Vec<MeshMessage>,
321    routing_table: RoutingTable,
322    security_manager: MeshSecurityManager,
323}
324
325/// Mesh message
326#[derive(Debug, Clone)]
327pub struct MeshMessage {
328    pub message_id: String,
329    pub source: u16,
330    pub destination: u16,
331    pub ttl: u8,
332    pub opcode: u16,
333    pub parameters: Vec<u8>,
334    pub app_key_index: u12,
335    pub net_key_index: u12,
336    pub sequence_number: u32,
337    pub timestamp: Instant,
338}
339
340/// Mesh security manager
341pub struct MeshSecurityManager {
342    pub network_keys: HashMap<u12, [u8; 16]>,
343    pub application_keys: HashMap<u12, [u8; 16]>,
344    pub device_keys: HashMap<u16, [u8; 16]>,
345    pub beacon_key: [u8; 16],
346}
347
348/// BLE advertiser
349pub struct BleAdvertiser {
350    advertising_data: Vec<u8>,
351    scan_response_data: Vec<u8>,
352    advertising_parameters: AdvertisingParameters,
353    active_advertisements: Vec<ActiveAdvertisement>,
354}
355
356/// Advertising parameters
357#[derive(Debug, Clone)]
358pub struct AdvertisingParameters {
359    pub interval_min: u16,
360    pub interval_max: u16,
361    pub type_: AdvertisingType,
362    pub filter_policy: AdvertisingFilterPolicy,
363}
364
365/// Advertising types
366#[derive(Debug, Clone, PartialEq)]
367pub enum AdvertisingType {
368    ConnectableUndirected,
369    ConnectableDirected,
370    ScannableUndirected,
371    NonConnectableUndirected,
372}
373
374/// Advertising filter policies
375#[derive(Debug, Clone, PartialEq)]
376pub enum AdvertisingFilterPolicy {
377    AllowScanAny,
378    AllowScanWhitelist,
379    AllowConnectAny,
380    AllowConnectWhitelist,
381}
382
383/// Active advertisement
384#[derive(Debug, Clone)]
385pub struct ActiveAdvertisement {
386    pub handle: u8,
387    pub parameters: AdvertisingParameters,
388    pub data: Vec<u8>,
389    pub status: AdvertisementStatus,
390}
391
392/// Advertisement status
393#[derive(Debug, Clone, PartialEq)]
394pub enum AdvertisementStatus {
395    Active,
396    Paused,
397    Stopped,
398    Error,
399}
400
401/// BLE scanner
402pub struct BleScanner {
403    scanning_parameters: ScanningParameters,
404    scan_filter: ScanFilter,
405    active_scans: Vec<ActiveScan>,
406}
407
408/// Scanning parameters
409#[derive(Debug, Clone)]
410pub struct ScanningParameters {
411    pub interval: u16,
412    pub window: u16,
413    pub type_: ScanningType,
414    pub filter_duplicates: bool,
415}
416
417/// Scanning types
418#[derive(Debug, Clone, PartialEq)]
419pub enum ScanningType {
420    Passive,
421    Active,
422}
423
424/// Scan filter
425#[derive(Debug, Clone)]
426pub struct ScanFilter {
427    pub address_filter: Option<BleAddress>,
428    pub rssi_filter: Option<i8>,
429    pub service_uuid_filter: Vec<u16>,
430}
431
432/// Active scan
433#[derive(Debug, Clone)]
434pub struct ActiveScan {
435    pub handle: u8,
436    pub parameters: ScanningParameters,
437    pub results: Vec<ScanResult>,
438    pub status: ScanStatus,
439}
440
441/// Scan result
442#[derive(Debug, Clone)]
443pub struct ScanResult {
444    pub address: BleAddress,
445    pub rssi: i8,
446    pub advertising_data: Vec<u8>,
447    pub scan_response_data: Vec<u8>,
448    pub timestamp: Instant,
449}
450
451/// Scan status
452#[derive(Debug, Clone, PartialEq)]
453pub enum ScanStatus {
454    Scanning,
455    Paused,
456    Stopped,
457    Error,
458}
459
460/// BLE connection manager
461pub struct BleConnectionManager {
462    connections: HashMap<u16, BleConnection>,
463    connection_parameters: ConnectionParameters,
464    security_manager: BleSecurityManager,
465}
466
467/// BLE connection
468#[derive(Debug, Clone)]
469pub struct BleConnection {
470    pub handle: u16,
471    pub role: BleRole,
472    pub address: BleAddress,
473    pub parameters: ConnectionParameters,
474    pub state: ConnectionState,
475    pub security_level: SecurityLevel,
476    pub mtu: u16,
477    pub data_length: u16,
478}
479
480/// Connection parameters
481#[derive(Debug, Clone)]
482pub struct ConnectionParameters {
483    pub min_interval: u16,
484    pub max_interval: u16,
485    pub latency: u16,
486    pub supervision_timeout: u16,
487    pub min_ce_length: u16,
488    pub max_ce_length: u16,
489}
490
491/// Security levels
492#[derive(Debug, Clone, PartialEq)]
493pub enum SecurityLevel {
494    None,
495    Low,
496    Medium,
497    High,
498    FIPS,
499}
500
501/// BLE security manager
502pub struct BleSecurityManager {
503    pub encryption_keys: HashMap<u16, EncryptionKey>,
504    pub identity_keys: HashMap<u16, IdentityKey>,
505    pub signing_keys: HashMap<u16, SigningKey>,
506    pub csrk: HashMap<u16, Csrk>,
507}
508
509/// Encryption key
510#[derive(Debug, Clone)]
511pub struct EncryptionKey {
512    pub ltk: [u8; 16],
513    pub rand: [u8; 8],
514    pub ediv: u16,
515}
516
517/// Identity key
518#[derive(Debug, Clone)]
519pub struct IdentityKey {
520    pub irk: [u8; 16],
521    pub address: BleAddress,
522}
523
524/// Signing key
525#[derive(Debug, Clone)]
526pub struct SigningKey {
527    pub csrk: [u8; 16],
528    pub counter: u32,
529}
530
531/// CSRK
532#[derive(Debug, Clone)]
533pub struct Csrk {
534    pub key: [u8; 16],
535    pub counter: u32,
536}
537
538impl BleNetwork {
539    pub fn new() -> Self {
540        Self {
541            nodes: HashMap::new(),
542            mesh_manager: BleMeshManager::new(),
543            advertiser: BleAdvertiser::new(),
544            scanner: BleScanner::new(),
545            connection_manager: BleConnectionManager::new(),
546        }
547    }
548
549    pub fn initialize(&mut self) -> Result<(), MeshError> {
550        // Initialize BLE network components
551        self.mesh_manager.initialize()?;
552        self.advertiser.initialize()?;
553        self.scanner.initialize()?;
554        self.connection_manager.initialize()?;
555        Ok(())
556    }
557
558    pub fn discover_nodes(&mut self) -> Result<Vec<BleNode>, MeshError> {
559        let mut discovered_nodes = Vec::new();
560
561        // Simulate BLE node discovery
562        for i in 0..10 {
563            let node = BleNode {
564                node_id: format!("ble_node_{}", i),
565                address: BleAddress {
566                    address: [i as u8, 0, 0, 0, 0, 0],
567                    address_type: BleAddressType::Random,
568                },
569                capabilities: BleCapabilities {
570                    max_connections: 3,
571                    data_length: 251,
572                    phy_types: vec![BlePhyType::LE1M, BlePhyType::LE2M],
573                    features: vec![BleFeature::ExtendedAdvertising, BleFeature::LE2MPHY],
574                },
575                role: BleRole::Peripheral,
576                connection_state: ConnectionState::Disconnected,
577                rssi: -60 + (i as i8 * 3),
578                battery_level: 100.0 - (i as f64 * 5.0),
579            };
580
581            self.nodes.insert(node.node_id.clone(), node.clone());
582            discovered_nodes.push(node);
583        }
584
585        Ok(discovered_nodes)
586    }
587
588    pub fn send_message(&mut self, _message: &StoredMessage) -> Result<(), MeshError> {
589        // Send message through BLE network
590        thread::sleep(Duration::from_millis(100)); // Simulate transmission time
591        Ok(())
592    }
593
594    pub fn send_payload(
595        &mut self,
596        _destination: &str,
597        _payload: &[u8],
598        _priority: MessagePriority,
599    ) -> Result<(), MeshError> {
600        thread::sleep(Duration::from_millis(100));
601        Ok(())
602    }
603
604    pub fn get_node_count(&self) -> u32 {
605        self.nodes.len() as u32
606    }
607
608    pub fn optimize_discovery(&mut self) -> Result<(), MeshError> {
609        // Optimize BLE discovery
610        Ok(())
611    }
612}
613
614impl BleMeshManager {
615    pub fn new() -> Self {
616        Self {
617            mesh_network: BleMeshNetwork::new(),
618            provisioning_manager: ProvisioningManager::new(),
619            configuration_manager: ConfigurationManager::new(),
620            message_handler: MeshMessageHandler::new(),
621        }
622    }
623
624    pub fn initialize(&mut self) -> Result<(), MeshError> {
625        self.provisioning_manager.initialize()?;
626        self.configuration_manager.initialize()?;
627        Ok(())
628    }
629
630    pub fn mesh_network(&self) -> &BleMeshNetwork {
631        &self.mesh_network
632    }
633
634    pub fn mesh_network_mut(&mut self) -> &mut BleMeshNetwork {
635        &mut self.mesh_network
636    }
637
638    pub fn provisioning_manager(&self) -> &ProvisioningManager {
639        &self.provisioning_manager
640    }
641
642    pub fn configuration_manager(&self) -> &ConfigurationManager {
643        &self.configuration_manager
644    }
645
646    pub fn message_handler(&self) -> &MeshMessageHandler {
647        &self.message_handler
648    }
649}
650
651impl BleMeshNetwork {
652    pub fn new() -> Self {
653        Self {
654            network_id: "mesh_network_1".to_string(),
655            network_key: [0u8; 16],
656            iv_index: 0,
657            seq_num: 0,
658            nodes: HashMap::new(),
659            elements: HashMap::new(),
660        }
661    }
662}
663
664impl ProvisioningManager {
665    pub fn new() -> Self {
666        Self {
667            provisioning_protocol: ProvisioningProtocol::PBADV,
668            provisioning_data: ProvisioningData {
669                network_key: [0u8; 16],
670                net_key_index: 0,
671                flags: 0,
672                iv_index: 0,
673                unicast_address: 0x0001,
674            },
675            oob_data: None,
676        }
677    }
678
679    pub fn initialize(&mut self) -> Result<(), MeshError> {
680        Ok(())
681    }
682
683    pub fn protocol(&self) -> &ProvisioningProtocol {
684        &self.provisioning_protocol
685    }
686
687    pub fn provisioning_data(&self) -> &ProvisioningData {
688        &self.provisioning_data
689    }
690
691    pub fn set_oob_data(&mut self, data: OobData) {
692        self.oob_data = Some(data);
693    }
694
695    pub fn oob_data(&self) -> Option<&OobData> {
696        self.oob_data.as_ref()
697    }
698}
699
700impl ConfigurationManager {
701    pub fn new() -> Self {
702        Self {
703            config_database: ConfigDatabase::new(),
704            config_models: Vec::new(),
705            access_control: AccessControl::new(),
706        }
707    }
708
709    pub fn initialize(&mut self) -> Result<(), MeshError> {
710        Ok(())
711    }
712
713    pub fn config_database(&self) -> &ConfigDatabase {
714        &self.config_database
715    }
716
717    pub fn config_database_mut(&mut self) -> &mut ConfigDatabase {
718        &mut self.config_database
719    }
720
721    pub fn add_config_model(&mut self, model: ConfigModel) {
722        self.config_models.push(model);
723    }
724
725    pub fn config_models(&self) -> &[ConfigModel] {
726        &self.config_models
727    }
728
729    pub fn access_control(&self) -> &AccessControl {
730        &self.access_control
731    }
732}
733
734impl ConfigDatabase {
735    pub fn new() -> Self {
736        Self {
737            app_keys: HashMap::new(),
738            subnet_list: Vec::new(),
739            virtual_addresses: HashMap::new(),
740        }
741    }
742}
743
744impl AccessControl {
745    pub fn new() -> Self {
746        Self {
747            access_list: Vec::new(),
748            default_policy: AccessPolicy::Allow,
749        }
750    }
751}
752
753impl MeshMessageHandler {
754    pub fn new() -> Self {
755        Self {
756            message_queue: Vec::new(),
757            routing_table: RoutingTable::new(),
758            security_manager: MeshSecurityManager::new(),
759        }
760    }
761
762    pub fn enqueue_message(&mut self, message: MeshMessage) {
763        self.message_queue.push(message);
764    }
765
766    pub fn dequeue_message(&mut self) -> Option<MeshMessage> {
767        self.message_queue.pop()
768    }
769
770    pub fn queue_length(&self) -> usize {
771        self.message_queue.len()
772    }
773
774    pub fn routing_table(&self) -> &RoutingTable {
775        &self.routing_table
776    }
777
778    pub fn security_manager(&self) -> &MeshSecurityManager {
779        &self.security_manager
780    }
781}
782
783impl MeshSecurityManager {
784    pub fn new() -> Self {
785        Self {
786            network_keys: HashMap::new(),
787            application_keys: HashMap::new(),
788            device_keys: HashMap::new(),
789            beacon_key: [0u8; 16],
790        }
791    }
792}
793
794impl BleAdvertiser {
795    pub fn new() -> Self {
796        Self {
797            advertising_data: Vec::new(),
798            scan_response_data: Vec::new(),
799            advertising_parameters: AdvertisingParameters {
800                interval_min: 100,
801                interval_max: 200,
802                type_: AdvertisingType::ConnectableUndirected,
803                filter_policy: AdvertisingFilterPolicy::AllowScanAny,
804            },
805            active_advertisements: Vec::new(),
806        }
807    }
808
809    pub fn initialize(&mut self) -> Result<(), MeshError> {
810        Ok(())
811    }
812
813    pub fn set_advertising_data(&mut self, data: Vec<u8>) {
814        self.advertising_data = data;
815    }
816
817    pub fn advertising_data(&self) -> &[u8] {
818        &self.advertising_data
819    }
820
821    pub fn set_scan_response_data(&mut self, data: Vec<u8>) {
822        self.scan_response_data = data;
823    }
824
825    pub fn scan_response_data(&self) -> &[u8] {
826        &self.scan_response_data
827    }
828
829    pub fn advertising_parameters(&self) -> &AdvertisingParameters {
830        &self.advertising_parameters
831    }
832
833    pub fn start_advertising(&mut self, adv: ActiveAdvertisement) {
834        self.active_advertisements.push(adv);
835    }
836
837    pub fn stop_advertising(&mut self, handle: u8) {
838        self.active_advertisements.retain(|a| a.handle != handle);
839    }
840
841    pub fn active_advertisement_count(&self) -> usize {
842        self.active_advertisements.len()
843    }
844}
845
846impl BleScanner {
847    pub fn new() -> Self {
848        Self {
849            scanning_parameters: ScanningParameters {
850                interval: 100,
851                window: 50,
852                type_: ScanningType::Active,
853                filter_duplicates: true,
854            },
855            scan_filter: ScanFilter {
856                address_filter: None,
857                rssi_filter: None,
858                service_uuid_filter: Vec::new(),
859            },
860            active_scans: Vec::new(),
861        }
862    }
863
864    pub fn initialize(&mut self) -> Result<(), MeshError> {
865        Ok(())
866    }
867
868    pub fn scanning_parameters(&self) -> &ScanningParameters {
869        &self.scanning_parameters
870    }
871
872    pub fn scan_filter(&self) -> &ScanFilter {
873        &self.scan_filter
874    }
875
876    pub fn add_service_uuid_filter(&mut self, uuid: u16) {
877        self.scan_filter.service_uuid_filter.push(uuid);
878    }
879
880    pub fn start_scan(&mut self, scan: ActiveScan) {
881        self.active_scans.push(scan);
882    }
883
884    pub fn stop_scan(&mut self, handle: u8) {
885        self.active_scans.retain(|s| s.handle != handle);
886    }
887
888    pub fn active_scan_count(&self) -> usize {
889        self.active_scans.len()
890    }
891}
892
893impl BleConnectionManager {
894    pub fn new() -> Self {
895        Self {
896            connections: HashMap::new(),
897            connection_parameters: ConnectionParameters {
898                min_interval: 24,
899                max_interval: 40,
900                latency: 0,
901                supervision_timeout: 700,
902                min_ce_length: 0,
903                max_ce_length: 0,
904            },
905            security_manager: BleSecurityManager::new(),
906        }
907    }
908
909    pub fn initialize(&mut self) -> Result<(), MeshError> {
910        Ok(())
911    }
912
913    pub fn add_connection(&mut self, handle: u16, connection: BleConnection) {
914        self.connections.insert(handle, connection);
915    }
916
917    pub fn remove_connection(&mut self, handle: u16) {
918        self.connections.remove(&handle);
919    }
920
921    pub fn connection_count(&self) -> usize {
922        self.connections.len()
923    }
924
925    pub fn get_connection(&self, handle: u16) -> Option<&BleConnection> {
926        self.connections.get(&handle)
927    }
928
929    pub fn connection_parameters(&self) -> &ConnectionParameters {
930        &self.connection_parameters
931    }
932
933    pub fn security_manager(&self) -> &BleSecurityManager {
934        &self.security_manager
935    }
936}
937
938impl BleSecurityManager {
939    pub fn new() -> Self {
940        Self {
941            encryption_keys: HashMap::new(),
942            identity_keys: HashMap::new(),
943            signing_keys: HashMap::new(),
944            csrk: HashMap::new(),
945        }
946    }
947}
qualia_core_db/net/acoustic_ble_mesh/ble.rs

qualia_core_db/net/acoustic_ble_mesh/
ble.rs
