Add implementation for WebBluetooth

Author: paroga

Cargo.toml

@@ -31,15 +31,15 @@ thiserror = "1.0.30"
 uuid = "0.8.2"
 serde_cr = { package = "serde", version = "1.0.133", features = ["derive"], default-features = false, optional = true }
 serde_bytes = { version = "0.11.5", optional = true }
-dashmap = "5.0.0"
+dashmap = "4.0.2"
 futures = "0.3.19"
 static_assertions = "1.1.0"
 tokio = { version = "1.15.0", features = ["rt", "sync"] }
 tokio-stream = { version = "0.1.8", features = ["sync"] }
 
 [target.'cfg(target_os = "linux")'.dependencies]
 dbus = "0.9.5"
-bluez-async = "0.5.5"
+bluez-async = { version = "0.5.5", optional = true }
 
 [target.'cfg(any(target_os = "macos", target_os = "ios"))'.dependencies]
 cocoa = "0.24.0"
@@ -49,9 +49,29 @@ libc = "0.2.112"
 [target.'cfg(target_os = "windows")'.dependencies]
 windows = { version = "0.28.0", features = ["std", "Devices_Bluetooth", "Devices_Bluetooth_GenericAttributeProfile", "Devices_Bluetooth_Advertisement", "Devices_Radios", "Foundation_Collections", "Foundation", "Storage_Streams"] }
 
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+js-sys = "0.3.56"
+wasm-bindgen = "0.2.79"
+wasm-bindgen-futures = "0.4.29"
+
+[target.'cfg(target_arch = "wasm32")'.dependencies.web-sys]
+version = "0.3.4"
+features = [
+  'Bluetooth',
+  'BluetoothCharacteristicProperties',
+  'BluetoothDevice',
+  'BluetoothLeScanFilterInit',
+  'BluetoothRemoteGattCharacteristic',
+  'BluetoothRemoteGattServer',
+  'BluetoothRemoteGattService',
+  'Event',
+  'Navigator',
+  'RequestDeviceOptions',
+  'Window',
+]
+
 [dev-dependencies]
 rand = "0.8.4"
 pretty_env_logger = "0.4.0"
 tokio = { version = "1.15.0", features = ["macros", "rt", "rt-multi-thread"] }
 serde_json = "1.0.74"
-

src/lib.rs

@@ -105,6 +105,8 @@ mod corebluetooth;
 pub mod platform;
 #[cfg(feature = "serde")]
 pub mod serde;
+#[cfg(target_arch = "wasm32")]
+mod wasm;
 #[cfg(target_os = "windows")]
 mod winrtble;
 
