created a library out of the ble_module

qaul · MathJud · May 30, 2022 · Jul 18, 2022 · Jul 20, 2022 · Sep 20, 2022
commit 13af7857279a0607c6bc826c5776061136f847bc
diff --git a/rust/ble_module/src/ble/ble_service.rs b/rust/ble_module/src/ble/ble_service.rs
@@ -94,12 +94,12 @@ impl IdleBleService {
                 .ble_handles
                 .push(QaulBleHandle::AdvertisementHandle(handle)),
             Err(err) => {
-                error!("{:#?}", err);
+                log::error!("{:#?}", err);
                 return QaulBleService::Idle(self);
             }
         };
 
-        debug!(
+        log::debug!(
             "Advertising qaul main BLE service at UUID {}",
             main_service_uuid()
         );
@@ -121,7 +121,7 @@ impl IdleBleService {
                     fun: Box::new(move |req| {
                         let value = qaul_id.clone();
                         async move {
-                            debug!("Read request {:?} with value {:x?}", &req, &value);
+                            log::debug!("Read request {:?} with value {:x?}", &req, &value);
                             Ok(value.to_vec())
                         }
                         .boxed()
@@ -164,7 +164,7 @@ impl IdleBleService {
         match self.adapter.serve_gatt_application(app).await {
             Ok(handle) => self.ble_handles.push(QaulBleHandle::AppHandle(handle)),
             Err(err) => {
-                error!("{:#?}", err);
+                log::error!("{:#?}", err);
                 return QaulBleService::Idle(self);
             }
         };
@@ -187,7 +187,7 @@ impl IdleBleService {
                 _ => None,
             }),
             Err(err) => {
-                error!("{:#?}", err);
+                log::error!("{:#?}", err);
                 return QaulBleService::Idle(self);
             }
         };
@@ -215,11 +215,13 @@ impl IdleBleService {
         while let Some(evt) = merged_ble_streams.next().await {
             match evt {
                 BleMainLoopEvent::Stop => {
-                    info!("Received stop signal, stopping advertising, scanning, and listening.");
+                    log::info!(
+                        "Received stop signal, stopping advertising, scanning, and listening."
+                    );
                     break;
                 }
                 BleMainLoopEvent::MessageReceived(e) => {
-                    info!(
+                    log::info!(
                         "Received {} bytes of data from {}",
                         e.0.len(),
                         mac_to_string(&e.1)
@@ -247,7 +249,7 @@ impl IdleBleService {
                             }
                         }
                         Err(err) => {
-                            error!("{:#?}", err);
+                            log::error!("{:#?}", err);
                         }
                     }
                 }
@@ -272,7 +274,7 @@ impl IdleBleService {
 
         let stringified_addr = mac_to_string(&device.address());
         let uuids = device.uuids().await?.unwrap_or_default();
-        trace!(
+        log::trace!(
             "Discovered device {} with service UUIDs {:?}",
             &stringified_addr,
             &uuids
@@ -281,11 +283,11 @@ impl IdleBleService {
         if !uuids.contains(&main_service_uuid()) {
             return Ok(msg_receivers);
         }
-        debug!("Discovered qaul bluetooth device {}", &stringified_addr);
+        log::debug!("Discovered qaul bluetooth device {}", &stringified_addr);
 
         if !device.is_connected().await? {
             device.connect().await?;
-            info!("Connected to device {}", &stringified_addr);
+            log::info!("Connected to device {}", &stringified_addr);
         }
 
         for service in device.services().await? {
@@ -297,7 +299,7 @@ impl IdleBleService {
                 let flags = char.flags().await?;
                 if flags.notify || flags.indicate {
                     msg_receivers.push(char.notify_io().await?);
-                    info!(
+                    log::info!(
                         "Setting up notification for characteristic {} of device {}",
                         char.uuid().await?,
                         &stringified_addr
@@ -331,7 +333,7 @@ impl IdleBleService {
                         reader.device_address(),
                     )))
                     .await
-                    .map_err(|err| error!("{:#?}", err));
+                    .map_err(|err| log::error!("{:#?}", err));
             }
         });
     }
@@ -351,7 +353,7 @@ impl StartedBleService {
 
         if !device.is_connected().await? {
             device.connect().await?;
-            info!("Connected to device {}", &stringified_addr);
+            log::info!("Connected to device {}", &stringified_addr);
         }
 
         for service in device.services().await? {
@@ -369,7 +371,7 @@ impl StartedBleService {
 
     pub async fn stop(self) -> QaulBleService {
         if let Err(err) = self.stop_handle.send(true).await {
-            error!("Failed to stop bluetooth service: {:#?}", &err);
+            log::error!("Failed to stop bluetooth service: {:#?}", &err);
             send_stop_unsuccessful(err.to_string());
             return QaulBleService::Started(self);
         }

diff --git a/rust/ble_module/src/lib.rs b/rust/ble_module/src/lib.rs
@@ -0,0 +1,41 @@
+// Copyright (c) 2023 Open Community Project Association https://ocpa.ch
+// This software is published under the AGPLv3 license.
+
+//! # qaul BLE Module for Linux
+//!
+//! qaul BLE module for Linux
+
+use crate::ble::ble_service::IdleBleService;
+use futures::executor::block_on;
+use rpc::msg_loop::listen_for_sys_msgs;
+use std::thread;
+
+mod ble;
+pub mod rpc;
+
+/// initialize and start the ble_module in an own thread
+pub fn init() {
+    // Spawn new thread
+    thread::spawn(move || {
+        block_on(async move {
+            // start BLE module main loop
+            main_loop().await;
+        })
+    });
+}
+
+/// Start the setup and main loop of this library
+async fn main_loop() {
+    let rpc_receiver = rpc::init();
+    let ble_service = IdleBleService::new().await.unwrap_or_else(|err| {
+        log::error!("{:#?}", err);
+        std::process::exit(1);
+    });
+
+    listen_for_sys_msgs(rpc_receiver, ble_service)
+        .await
+        .unwrap_or_else(|err| {
+            log::error!("{:#?}", err);
+            std::process::exit(1);
+        });
+}
diff --git a/rust/ble_module/src/rpc/mod.rs b/rust/ble_module/src/rpc/mod.rs
@@ -13,7 +13,6 @@ pub mod msg_loop;
 pub mod utils;
 
 use async_trait::async_trait;
-use bytes::Bytes;
 use prost::Message;
 use state::Storage;
 
@@ -22,7 +21,7 @@ use proto_sys::Ble;
 /// receiver of the mpsc channel: ui ---> ble_module
 static EXTERN_RECEIVE: Storage<crossbeam_channel::Receiver<Vec<u8>>> = Storage::new();
 /// sender of the mpsc channel: ui ---> ble_module
-static EXTERN_SEND: Storage<async_std::channel::Sender<Bytes>> = Storage::new();
+static EXTERN_SEND: Storage<async_std::channel::Sender<Vec<u8>>> = Storage::new();
 /// sender handle of the mpsc channel: ble_module ---> ui
 static BLE_MODULE_SEND: Storage<crossbeam_channel::Sender<Vec<u8>>> = Storage::new();
 
@@ -32,7 +31,7 @@ pub trait SysRpcReceiver {
 }
 
 pub struct BleRpc {
-    receiver: async_std::channel::Receiver<Bytes>,
+    receiver: async_std::channel::Receiver<Vec<u8>>,
 }
 
 #[async_trait]
@@ -49,7 +48,7 @@ impl SysRpcReceiver for BleRpc {
 
 /// Initialize RPC module
 /// Create the sending and receiving channels and persist them across threads.
-/// Return the receiver for the channel ui ---> ble_module
+/// Return the receiver for the channel libqaul ---> ble_module
 pub fn init() -> BleRpc {
     // create channels
     let (ble_send, ui_rec) = crossbeam_channel::bounded::<Vec<u8>>(32);
@@ -63,16 +62,16 @@ pub fn init() -> BleRpc {
     BleRpc { receiver: ble_rec }
 }
 
-/// send rpc message ui ---> ble_module
+/// send sys message libqaul ---> ble_module
 #[allow(dead_code)]
-pub fn send_to_ble_module(binary_message: Bytes) {
+pub fn send_to_ble_module(binary_message: Vec<u8>) {
     if let Err(err) = EXTERN_SEND.get().try_send(binary_message) {
-        error!("{:?}", err);
+        log::error!("{:?}", err);
     }
 }
 
 /// check whether there are new messages in
-/// the receiving rpc channel ble_module ---> ui
+/// the receiving sys channel ble_module ---> libqaul
 #[allow(dead_code)]
 pub fn receive_from_ble_module() -> Result<Vec<u8>, crossbeam_channel::TryRecvError> {
     EXTERN_RECEIVE.get().try_recv()
@@ -84,22 +83,22 @@ pub fn queue_length_ble_to_ui() -> usize {
     BLE_MODULE_SEND.get().len()
 }
 
-/// send rpc message ble_module ---> ui
+/// send sys message ble_module ---> libqaul
 pub fn send_to_ui(binary_message: Vec<u8>) {
     if let Err(err) = BLE_MODULE_SEND.get().try_send(binary_message) {
-        error!("{:?}", err);
+        log::error!("{:?}", err);
     }
 }
 
-/// Process received binary protobuf encoded RPC message
+/// Process received binary protobuf encoded SYS message
 ///
 /// This function will decode the message from the binary
 /// protobuf format to a rust struct and return it
-pub fn process_received_message(data: Bytes) -> Option<Ble> {
-    match Ble::decode(data.clone()) {
+pub fn process_received_message(data: Vec<u8>) -> Option<Ble> {
+    match Ble::decode(&data[..]) {
         Ok(ble) => Some(ble),
         Err(err) => {
-            error!("{:#?}", err);
+            log::error!("{:#?}", err);
             None
         }
     }

diff --git a/rust/ble_module/src/rpc/msg_loop.rs b/rust/ble_module/src/rpc/msg_loop.rs
@@ -25,11 +25,11 @@ pub async fn listen_for_sys_msgs(
         let evt = rpc_receiver.recv().await;
         match evt {
             None => {
-                info!("Qaul 'sys' message channel closed. Shutting down gracefully.");
+                log::info!("Qaul 'sys' message channel closed. Shutting down gracefully.");
                 break;
             }
             Some(msg) => {
-                debug!("Received 'sys' message: {:#?}", msg);
+                log::debug!("Received 'sys' message: {:#?}", msg);
                 if msg.message.is_none() {
                     continue;
                 }
@@ -38,11 +38,13 @@ pub async fn listen_for_sys_msgs(
                         QaulBleService::Idle(svc) => {
                             let qaul_id = Bytes::from(req.qaul_id);
                             ble_service = svc.advertise_scan_listen(qaul_id, None).await;
-                            debug!("Set up advertisement and scan filter, entering BLE main loop.");
+                            log::debug!(
+                                "Set up advertisement and scan filter, entering BLE main loop."
+                            );
                             send_start_successful();
                         }
                         QaulBleService::Started(_) => {
-                            warn!(
+                            log::warn!(
                                 "Received Start Request, but bluetooth service is already running!"
                             );
                             send_result_already_running()
@@ -53,7 +55,9 @@ pub async fn listen_for_sys_msgs(
                             ble_service = svc.stop().await;
                         }
                         QaulBleService::Idle(_) => {
-                            warn!("Received Stop Request, but bluetooth service is not running!");
+                            log::warn!(
+                                "Received Stop Request, but bluetooth service is not running!"
+                            );
                             send_stop_successful(); // Is this really a success case?
                         }
                     },
@@ -63,14 +67,14 @@ pub async fn listen_for_sys_msgs(
                             Err(err) => send_direct_send_error(req.receiver_id, err.to_string()),
                         },
                         QaulBleService::Idle(_) => {
-                            warn!("Received Direct Send Request, but bluetooth service is not running!");
+                            log::warn!("Received Direct Send Request, but bluetooth service is not running!");
                             send_result_not_running()
                         }
                     },
                     InfoRequest(_) => {
                         spawn(async {
                             get_device_info().await.unwrap_or_else(|err| {
-                                error!("Error getting device info: {:#?}", &err)
+                                log::error!("Error getting device info: {:#?}", &err)
                             })
                         });
                     }