Struct BluetoothManager 

pub struct BluetoothManager {
    pub(crate) adapter: Option<BluetoothAdapter>,
    pub(crate) address_to_id: HashMap<String, String>,
    pub(crate) service_to_device: HashMap<String, String>,
    pub(crate) characteristic_to_service: HashMap<String, String>,
    pub(crate) descriptor_to_characteristic: HashMap<String, String>,
    pub(crate) cached_devices: HashMap<String, BluetoothDevice>,
    pub(crate) cached_services: HashMap<String, BluetoothGATTService>,
    pub(crate) cached_characteristics: HashMap<String, BluetoothGATTCharacteristic>,
    pub(crate) cached_descriptors: HashMap<String, BluetoothGATTDescriptor>,
    pub(crate) allowed_services: HashMap<String, HashSet<String>>,
    pub(crate) embedder_proxy: EmbedderProxy,
}

Fields

adapter: Option<BluetoothAdapter>

address_to_id: HashMap<String, String>

service_to_device: HashMap<String, String>

characteristic_to_service: HashMap<String, String>

descriptor_to_characteristic: HashMap<String, String>

cached_devices: HashMap<String, BluetoothDevice>

cached_services: HashMap<String, BluetoothGATTService>

cached_characteristics: HashMap<String, BluetoothGATTCharacteristic>

cached_descriptors: HashMap<String, BluetoothGATTDescriptor>

allowed_services: HashMap<String, HashSet<String>>

embedder_proxy: EmbedderProxy

Implementations

impl BluetoothManager

pub fn new( adapter: Option<BluetoothAdapter>, embedder_proxy: EmbedderProxy, ) -> BluetoothManager

pub(crate) fn start_sync(&mut self, receiver: GenericReceiver<BluetoothRequest>)

Synchronous message loop.

pub(crate) async fn handle_message(&mut self, msg: BluetoothRequest) -> bool

Handle a single message. Returns true if the event loop should exit.

pub(crate) async fn test( &mut self, data_set_name: String, ) -> BluetoothResult<()>

pub(crate) fn remove_ids_from_caches( &mut self, service_ids: Vec<String>, characteristic_ids: Vec<String>, descriptor_ids: Vec<String>, )

pub async fn get_or_create_adapter(&mut self) -> Option<BluetoothAdapter>

pub(crate) async fn get_adapter(&mut self) -> BluetoothResult<BluetoothAdapter>

pub(crate) async fn get_and_cache_devices( &mut self, adapter: &mut BluetoothAdapter, ) -> Vec<BluetoothDevice>

pub(crate) async fn get_device( &mut self, adapter: &mut BluetoothAdapter, device_id: &str, ) -> Option<&BluetoothDevice>

pub(crate) async fn select_device( &mut self, webview_id: WebViewId, devices: Vec<BluetoothDevice>, adapter: &BluetoothAdapter, ) -> Option<String>

pub(crate) fn generate_device_id(&mut self) -> String

pub(crate) fn device_from_service_id( &self, service_id: &str, ) -> Option<BluetoothDevice>

pub(crate) fn device_is_cached(&self, device_id: &str) -> bool

pub(crate) async fn device_matches_filter( &mut self, device_id: &str, filters: &BluetoothScanfilterSequence, ) -> BluetoothResult<bool>

pub(crate) async fn get_and_cache_gatt_services( &mut self, adapter: &mut BluetoothAdapter, device_id: &str, ) -> Vec<BluetoothGATTService>

pub(crate) async fn get_gatt_service( &mut self, adapter: &mut BluetoothAdapter, service_id: &str, ) -> Option<&BluetoothGATTService>

pub(crate) fn service_is_cached(&self, service_id: &str) -> bool

pub(crate) async fn get_and_cache_gatt_characteristics( &mut self, adapter: &mut BluetoothAdapter, service_id: &str, ) -> Vec<BluetoothGATTCharacteristic>

pub(crate) async fn get_gatt_characteristic( &mut self, adapter: &mut BluetoothAdapter, characteristic_id: &str, ) -> Option<&BluetoothGATTCharacteristic>

pub(crate) fn get_characteristic_properties( &self, characteristic: &BluetoothGATTCharacteristic, ) -> Flags

pub(crate) fn characteristic_is_cached(&self, characteristic_id: &str) -> bool

pub(crate) async fn get_and_cache_gatt_descriptors( &mut self, adapter: &mut BluetoothAdapter, characteristic_id: &str, ) -> Vec<BluetoothGATTDescriptor>

pub(crate) async fn get_gatt_descriptor( &mut self, adapter: &mut BluetoothAdapter, descriptor_id: &str, ) -> Option<&BluetoothGATTDescriptor>

pub(crate) async fn request_device( &mut self, options: RequestDeviceoptions, ) -> BluetoothResponseResult

https://webbluetoothcg.github.io/web-bluetooth/#request-bluetooth-devices

pub(crate) async fn gatt_server_connect( &mut self, device_id: String, ) -> BluetoothResponseResult

https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothremotegattserver-connect

pub(crate) async fn gatt_server_disconnect( &mut self, device_id: String, ) -> BluetoothResult<()>

https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothremotegattserver-disconnect

pub(crate) async fn get_gatt_children( &mut self, id: String, uuid: Option<String>, single: bool, child_type: GATTType, ) -> BluetoothResponseResult

https://webbluetoothcg.github.io/web-bluetooth/#getgattchildren

pub(crate) async fn read_value(&mut self, id: String) -> BluetoothResponseResult

https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothremotegattcharacteristic-readvalue https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothremotegattdescriptor-readvalue

pub(crate) async fn write_value( &mut self, id: String, value: Vec<u8>, ) -> BluetoothResponseResult

https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothremotegattcharacteristic-writevalue https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothremotegattdescriptor-writevalue

pub(crate) async fn enable_notification( &mut self, id: String, enable: bool, ) -> BluetoothResponseResult

https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothremotegattcharacteristic-startnotifications https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothremotegattcharacteristic-stopnotifications

pub(crate) fn watch_advertisements( &mut self, _device_id: String, ) -> BluetoothResponseResult

https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothdevice-watchadvertisements

pub(crate) async fn get_availability(&mut self) -> BluetoothResponseResult

https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetooth-getavailability