@@ -132,6 +134,9 @@ pub enum Error {
     #[error("Invalid Bluetooth address: {0}")]
     InvalidBDAddr(#[from] ParseBDAddrError),
 
+    #[error("JavaScript {:?}", _0)]
+    JavaScript(String),
+
     #[error("{}", _0)]
     Other(Box<dyn std::error::Error + Send + Sync>),
 }

src/platform.rs

@@ -9,6 +9,10 @@ pub use crate::bluez::{
 pub use crate::corebluetooth::{
     adapter::Adapter, manager::Manager, peripheral::Peripheral, peripheral::PeripheralId,
 };
+#[cfg(target_arch = "wasm32")]
+pub use crate::wasm::{
+    adapter::Adapter, manager::Manager, peripheral::Peripheral, peripheral::PeripheralId,
+};
 #[cfg(target_os = "windows")]
 pub use crate::winrtble::{
     adapter::Adapter, manager::Manager, peripheral::Peripheral, peripheral::PeripheralId,

src/wasm/adapter.rs

@@ -0,0 +1,125 @@
+use super::peripheral::{Peripheral, PeripheralId};
+use super::utils::wrap_promise;
+use crate::api::{BDAddr, Central, CentralEvent, Peripheral as _, ScanFilter};
+use crate::common::adapter_manager::AdapterManager;
+use crate::{Error, Result};
+use async_trait::async_trait;
+use futures::channel::oneshot;
+use futures::stream::Stream;
+use js_sys::Array;
+use std::pin::Pin;
+use std::sync::Arc;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_futures::spawn_local;
+use web_sys::{BluetoothDevice, BluetoothLeScanFilterInit, RequestDeviceOptions};
+
+/// Implementation of [api::Central](crate::api::Central).
+#[derive(Clone, Debug)]
+pub struct Adapter {
+    manager: Arc<AdapterManager<Peripheral>>,
+}
+
+fn bluetooth() -> Option<web_sys::Bluetooth> {
+    web_sys::window().unwrap().navigator().bluetooth()
+}
+
+trait AddPeripheralAndEmit {
+    fn add_peripheral_and_emit(&self, device: JsValue);
+}
+
+impl AddPeripheralAndEmit for Arc<AdapterManager<Peripheral>> {
+    fn add_peripheral_and_emit(&self, device: JsValue) {
+        let p = Peripheral::new(Arc::downgrade(self), BluetoothDevice::from(device));
+        let id = p.id();
+        if self.peripheral(&id).is_none() {
+            self.add_peripheral(p);
+            self.emit(CentralEvent::DeviceDiscovered(id.into()));
+        }
+    }
+}
+
+impl Adapter {
+    pub(crate) fn try_new() -> Option<Self> {
+        if let Some(_) = bluetooth() {
+            Some(Self {
+                manager: Arc::new(AdapterManager::default()),
+            })
+        } else {
+            None
+        }
+    }
+}
+
+#[async_trait]
+impl Central for Adapter {
+    type Peripheral = Peripheral;
+
+    async fn events(&self) -> Result<Pin<Box<dyn Stream<Item = CentralEvent> + Send>>> {
+        Ok(self.manager.event_stream())
+    }
+
+    async fn start_scan(&self, filter: ScanFilter) -> Result<()> {
+        let (sender, receiver) = oneshot::channel();
+        let manager = self.manager.clone();
+        spawn_local(async move {
+            // add already found devices
+            if manager.peripherals().is_empty() {
+                if let Ok(devices) = wrap_promise::<Array>(bluetooth().unwrap().get_devices()).await
+                {
+                    for device in devices.iter() {
+                        manager.add_peripheral_and_emit(device);
+                    }
+                }
+            }
+
+            let mut options = RequestDeviceOptions::new();
+            let optional_services = Array::new();
+            let filters = Array::new();
+
+            for uuid in filter.services.iter() {
+                let mut filter = BluetoothLeScanFilterInit::new();
+                let filter_services = Array::new();
+                filter_services.push(&uuid.to_string().into());
+                filter.services(&filter_services.into());
+                filters.push(&filter.into());
+                optional_services.push(&uuid.to_string().into());
+            }
+
+            options.filters(&filters.into());
+            options.optional_services(&optional_services.into());
+
+            let ret = wrap_promise(bluetooth().unwrap().request_device(&options))
+                .await
+                .map(|device| {
+                    manager.add_peripheral_and_emit(device);
+                    ()
+                });
+
+            let _ = sender.send(ret);
+        });
+
+        receiver.await.unwrap()
+    }
+
+    async fn stop_scan(&self) -> Result<()> {
+        Ok(())
+    }
+
+    async fn peripherals(&self) -> Result<Vec<Peripheral>> {
+        Ok(self.manager.peripherals())
+    }
+
+    async fn peripheral(&self, id: &PeripheralId) -> Result<Peripheral> {
+        self.manager.peripheral(id).ok_or(Error::DeviceNotFound)
+    }
+
+    async fn add_peripheral(&self, _address: BDAddr) -> Result<Peripheral> {
+        Err(Error::NotSupported(
+            "Can't add a Peripheral from a BDAddr".to_string(),
+        ))
+    }
+
+    async fn adapter_info(&self) -> Result<String> {
+        Ok("WebBluetooth".to_string())
+    }
+}

src/wasm/manager.rs

@@ -0,0 +1,26 @@
+use super::adapter::Adapter;
+use crate::{api, Result};
+use async_trait::async_trait;
+
+/// Implementation of [api::Manager](crate::api::Manager).
+#[derive(Clone, Debug)]
+pub struct Manager {}
+
+impl Manager {
+    pub async fn new() -> Result<Self> {
+        Ok(Self {})
+    }
+}
+
+#[async_trait]
+impl api::Manager for Manager {
+    type Adapter = Adapter;
+
+    async fn adapters(&self) -> Result<Vec<Adapter>> {
+        if let Some(adapter) = Adapter::try_new() {
+            Ok(vec![adapter])
+        } else {
+            Ok(vec![])
+        }
+    }
+}

src/wasm/mod.rs

@@ -0,0 +1,4 @@
+pub mod adapter;
+pub mod manager;
+pub mod peripheral;
+mod utils;