2016-05-04 18:06:06 +03:00
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
|
2016-11-03 23:04:43 +03:00
|
|
|
#[macro_use]
|
|
|
|
extern crate bitflags;
|
|
|
|
extern crate bluetooth_traits;
|
|
|
|
extern crate device;
|
|
|
|
extern crate ipc_channel;
|
|
|
|
extern crate rand;
|
|
|
|
#[cfg(target_os = "linux")]
|
|
|
|
extern crate tinyfiledialogs;
|
|
|
|
extern crate util;
|
2016-11-04 15:44:42 +03:00
|
|
|
extern crate uuid;
|
|
|
|
|
|
|
|
pub mod test;
|
2016-11-03 23:04:43 +03:00
|
|
|
|
2016-11-08 18:05:12 +03:00
|
|
|
use bluetooth_traits::{BluetoothCharacteristicMsg, BluetoothDescriptorMsg, BluetoothServiceMsg};
|
|
|
|
use bluetooth_traits::{BluetoothDeviceMsg, BluetoothRequest, BluetoothResponse};
|
|
|
|
use bluetooth_traits::{BluetoothError, BluetoothResponseResult, BluetoothResult};
|
2016-11-22 14:55:02 +03:00
|
|
|
use bluetooth_traits::blocklist::{uuid_is_blocklisted, Blocklist};
|
2016-11-03 23:04:43 +03:00
|
|
|
use bluetooth_traits::scanfilter::{BluetoothScanfilter, BluetoothScanfilterSequence, RequestDeviceoptions};
|
2016-11-04 15:44:42 +03:00
|
|
|
use device::bluetooth::{BluetoothAdapter, BluetoothDevice, BluetoothGATTCharacteristic};
|
|
|
|
use device::bluetooth::{BluetoothGATTDescriptor, BluetoothGATTService};
|
2016-05-04 18:06:06 +03:00
|
|
|
use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
|
2016-11-03 23:04:43 +03:00
|
|
|
use rand::Rng;
|
2016-05-04 18:06:06 +03:00
|
|
|
use std::borrow::ToOwned;
|
2016-06-05 16:00:50 +03:00
|
|
|
use std::collections::{HashMap, HashSet};
|
2016-05-04 18:06:06 +03:00
|
|
|
use std::string::String;
|
2016-05-26 21:15:49 +03:00
|
|
|
use std::thread;
|
|
|
|
use std::time::Duration;
|
2016-05-04 18:06:06 +03:00
|
|
|
use util::thread::spawn_named;
|
|
|
|
|
2016-07-05 19:02:25 +03:00
|
|
|
// A transaction not completed within 30 seconds shall time out. Such a transaction shall be considered to have failed.
|
|
|
|
// https://www.bluetooth.org/DocMan/handlers/DownloadDoc.ashx?doc_id=286439 (Vol. 3, page 480)
|
|
|
|
const MAXIMUM_TRANSACTION_TIME: u8 = 30;
|
|
|
|
const CONNECTION_TIMEOUT_MS: u64 = 1000;
|
2016-05-26 21:15:49 +03:00
|
|
|
// The discovery session needs some time to find any nearby devices
|
|
|
|
const DISCOVERY_TIMEOUT_MS: u64 = 1500;
|
|
|
|
#[cfg(target_os = "linux")]
|
|
|
|
const DIALOG_TITLE: &'static str = "Choose a device";
|
|
|
|
#[cfg(target_os = "linux")]
|
|
|
|
const DIALOG_COLUMN_ID: &'static str = "Id";
|
|
|
|
#[cfg(target_os = "linux")]
|
|
|
|
const DIALOG_COLUMN_NAME: &'static str = "Name";
|
2016-05-04 18:06:06 +03:00
|
|
|
|
|
|
|
bitflags! {
|
|
|
|
flags Flags: u32 {
|
|
|
|
const BROADCAST = 0b000000001,
|
|
|
|
const READ = 0b000000010,
|
|
|
|
const WRITE_WITHOUT_RESPONSE = 0b000000100,
|
|
|
|
const WRITE = 0b000001000,
|
|
|
|
const NOTIFY = 0b000010000,
|
|
|
|
const INDICATE = 0b000100000,
|
|
|
|
const AUTHENTICATED_SIGNED_WRITES = 0b001000000,
|
|
|
|
const RELIABLE_WRITE = 0b010000000,
|
|
|
|
const WRITABLE_AUXILIARIES = 0b100000000,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
macro_rules! return_if_cached(
|
|
|
|
($cache:expr, $key:expr) => (
|
|
|
|
if $cache.contains_key($key) {
|
|
|
|
return $cache.get($key);
|
|
|
|
}
|
|
|
|
);
|
|
|
|
);
|
|
|
|
|
2016-05-30 22:39:34 +03:00
|
|
|
macro_rules! get_adapter_or_return_error(
|
|
|
|
($bl_manager:expr, $sender:expr) => (
|
|
|
|
match $bl_manager.get_or_create_adapter() {
|
2016-11-04 15:44:42 +03:00
|
|
|
Some(adapter) => {
|
|
|
|
if !adapter.is_powered().unwrap_or(false) {
|
2016-11-07 18:50:13 +03:00
|
|
|
return drop($sender.send(Err(BluetoothError::NotFound)))
|
2016-11-04 15:44:42 +03:00
|
|
|
}
|
|
|
|
adapter
|
|
|
|
},
|
2016-11-07 18:50:13 +03:00
|
|
|
None => return drop($sender.send(Err(BluetoothError::NotFound))),
|
2016-05-30 22:39:34 +03:00
|
|
|
}
|
|
|
|
);
|
|
|
|
);
|
|
|
|
|
2016-05-04 18:06:06 +03:00
|
|
|
pub trait BluetoothThreadFactory {
|
|
|
|
fn new() -> Self;
|
|
|
|
}
|
|
|
|
|
2016-11-08 18:05:12 +03:00
|
|
|
impl BluetoothThreadFactory for IpcSender<BluetoothRequest> {
|
|
|
|
fn new() -> IpcSender<BluetoothRequest> {
|
2016-05-04 18:06:06 +03:00
|
|
|
let (sender, receiver) = ipc::channel().unwrap();
|
|
|
|
let adapter = BluetoothAdapter::init().ok();
|
|
|
|
spawn_named("BluetoothThread".to_owned(), move || {
|
|
|
|
BluetoothManager::new(receiver, adapter).start();
|
|
|
|
});
|
|
|
|
sender
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-16 01:29:44 +03:00
|
|
|
// https://webbluetoothcg.github.io/web-bluetooth/#matches-a-filter
|
2016-05-04 18:06:06 +03:00
|
|
|
fn matches_filter(device: &BluetoothDevice, filter: &BluetoothScanfilter) -> bool {
|
|
|
|
if filter.is_empty_or_invalid() {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-09-16 01:29:44 +03:00
|
|
|
// Step 1.
|
2016-11-07 18:50:13 +03:00
|
|
|
if let Some(name) = filter.get_name() {
|
|
|
|
if device.get_name().ok() != Some(name.to_string()) {
|
2016-05-04 18:06:06 +03:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-16 01:29:44 +03:00
|
|
|
// Step 2.
|
2016-05-04 18:06:06 +03:00
|
|
|
if !filter.get_name_prefix().is_empty() {
|
|
|
|
if let Ok(device_name) = device.get_name() {
|
|
|
|
if !device_name.starts_with(filter.get_name_prefix()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-16 01:29:44 +03:00
|
|
|
// Step 3.
|
2016-05-04 18:06:06 +03:00
|
|
|
if !filter.get_services().is_empty() {
|
|
|
|
if let Ok(device_uuids) = device.get_uuids() {
|
|
|
|
for service in filter.get_services() {
|
|
|
|
if device_uuids.iter().find(|x| x == &service).is_none() {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-09-16 01:29:44 +03:00
|
|
|
|
|
|
|
// Step 4.
|
|
|
|
// TODO: Implement get_manufacturer_data in device crate.
|
|
|
|
// if let Some(manufacturer_id) = filter.get_manufacturer_id() {
|
|
|
|
// if !device.get_manufacturer_data().contains_key(manufacturer_id) {
|
|
|
|
// return false;
|
|
|
|
// }
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// Step 5.
|
|
|
|
// TODO: Implement get_device_data in device crate.
|
|
|
|
// if !filter.get_service_data_uuid().is_empty() {
|
|
|
|
// if !device.get_service_data().contains_key(filter.get_service_data_uuid()) {
|
|
|
|
// return false;
|
|
|
|
// }
|
|
|
|
// }
|
|
|
|
|
|
|
|
// Step 6.
|
|
|
|
true
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
fn matches_filters(device: &BluetoothDevice, filters: &BluetoothScanfilterSequence) -> bool {
|
|
|
|
if filters.has_empty_or_invalid_filter() {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return filters.iter().any(|f| matches_filter(device, f))
|
|
|
|
}
|
|
|
|
|
2016-11-04 15:44:42 +03:00
|
|
|
fn is_mock_adapter(adapter: &BluetoothAdapter) -> bool {
|
|
|
|
match adapter {
|
|
|
|
&BluetoothAdapter::Mock(_) => true,
|
|
|
|
_ => false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-04 18:06:06 +03:00
|
|
|
pub struct BluetoothManager {
|
2016-11-08 18:05:12 +03:00
|
|
|
receiver: IpcReceiver<BluetoothRequest>,
|
2016-05-04 18:06:06 +03:00
|
|
|
adapter: Option<BluetoothAdapter>,
|
2016-06-02 21:28:34 +03:00
|
|
|
address_to_id: HashMap<String, String>,
|
2016-05-04 18:06:06 +03:00
|
|
|
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>,
|
2016-06-05 16:00:50 +03:00
|
|
|
allowed_services: HashMap<String, HashSet<String>>,
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
impl BluetoothManager {
|
2016-11-08 18:05:12 +03:00
|
|
|
pub fn new(receiver: IpcReceiver<BluetoothRequest>, adapter: Option<BluetoothAdapter>) -> BluetoothManager {
|
2016-05-04 18:06:06 +03:00
|
|
|
BluetoothManager {
|
|
|
|
receiver: receiver,
|
|
|
|
adapter: adapter,
|
2016-06-02 21:28:34 +03:00
|
|
|
address_to_id: HashMap::new(),
|
2016-05-04 18:06:06 +03:00
|
|
|
service_to_device: HashMap::new(),
|
|
|
|
characteristic_to_service: HashMap::new(),
|
|
|
|
descriptor_to_characteristic: HashMap::new(),
|
|
|
|
cached_devices: HashMap::new(),
|
|
|
|
cached_services: HashMap::new(),
|
|
|
|
cached_characteristics: HashMap::new(),
|
|
|
|
cached_descriptors: HashMap::new(),
|
2016-06-05 16:00:50 +03:00
|
|
|
allowed_services: HashMap::new(),
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn start(&mut self) {
|
|
|
|
while let Ok(msg) = self.receiver.recv() {
|
|
|
|
match msg {
|
2016-11-08 18:05:12 +03:00
|
|
|
BluetoothRequest::RequestDevice(options, sender) => {
|
2016-05-04 18:06:06 +03:00
|
|
|
self.request_device(options, sender)
|
|
|
|
},
|
2016-11-08 18:05:12 +03:00
|
|
|
BluetoothRequest::GATTServerConnect(device_id, sender) => {
|
2016-05-04 18:06:06 +03:00
|
|
|
self.gatt_server_connect(device_id, sender)
|
|
|
|
},
|
2016-11-08 18:05:12 +03:00
|
|
|
BluetoothRequest::GATTServerDisconnect(device_id, sender) => {
|
2016-05-04 18:06:06 +03:00
|
|
|
self.gatt_server_disconnect(device_id, sender)
|
|
|
|
},
|
2016-11-08 18:05:12 +03:00
|
|
|
BluetoothRequest::GetPrimaryService(device_id, uuid, sender) => {
|
2016-05-04 18:06:06 +03:00
|
|
|
self.get_primary_service(device_id, uuid, sender)
|
|
|
|
},
|
2016-11-08 18:05:12 +03:00
|
|
|
BluetoothRequest::GetPrimaryServices(device_id, uuid, sender) => {
|
2016-05-04 18:06:06 +03:00
|
|
|
self.get_primary_services(device_id, uuid, sender)
|
|
|
|
},
|
2016-11-08 18:05:12 +03:00
|
|
|
BluetoothRequest::GetIncludedService(service_id, uuid, sender) => {
|
2016-05-26 22:04:33 +03:00
|
|
|
self.get_included_service(service_id, uuid, sender)
|
|
|
|
},
|
2016-11-08 18:05:12 +03:00
|
|
|
BluetoothRequest::GetIncludedServices(service_id, uuid, sender) => {
|
2016-05-26 22:04:33 +03:00
|
|
|
self.get_included_services(service_id, uuid, sender)
|
|
|
|
},
|
2016-11-08 18:05:12 +03:00
|
|
|
BluetoothRequest::GetCharacteristic(service_id, uuid, sender) => {
|
2016-05-04 18:06:06 +03:00
|
|
|
self.get_characteristic(service_id, uuid, sender)
|
|
|
|
},
|
2016-11-08 18:05:12 +03:00
|
|
|
BluetoothRequest::GetCharacteristics(service_id, uuid, sender) => {
|
2016-05-04 18:06:06 +03:00
|
|
|
self.get_characteristics(service_id, uuid, sender)
|
|
|
|
},
|
2016-11-08 18:05:12 +03:00
|
|
|
BluetoothRequest::GetDescriptor(characteristic_id, uuid, sender) => {
|
2016-05-04 18:06:06 +03:00
|
|
|
self.get_descriptor(characteristic_id, uuid, sender)
|
|
|
|
},
|
2016-11-08 18:05:12 +03:00
|
|
|
BluetoothRequest::GetDescriptors(characteristic_id, uuid, sender) => {
|
2016-05-04 18:06:06 +03:00
|
|
|
self.get_descriptors(characteristic_id, uuid, sender)
|
|
|
|
},
|
2016-11-08 18:05:12 +03:00
|
|
|
BluetoothRequest::ReadValue(id, sender) => {
|
2016-05-04 18:06:06 +03:00
|
|
|
self.read_value(id, sender)
|
|
|
|
},
|
2016-11-08 18:05:12 +03:00
|
|
|
BluetoothRequest::WriteValue(id, value, sender) => {
|
2016-05-04 18:06:06 +03:00
|
|
|
self.write_value(id, value, sender)
|
|
|
|
},
|
2016-11-08 18:05:12 +03:00
|
|
|
BluetoothRequest::Test(data_set_name, sender) => {
|
2016-11-04 15:44:42 +03:00
|
|
|
self.test(data_set_name, sender)
|
|
|
|
}
|
2016-11-08 18:05:12 +03:00
|
|
|
BluetoothRequest::Exit => {
|
2016-05-04 18:06:06 +03:00
|
|
|
break
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-04 15:44:42 +03:00
|
|
|
// Test
|
|
|
|
|
|
|
|
fn test(&mut self, data_set_name: String, sender: IpcSender<BluetoothResult<()>>) {
|
|
|
|
self.address_to_id.clear();
|
|
|
|
self.service_to_device.clear();
|
|
|
|
self.characteristic_to_service.clear();
|
|
|
|
self.descriptor_to_characteristic.clear();
|
|
|
|
self.cached_devices.clear();
|
|
|
|
self.cached_services.clear();
|
|
|
|
self.cached_characteristics.clear();
|
|
|
|
self.cached_descriptors.clear();
|
|
|
|
self.allowed_services.clear();
|
|
|
|
self.adapter = BluetoothAdapter::init_mock().ok();
|
|
|
|
match test::test(self, data_set_name) {
|
|
|
|
Ok(_) => {
|
|
|
|
let _ = sender.send(Ok(()));
|
|
|
|
},
|
|
|
|
Err(error) => {
|
|
|
|
let _ = sender.send(Err(BluetoothError::Type(error.description().to_owned())));
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-04 18:06:06 +03:00
|
|
|
// Adapter
|
|
|
|
|
2016-11-04 15:44:42 +03:00
|
|
|
pub fn get_or_create_adapter(&mut self) -> Option<BluetoothAdapter> {
|
2016-05-04 18:06:06 +03:00
|
|
|
let adapter_valid = self.adapter.as_ref().map_or(false, |a| a.get_address().is_ok());
|
|
|
|
if !adapter_valid {
|
|
|
|
self.adapter = BluetoothAdapter::init().ok();
|
|
|
|
}
|
2016-11-04 15:44:42 +03:00
|
|
|
|
|
|
|
let adapter = match self.adapter.as_ref() {
|
|
|
|
Some(adapter) => adapter,
|
|
|
|
None => return None,
|
|
|
|
};
|
|
|
|
|
|
|
|
if is_mock_adapter(adapter) && !adapter.is_present().unwrap_or(false) {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
2016-05-04 18:06:06 +03:00
|
|
|
self.adapter.clone()
|
|
|
|
}
|
|
|
|
|
|
|
|
// Device
|
|
|
|
|
|
|
|
fn get_and_cache_devices(&mut self, adapter: &mut BluetoothAdapter) -> Vec<BluetoothDevice> {
|
|
|
|
let devices = adapter.get_devices().unwrap_or(vec!());
|
|
|
|
for device in &devices {
|
|
|
|
if let Ok(address) = device.get_address() {
|
2016-06-02 21:28:34 +03:00
|
|
|
if !self.address_to_id.contains_key(&address) {
|
|
|
|
let generated_id = self.generate_device_id();
|
|
|
|
self.address_to_id.insert(address, generated_id.clone());
|
2016-06-05 16:00:50 +03:00
|
|
|
self.cached_devices.insert(generated_id.clone(), device.clone());
|
|
|
|
self.allowed_services.insert(generated_id, HashSet::new());
|
2016-06-02 21:28:34 +03:00
|
|
|
}
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
self.cached_devices.iter().map(|(_, d)| d.clone()).collect()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_device(&mut self, adapter: &mut BluetoothAdapter, device_id: &str) -> Option<&BluetoothDevice> {
|
|
|
|
return_if_cached!(self.cached_devices, device_id);
|
|
|
|
self.get_and_cache_devices(adapter);
|
|
|
|
return_if_cached!(self.cached_devices, device_id);
|
|
|
|
None
|
|
|
|
}
|
|
|
|
|
2016-05-26 21:15:49 +03:00
|
|
|
#[cfg(target_os = "linux")]
|
2016-11-04 15:44:42 +03:00
|
|
|
fn select_device(&mut self, devices: Vec<BluetoothDevice>, adapter: &BluetoothAdapter) -> Option<String> {
|
|
|
|
if is_mock_adapter(adapter) {
|
|
|
|
for device in devices {
|
|
|
|
if let Ok(address) = device.get_address() {
|
|
|
|
return Some(address);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
2016-05-26 21:15:49 +03:00
|
|
|
let mut dialog_rows: Vec<String> = vec!();
|
|
|
|
for device in devices {
|
|
|
|
dialog_rows.extend_from_slice(&[device.get_address().unwrap_or("".to_string()),
|
|
|
|
device.get_name().unwrap_or("".to_string())]);
|
|
|
|
}
|
|
|
|
let dialog_rows: Vec<&str> = dialog_rows.iter()
|
|
|
|
.map(|s| s.as_ref())
|
|
|
|
.collect();
|
|
|
|
let dialog_rows: &[&str] = dialog_rows.as_slice();
|
|
|
|
|
|
|
|
if let Some(device) = tinyfiledialogs::list_dialog(DIALOG_TITLE,
|
|
|
|
&[DIALOG_COLUMN_ID, DIALOG_COLUMN_NAME],
|
|
|
|
Some(dialog_rows)) {
|
|
|
|
// The device string format will be "Address|Name". We need the first part of it.
|
|
|
|
return device.split("|").next().map(|s| s.to_string());
|
|
|
|
}
|
|
|
|
None
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(not(target_os = "linux"))]
|
2016-11-04 15:44:42 +03:00
|
|
|
fn select_device(&mut self, devices: Vec<BluetoothDevice>, _adapter: &BluetoothAdapter) -> Option<String> {
|
2016-05-26 21:15:49 +03:00
|
|
|
for device in devices {
|
|
|
|
if let Ok(address) = device.get_address() {
|
|
|
|
return Some(address);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
None
|
|
|
|
}
|
|
|
|
|
2016-06-02 21:28:34 +03:00
|
|
|
fn generate_device_id(&mut self) -> String {
|
|
|
|
let mut device_id;
|
|
|
|
let mut rng = rand::thread_rng();
|
|
|
|
loop {
|
|
|
|
device_id = rng.gen::<u32>().to_string();
|
|
|
|
if !self.cached_devices.contains_key(&device_id) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
device_id
|
|
|
|
}
|
|
|
|
|
2016-11-04 15:44:42 +03:00
|
|
|
fn device_from_service_id(&self, service_id: &str) -> Option<BluetoothDevice> {
|
|
|
|
let device_id = match self.service_to_device.get(service_id) {
|
|
|
|
Some(id) => id,
|
|
|
|
None => return None,
|
|
|
|
};
|
|
|
|
match self.cached_devices.get(device_id) {
|
|
|
|
Some(d) => Some(d.clone()),
|
|
|
|
None => None,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-04 18:06:06 +03:00
|
|
|
// Service
|
|
|
|
|
|
|
|
fn get_and_cache_gatt_services(&mut self,
|
|
|
|
adapter: &mut BluetoothAdapter,
|
|
|
|
device_id: &str)
|
|
|
|
-> Vec<BluetoothGATTService> {
|
|
|
|
let services = match self.get_device(adapter, device_id) {
|
|
|
|
Some(d) => d.get_gatt_services().unwrap_or(vec!()),
|
|
|
|
None => vec!(),
|
|
|
|
};
|
|
|
|
for service in &services {
|
2016-09-06 18:44:41 +03:00
|
|
|
self.cached_services.insert(service.get_id(), service.clone());
|
|
|
|
self.service_to_device.insert(service.get_id(), device_id.to_owned());
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
services
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_gatt_service(&mut self, adapter: &mut BluetoothAdapter, service_id: &str) -> Option<&BluetoothGATTService> {
|
|
|
|
return_if_cached!(self.cached_services, service_id);
|
|
|
|
let device_id = match self.service_to_device.get(service_id) {
|
|
|
|
Some(d) => d.clone(),
|
|
|
|
None => return None,
|
|
|
|
};
|
|
|
|
self.get_and_cache_gatt_services(adapter, &device_id);
|
|
|
|
return_if_cached!(self.cached_services, service_id);
|
|
|
|
None
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_gatt_services_by_uuid(&mut self,
|
|
|
|
adapter: &mut BluetoothAdapter,
|
|
|
|
device_id: &str,
|
|
|
|
service_uuid: &str)
|
|
|
|
-> Vec<BluetoothGATTService> {
|
|
|
|
let services = self.get_and_cache_gatt_services(adapter, device_id);
|
|
|
|
services.into_iter().filter(|s| s.get_uuid().ok() == Some(service_uuid.to_string())).collect()
|
|
|
|
}
|
|
|
|
|
|
|
|
// Characteristic
|
|
|
|
|
|
|
|
fn get_and_cache_gatt_characteristics(&mut self,
|
|
|
|
adapter: &mut BluetoothAdapter,
|
|
|
|
service_id: &str)
|
|
|
|
-> Vec<BluetoothGATTCharacteristic> {
|
|
|
|
let characteristics = match self.get_gatt_service(adapter, service_id) {
|
|
|
|
Some(s) => s.get_gatt_characteristics().unwrap_or(vec!()),
|
|
|
|
None => vec!(),
|
|
|
|
};
|
|
|
|
|
|
|
|
for characteristic in &characteristics {
|
2016-09-06 18:44:41 +03:00
|
|
|
self.cached_characteristics.insert(characteristic.get_id(), characteristic.clone());
|
|
|
|
self.characteristic_to_service.insert(characteristic.get_id(), service_id.to_owned());
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
characteristics
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_gatt_characteristic(&mut self,
|
|
|
|
adapter: &mut BluetoothAdapter,
|
|
|
|
characteristic_id: &str)
|
|
|
|
-> Option<&BluetoothGATTCharacteristic> {
|
|
|
|
return_if_cached!(self.cached_characteristics, characteristic_id);
|
|
|
|
let service_id = match self.characteristic_to_service.get(characteristic_id) {
|
|
|
|
Some(s) => s.clone(),
|
|
|
|
None => return None,
|
|
|
|
};
|
|
|
|
self.get_and_cache_gatt_characteristics(adapter, &service_id);
|
|
|
|
return_if_cached!(self.cached_characteristics, characteristic_id);
|
|
|
|
None
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_gatt_characteristics_by_uuid(&mut self,
|
|
|
|
adapter: &mut BluetoothAdapter,
|
|
|
|
service_id: &str,
|
|
|
|
characteristic_uuid: &str)
|
|
|
|
-> Vec<BluetoothGATTCharacteristic> {
|
|
|
|
let characteristics = self.get_and_cache_gatt_characteristics(adapter, service_id);
|
|
|
|
characteristics.into_iter()
|
|
|
|
.filter(|c| c.get_uuid().ok() == Some(characteristic_uuid.to_string()))
|
|
|
|
.collect()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_characteristic_properties(&self, characteristic: &BluetoothGATTCharacteristic) -> Flags {
|
|
|
|
let mut props: Flags = Flags::empty();
|
|
|
|
let flags = characteristic.get_flags().unwrap_or(vec!());
|
|
|
|
for flag in flags {
|
|
|
|
match flag.as_ref() {
|
|
|
|
"broadcast" => props.insert(BROADCAST),
|
|
|
|
"read" => props.insert(READ),
|
2016-11-14 22:50:51 +03:00
|
|
|
"write-without-response" => props.insert(WRITE_WITHOUT_RESPONSE),
|
2016-05-04 18:06:06 +03:00
|
|
|
"write" => props.insert(WRITE),
|
|
|
|
"notify" => props.insert(NOTIFY),
|
|
|
|
"indicate" => props.insert(INDICATE),
|
2016-11-14 22:50:51 +03:00
|
|
|
"authenticated-signed-writes" => props.insert(AUTHENTICATED_SIGNED_WRITES),
|
|
|
|
"reliable-write" => props.insert(RELIABLE_WRITE),
|
|
|
|
"writable-auxiliaries" => props.insert(WRITABLE_AUXILIARIES),
|
2016-05-04 18:06:06 +03:00
|
|
|
_ => (),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
props
|
|
|
|
}
|
|
|
|
|
|
|
|
// Descriptor
|
|
|
|
|
|
|
|
fn get_and_cache_gatt_descriptors(&mut self,
|
|
|
|
adapter: &mut BluetoothAdapter,
|
|
|
|
characteristic_id: &str)
|
|
|
|
-> Vec<BluetoothGATTDescriptor> {
|
|
|
|
let descriptors = match self.get_gatt_characteristic(adapter, characteristic_id) {
|
|
|
|
Some(c) => c.get_gatt_descriptors().unwrap_or(vec!()),
|
|
|
|
None => vec!(),
|
|
|
|
};
|
|
|
|
|
|
|
|
for descriptor in &descriptors {
|
2016-09-06 18:44:41 +03:00
|
|
|
self.cached_descriptors.insert(descriptor.get_id(), descriptor.clone());
|
|
|
|
self.descriptor_to_characteristic.insert(descriptor.get_id(), characteristic_id.to_owned());
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
descriptors
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_gatt_descriptor(&mut self,
|
|
|
|
adapter: &mut BluetoothAdapter,
|
|
|
|
descriptor_id: &str)
|
|
|
|
-> Option<&BluetoothGATTDescriptor> {
|
|
|
|
return_if_cached!(self.cached_descriptors, descriptor_id);
|
|
|
|
let characteristic_id = match self.descriptor_to_characteristic.get(descriptor_id) {
|
|
|
|
Some(c) => c.clone(),
|
|
|
|
None => return None,
|
|
|
|
};
|
|
|
|
self.get_and_cache_gatt_descriptors(adapter, &characteristic_id);
|
|
|
|
return_if_cached!(self.cached_descriptors, descriptor_id);
|
|
|
|
None
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_gatt_descriptors_by_uuid(&mut self,
|
|
|
|
adapter: &mut BluetoothAdapter,
|
|
|
|
characteristic_id: &str,
|
|
|
|
descriptor_uuid: &str)
|
|
|
|
-> Vec<BluetoothGATTDescriptor> {
|
|
|
|
let descriptors = self.get_and_cache_gatt_descriptors(adapter, characteristic_id);
|
|
|
|
descriptors.into_iter()
|
|
|
|
.filter(|d| d.get_uuid().ok() == Some(descriptor_uuid.to_string()))
|
|
|
|
.collect()
|
|
|
|
}
|
|
|
|
|
|
|
|
// Methods
|
|
|
|
|
2016-09-16 01:29:44 +03:00
|
|
|
// https://webbluetoothcg.github.io/web-bluetooth/#request-bluetooth-devices
|
2016-05-04 18:06:06 +03:00
|
|
|
fn request_device(&mut self,
|
|
|
|
options: RequestDeviceoptions,
|
2016-11-08 18:05:12 +03:00
|
|
|
sender: IpcSender<BluetoothResponseResult>) {
|
2016-05-30 22:39:34 +03:00
|
|
|
let mut adapter = get_adapter_or_return_error!(self, sender);
|
2016-09-06 18:44:41 +03:00
|
|
|
if let Ok(ref session) = adapter.create_discovery_session() {
|
2016-05-26 21:15:49 +03:00
|
|
|
if session.start_discovery().is_ok() {
|
2016-11-04 15:44:42 +03:00
|
|
|
if !is_mock_adapter(&adapter) {
|
|
|
|
thread::sleep(Duration::from_millis(DISCOVERY_TIMEOUT_MS));
|
|
|
|
}
|
2016-05-26 21:15:49 +03:00
|
|
|
}
|
|
|
|
let _ = session.stop_discovery();
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
2016-09-16 01:29:44 +03:00
|
|
|
|
|
|
|
// Step 6.
|
|
|
|
// Note: There is no requiredServiceUUIDS, we scan for all devices.
|
|
|
|
let mut matched_devices = self.get_and_cache_devices(&mut adapter);
|
|
|
|
|
|
|
|
// Step 7.
|
|
|
|
if !options.is_accepting_all_devices() {
|
|
|
|
matched_devices = matched_devices.into_iter()
|
|
|
|
.filter(|d| matches_filters(d, options.get_filters()))
|
|
|
|
.collect();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Step 8.
|
2016-11-04 15:44:42 +03:00
|
|
|
if let Some(address) = self.select_device(matched_devices, &adapter) {
|
2016-06-02 21:28:34 +03:00
|
|
|
let device_id = match self.address_to_id.get(&address) {
|
|
|
|
Some(id) => id.clone(),
|
2016-07-28 11:33:08 +03:00
|
|
|
None => return drop(sender.send(Err(BluetoothError::NotFound))),
|
2016-06-02 21:28:34 +03:00
|
|
|
};
|
2016-06-05 16:00:50 +03:00
|
|
|
let mut services = options.get_services_set();
|
|
|
|
if let Some(services_set) = self.allowed_services.get(&device_id) {
|
|
|
|
services = services_set | &services;
|
|
|
|
}
|
|
|
|
self.allowed_services.insert(device_id.clone(), services);
|
2016-06-02 21:28:34 +03:00
|
|
|
if let Some(device) = self.get_device(&mut adapter, &device_id) {
|
2016-11-08 18:05:12 +03:00
|
|
|
let message = BluetoothDeviceMsg {
|
|
|
|
id: device_id,
|
|
|
|
name: device.get_name().ok(),
|
|
|
|
appearance: device.get_appearance().ok(),
|
|
|
|
tx_power: device.get_tx_power().ok().map(|p| p as i8),
|
|
|
|
rssi: device.get_rssi().ok().map(|p| p as i8),
|
|
|
|
};
|
|
|
|
return drop(sender.send(Ok(BluetoothResponse::RequestDevice(message))));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
}
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::NotFound)));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
|
2016-11-08 18:05:12 +03:00
|
|
|
fn gatt_server_connect(&mut self, device_id: String, sender: IpcSender<BluetoothResponseResult>) {
|
2016-05-30 22:39:34 +03:00
|
|
|
let mut adapter = get_adapter_or_return_error!(self, sender);
|
2016-07-05 19:02:25 +03:00
|
|
|
match self.get_device(&mut adapter, &device_id) {
|
2016-05-04 18:06:06 +03:00
|
|
|
Some(d) => {
|
|
|
|
if d.is_connected().unwrap_or(false) {
|
2016-11-08 18:05:12 +03:00
|
|
|
return drop(sender.send(Ok(BluetoothResponse::GATTServerConnect(true))));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
2016-07-05 19:02:25 +03:00
|
|
|
let _ = d.connect();
|
|
|
|
for _ in 0..MAXIMUM_TRANSACTION_TIME {
|
|
|
|
match d.is_connected().unwrap_or(false) {
|
2016-11-08 18:05:12 +03:00
|
|
|
true => return drop(sender.send(Ok(BluetoothResponse::GATTServerConnect(true)))),
|
2016-11-04 15:44:42 +03:00
|
|
|
false => {
|
|
|
|
if is_mock_adapter(&adapter) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
thread::sleep(Duration::from_millis(CONNECTION_TIMEOUT_MS));
|
|
|
|
},
|
2016-07-05 19:02:25 +03:00
|
|
|
}
|
|
|
|
}
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::Network)));
|
2016-05-04 18:06:06 +03:00
|
|
|
},
|
2016-07-28 11:33:08 +03:00
|
|
|
None => return drop(sender.send(Err(BluetoothError::NotFound))),
|
2016-07-05 19:02:25 +03:00
|
|
|
}
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
fn gatt_server_disconnect(&mut self, device_id: String, sender: IpcSender<BluetoothResult<bool>>) {
|
2016-05-30 22:39:34 +03:00
|
|
|
let mut adapter = get_adapter_or_return_error!(self, sender);
|
2016-05-04 18:06:06 +03:00
|
|
|
|
2016-07-05 19:02:25 +03:00
|
|
|
match self.get_device(&mut adapter, &device_id) {
|
2016-05-04 18:06:06 +03:00
|
|
|
Some(d) => {
|
2016-07-05 19:02:25 +03:00
|
|
|
if !d.is_connected().unwrap_or(true) {
|
|
|
|
return drop(sender.send(Ok(false)));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
2016-07-05 19:02:25 +03:00
|
|
|
let _ = d.disconnect();
|
|
|
|
for _ in 0..MAXIMUM_TRANSACTION_TIME {
|
|
|
|
match d.is_connected().unwrap_or(true) {
|
|
|
|
true => thread::sleep(Duration::from_millis(CONNECTION_TIMEOUT_MS)),
|
|
|
|
false => return drop(sender.send(Ok(false))),
|
|
|
|
}
|
|
|
|
}
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::Network)));
|
2016-05-04 18:06:06 +03:00
|
|
|
},
|
2016-07-28 11:33:08 +03:00
|
|
|
None => return drop(sender.send(Err(BluetoothError::NotFound))),
|
2016-07-05 19:02:25 +03:00
|
|
|
}
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
fn get_primary_service(&mut self,
|
|
|
|
device_id: String,
|
|
|
|
uuid: String,
|
2016-11-08 18:05:12 +03:00
|
|
|
sender: IpcSender<BluetoothResponseResult>) {
|
2016-11-07 18:50:13 +03:00
|
|
|
if !self.cached_devices.contains_key(&device_id) {
|
|
|
|
return drop(sender.send(Err(BluetoothError::InvalidState)));
|
|
|
|
}
|
2016-05-30 22:39:34 +03:00
|
|
|
let mut adapter = get_adapter_or_return_error!(self, sender);
|
2016-06-05 16:00:50 +03:00
|
|
|
if !self.allowed_services.get(&device_id).map_or(false, |s| s.contains(&uuid)) {
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::Security)));
|
2016-06-05 16:00:50 +03:00
|
|
|
}
|
2016-05-04 18:06:06 +03:00
|
|
|
let services = self.get_gatt_services_by_uuid(&mut adapter, &device_id, &uuid);
|
|
|
|
if services.is_empty() {
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::NotFound)));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
for service in services {
|
|
|
|
if service.is_primary().unwrap_or(false) {
|
|
|
|
if let Ok(uuid) = service.get_uuid() {
|
2016-11-08 18:05:12 +03:00
|
|
|
return drop(sender.send(
|
|
|
|
Ok(BluetoothResponse::GetPrimaryService(
|
|
|
|
BluetoothServiceMsg {
|
|
|
|
uuid: uuid,
|
|
|
|
is_primary: true,
|
|
|
|
instance_id: service.get_id(),
|
|
|
|
}
|
|
|
|
))
|
|
|
|
));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::NotFound)));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
fn get_primary_services(&mut self,
|
|
|
|
device_id: String,
|
|
|
|
uuid: Option<String>,
|
2016-11-08 18:05:12 +03:00
|
|
|
sender: IpcSender<BluetoothResponseResult>) {
|
2016-11-07 18:50:13 +03:00
|
|
|
if !self.cached_devices.contains_key(&device_id) {
|
|
|
|
return drop(sender.send(Err(BluetoothError::InvalidState)));
|
|
|
|
}
|
2016-05-30 22:39:34 +03:00
|
|
|
let mut adapter = get_adapter_or_return_error!(self, sender);
|
2016-05-04 18:06:06 +03:00
|
|
|
let services = match uuid {
|
2016-06-05 16:00:50 +03:00
|
|
|
Some(ref id) => {
|
|
|
|
if !self.allowed_services.get(&device_id).map_or(false, |s| s.contains(id)) {
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::Security)))
|
2016-06-05 16:00:50 +03:00
|
|
|
}
|
|
|
|
self.get_gatt_services_by_uuid(&mut adapter, &device_id, id)
|
|
|
|
},
|
2016-05-04 18:06:06 +03:00
|
|
|
None => self.get_and_cache_gatt_services(&mut adapter, &device_id),
|
|
|
|
};
|
|
|
|
if services.is_empty() {
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::NotFound)));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
let mut services_vec = vec!();
|
|
|
|
for service in services {
|
|
|
|
if service.is_primary().unwrap_or(false) {
|
|
|
|
if let Ok(uuid) = service.get_uuid() {
|
2016-11-08 18:05:12 +03:00
|
|
|
services_vec.push(
|
|
|
|
BluetoothServiceMsg {
|
|
|
|
uuid: uuid,
|
|
|
|
is_primary: true,
|
|
|
|
instance_id: service.get_id(),
|
|
|
|
}
|
|
|
|
);
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-11-22 14:55:02 +03:00
|
|
|
services_vec.retain(|s| !uuid_is_blocklisted(&s.uuid, Blocklist::All) &&
|
2016-11-07 18:50:13 +03:00
|
|
|
self.allowed_services
|
|
|
|
.get(&device_id)
|
|
|
|
.map_or(false, |uuids| uuids.contains(&s.uuid)));
|
2016-05-04 18:06:06 +03:00
|
|
|
if services_vec.is_empty() {
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::NotFound)));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
|
2016-11-08 18:05:12 +03:00
|
|
|
return drop(sender.send(Ok(BluetoothResponse::GetPrimaryServices(services_vec))));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
|
2016-05-26 22:04:33 +03:00
|
|
|
fn get_included_service(&mut self,
|
|
|
|
service_id: String,
|
|
|
|
uuid: String,
|
2016-11-08 18:05:12 +03:00
|
|
|
sender: IpcSender<BluetoothResponseResult>) {
|
2016-11-07 18:50:13 +03:00
|
|
|
if !self.cached_services.contains_key(&service_id) {
|
|
|
|
return drop(sender.send(Err(BluetoothError::InvalidState)));
|
|
|
|
}
|
2016-11-08 18:05:12 +03:00
|
|
|
let mut adapter = get_adapter_or_return_error!(self, sender);
|
2016-11-04 15:44:42 +03:00
|
|
|
let device = match self.device_from_service_id(&service_id) {
|
|
|
|
Some(device) => device,
|
|
|
|
None => return drop(sender.send(Err(BluetoothError::NotFound))),
|
|
|
|
};
|
2016-05-26 22:04:33 +03:00
|
|
|
let primary_service = match self.get_gatt_service(&mut adapter, &service_id) {
|
|
|
|
Some(s) => s,
|
2016-07-28 11:33:08 +03:00
|
|
|
None => return drop(sender.send(Err(BluetoothError::NotFound))),
|
2016-05-26 22:04:33 +03:00
|
|
|
};
|
2016-11-04 15:44:42 +03:00
|
|
|
let services = primary_service.get_includes(device).unwrap_or(vec!());
|
2016-05-26 22:04:33 +03:00
|
|
|
for service in services {
|
|
|
|
if let Ok(service_uuid) = service.get_uuid() {
|
|
|
|
if uuid == service_uuid {
|
2016-11-08 18:05:12 +03:00
|
|
|
return drop(sender.send(
|
|
|
|
Ok(BluetoothResponse::GetIncludedService(
|
|
|
|
BluetoothServiceMsg {
|
|
|
|
uuid: uuid,
|
|
|
|
is_primary: service.is_primary().unwrap_or(false),
|
|
|
|
instance_id: service.get_id(),
|
|
|
|
}
|
|
|
|
))
|
|
|
|
));
|
2016-05-26 22:04:33 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::NotFound)));
|
2016-05-26 22:04:33 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
fn get_included_services(&mut self,
|
|
|
|
service_id: String,
|
|
|
|
uuid: Option<String>,
|
2016-11-08 18:05:12 +03:00
|
|
|
sender: IpcSender<BluetoothResponseResult>) {
|
2016-11-07 18:50:13 +03:00
|
|
|
if !self.cached_services.contains_key(&service_id) {
|
|
|
|
return drop(sender.send(Err(BluetoothError::InvalidState)));
|
|
|
|
}
|
2016-11-08 18:05:12 +03:00
|
|
|
let mut adapter = get_adapter_or_return_error!(self, sender);
|
2016-11-04 15:44:42 +03:00
|
|
|
let device = match self.device_from_service_id(&service_id) {
|
|
|
|
Some(device) => device,
|
|
|
|
None => return drop(sender.send(Err(BluetoothError::NotFound))),
|
|
|
|
};
|
2016-05-26 22:04:33 +03:00
|
|
|
let primary_service = match self.get_gatt_service(&mut adapter, &service_id) {
|
|
|
|
Some(s) => s,
|
2016-07-28 11:33:08 +03:00
|
|
|
None => return drop(sender.send(Err(BluetoothError::NotFound))),
|
2016-05-26 22:04:33 +03:00
|
|
|
};
|
2016-11-04 15:44:42 +03:00
|
|
|
let services = primary_service.get_includes(device).unwrap_or(vec!());
|
2016-05-26 22:04:33 +03:00
|
|
|
let mut services_vec = vec!();
|
|
|
|
for service in services {
|
|
|
|
if let Ok(service_uuid) = service.get_uuid() {
|
2016-11-08 18:05:12 +03:00
|
|
|
services_vec.push(
|
|
|
|
BluetoothServiceMsg {
|
|
|
|
uuid: service_uuid,
|
|
|
|
is_primary: service.is_primary().unwrap_or(false),
|
|
|
|
instance_id: service.get_id(),
|
|
|
|
}
|
|
|
|
);
|
2016-05-26 22:04:33 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if let Some(uuid) = uuid {
|
|
|
|
services_vec.retain(|ref s| s.uuid == uuid);
|
|
|
|
}
|
2016-11-22 14:55:02 +03:00
|
|
|
services_vec.retain(|s| !uuid_is_blocklisted(&s.uuid, Blocklist::All));
|
2016-05-26 22:04:33 +03:00
|
|
|
if services_vec.is_empty() {
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::NotFound)));
|
2016-05-26 22:04:33 +03:00
|
|
|
}
|
|
|
|
|
2016-11-08 18:05:12 +03:00
|
|
|
return drop(sender.send(Ok(BluetoothResponse::GetIncludedServices(services_vec))));
|
2016-05-26 22:04:33 +03:00
|
|
|
}
|
|
|
|
|
2016-05-04 18:06:06 +03:00
|
|
|
fn get_characteristic(&mut self,
|
|
|
|
service_id: String,
|
|
|
|
uuid: String,
|
2016-11-08 18:05:12 +03:00
|
|
|
sender: IpcSender<BluetoothResponseResult>) {
|
2016-11-07 18:50:13 +03:00
|
|
|
if !self.cached_services.contains_key(&service_id) {
|
|
|
|
return drop(sender.send(Err(BluetoothError::InvalidState)));
|
|
|
|
}
|
2016-05-30 22:39:34 +03:00
|
|
|
let mut adapter = get_adapter_or_return_error!(self, sender);
|
2016-05-04 18:06:06 +03:00
|
|
|
let characteristics = self.get_gatt_characteristics_by_uuid(&mut adapter, &service_id, &uuid);
|
|
|
|
if characteristics.is_empty() {
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::NotFound)));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
for characteristic in characteristics {
|
|
|
|
if let Ok(uuid) = characteristic.get_uuid() {
|
|
|
|
let properties = self.get_characteristic_properties(&characteristic);
|
2016-11-08 18:05:12 +03:00
|
|
|
let message = BluetoothCharacteristicMsg {
|
|
|
|
uuid: uuid,
|
|
|
|
instance_id: characteristic.get_id(),
|
|
|
|
broadcast: properties.contains(BROADCAST),
|
|
|
|
read: properties.contains(READ),
|
|
|
|
write_without_response: properties.contains(WRITE_WITHOUT_RESPONSE),
|
|
|
|
write: properties.contains(WRITE),
|
|
|
|
notify: properties.contains(NOTIFY),
|
|
|
|
indicate: properties.contains(INDICATE),
|
|
|
|
authenticated_signed_writes: properties.contains(AUTHENTICATED_SIGNED_WRITES),
|
|
|
|
reliable_write: properties.contains(RELIABLE_WRITE),
|
|
|
|
writable_auxiliaries: properties.contains(WRITABLE_AUXILIARIES),
|
|
|
|
};
|
|
|
|
return drop(sender.send(Ok(BluetoothResponse::GetCharacteristic(message))));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
}
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::NotFound)));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
fn get_characteristics(&mut self,
|
|
|
|
service_id: String,
|
|
|
|
uuid: Option<String>,
|
2016-11-08 18:05:12 +03:00
|
|
|
sender: IpcSender<BluetoothResponseResult>) {
|
2016-11-07 18:50:13 +03:00
|
|
|
if !self.cached_services.contains_key(&service_id) {
|
|
|
|
return drop(sender.send(Err(BluetoothError::InvalidState)));
|
|
|
|
}
|
2016-05-30 22:39:34 +03:00
|
|
|
let mut adapter = get_adapter_or_return_error!(self, sender);
|
2016-05-04 18:06:06 +03:00
|
|
|
let characteristics = match uuid {
|
|
|
|
Some(id) => self.get_gatt_characteristics_by_uuid(&mut adapter, &service_id, &id),
|
|
|
|
None => self.get_and_cache_gatt_characteristics(&mut adapter, &service_id),
|
|
|
|
};
|
|
|
|
if characteristics.is_empty() {
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::NotFound)));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
let mut characteristics_vec = vec!();
|
|
|
|
for characteristic in characteristics {
|
|
|
|
if let Ok(uuid) = characteristic.get_uuid() {
|
|
|
|
let properties = self.get_characteristic_properties(&characteristic);
|
|
|
|
characteristics_vec.push(
|
2016-11-08 18:05:12 +03:00
|
|
|
BluetoothCharacteristicMsg {
|
|
|
|
uuid: uuid,
|
|
|
|
instance_id: characteristic.get_id(),
|
|
|
|
broadcast: properties.contains(BROADCAST),
|
|
|
|
read: properties.contains(READ),
|
|
|
|
write_without_response: properties.contains(WRITE_WITHOUT_RESPONSE),
|
|
|
|
write: properties.contains(WRITE),
|
|
|
|
notify: properties.contains(NOTIFY),
|
|
|
|
indicate: properties.contains(INDICATE),
|
|
|
|
authenticated_signed_writes: properties.contains(AUTHENTICATED_SIGNED_WRITES),
|
|
|
|
reliable_write: properties.contains(RELIABLE_WRITE),
|
|
|
|
writable_auxiliaries: properties.contains(WRITABLE_AUXILIARIES),
|
|
|
|
}
|
|
|
|
);
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
}
|
2016-11-22 14:55:02 +03:00
|
|
|
characteristics_vec.retain(|c| !uuid_is_blocklisted(&c.uuid, Blocklist::All));
|
2016-05-04 18:06:06 +03:00
|
|
|
if characteristics_vec.is_empty() {
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::NotFound)));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
|
2016-11-08 18:05:12 +03:00
|
|
|
return drop(sender.send(Ok(BluetoothResponse::GetCharacteristics(characteristics_vec))));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
fn get_descriptor(&mut self,
|
|
|
|
characteristic_id: String,
|
|
|
|
uuid: String,
|
2016-11-08 18:05:12 +03:00
|
|
|
sender: IpcSender<BluetoothResponseResult>) {
|
2016-11-07 18:50:13 +03:00
|
|
|
if !self.cached_characteristics.contains_key(&characteristic_id) {
|
|
|
|
return drop(sender.send(Err(BluetoothError::InvalidState)));
|
|
|
|
}
|
2016-05-30 22:39:34 +03:00
|
|
|
let mut adapter = get_adapter_or_return_error!(self, sender);
|
2016-05-04 18:06:06 +03:00
|
|
|
let descriptors = self.get_gatt_descriptors_by_uuid(&mut adapter, &characteristic_id, &uuid);
|
|
|
|
if descriptors.is_empty() {
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::NotFound)));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
for descriptor in descriptors {
|
|
|
|
if let Ok(uuid) = descriptor.get_uuid() {
|
2016-11-08 18:05:12 +03:00
|
|
|
return drop(sender.send(
|
|
|
|
Ok(BluetoothResponse::GetDescriptor(
|
|
|
|
BluetoothDescriptorMsg {
|
|
|
|
uuid: uuid,
|
|
|
|
instance_id: descriptor.get_id(),
|
|
|
|
}
|
|
|
|
))
|
|
|
|
));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
}
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::NotFound)));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
fn get_descriptors(&mut self,
|
|
|
|
characteristic_id: String,
|
|
|
|
uuid: Option<String>,
|
2016-11-08 18:05:12 +03:00
|
|
|
sender: IpcSender<BluetoothResponseResult>) {
|
2016-11-07 18:50:13 +03:00
|
|
|
if !self.cached_characteristics.contains_key(&characteristic_id) {
|
|
|
|
return drop(sender.send(Err(BluetoothError::InvalidState)));
|
|
|
|
}
|
2016-05-30 22:39:34 +03:00
|
|
|
let mut adapter = get_adapter_or_return_error!(self, sender);
|
2016-05-04 18:06:06 +03:00
|
|
|
let descriptors = match uuid {
|
|
|
|
Some(id) => self.get_gatt_descriptors_by_uuid(&mut adapter, &characteristic_id, &id),
|
|
|
|
None => self.get_and_cache_gatt_descriptors(&mut adapter, &characteristic_id),
|
|
|
|
};
|
|
|
|
if descriptors.is_empty() {
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::NotFound)));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
let mut descriptors_vec = vec!();
|
|
|
|
for descriptor in descriptors {
|
|
|
|
if let Ok(uuid) = descriptor.get_uuid() {
|
2016-11-08 18:05:12 +03:00
|
|
|
descriptors_vec.push(
|
|
|
|
BluetoothDescriptorMsg {
|
|
|
|
uuid: uuid,
|
|
|
|
instance_id: descriptor.get_id(),
|
|
|
|
}
|
|
|
|
);
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
}
|
2016-11-22 14:55:02 +03:00
|
|
|
descriptors_vec.retain(|d| !uuid_is_blocklisted(&d.uuid, Blocklist::All));
|
2016-05-04 18:06:06 +03:00
|
|
|
if descriptors_vec.is_empty() {
|
2016-07-28 11:33:08 +03:00
|
|
|
return drop(sender.send(Err(BluetoothError::NotFound)));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
2016-11-08 18:05:12 +03:00
|
|
|
return drop(sender.send(Ok(BluetoothResponse::GetDescriptors(descriptors_vec))));
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
|
2016-11-08 18:05:12 +03:00
|
|
|
fn read_value(&mut self, id: String, sender: IpcSender<BluetoothResponseResult>) {
|
2016-05-30 22:39:34 +03:00
|
|
|
let mut adapter = get_adapter_or_return_error!(self, sender);
|
2016-05-04 18:06:06 +03:00
|
|
|
let mut value = self.get_gatt_characteristic(&mut adapter, &id)
|
|
|
|
.map(|c| c.read_value().unwrap_or(vec![]));
|
|
|
|
if value.is_none() {
|
|
|
|
value = self.get_gatt_descriptor(&mut adapter, &id)
|
|
|
|
.map(|d| d.read_value().unwrap_or(vec![]));
|
|
|
|
}
|
2016-11-08 18:05:12 +03:00
|
|
|
match value {
|
|
|
|
Some(v) => return drop(sender.send(Ok(BluetoothResponse::ReadValue(v)))),
|
|
|
|
None => return drop(sender.send(Err(BluetoothError::InvalidState))),
|
|
|
|
}
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
|
2016-11-08 18:05:12 +03:00
|
|
|
fn write_value(&mut self, id: String, value: Vec<u8>, sender: IpcSender<BluetoothResponseResult>) {
|
2016-05-30 22:39:34 +03:00
|
|
|
let mut adapter = get_adapter_or_return_error!(self, sender);
|
2016-05-04 18:06:06 +03:00
|
|
|
let mut result = self.get_gatt_characteristic(&mut adapter, &id)
|
|
|
|
.map(|c| c.write_value(value.clone()));
|
|
|
|
if result.is_none() {
|
|
|
|
result = self.get_gatt_descriptor(&mut adapter, &id)
|
|
|
|
.map(|d| d.write_value(value.clone()));
|
|
|
|
}
|
2016-11-08 18:05:12 +03:00
|
|
|
match result {
|
2016-05-04 18:06:06 +03:00
|
|
|
Some(v) => match v {
|
2016-11-08 18:05:12 +03:00
|
|
|
Ok(_) => return drop(sender.send(Ok(BluetoothResponse::WriteValue(value)))),
|
2016-07-28 11:33:08 +03:00
|
|
|
Err(_) => return drop(sender.send(Err(BluetoothError::NotSupported))),
|
2016-05-04 18:06:06 +03:00
|
|
|
},
|
2016-11-07 18:50:13 +03:00
|
|
|
None => return drop(sender.send(Err(BluetoothError::InvalidState))),
|
2016-11-08 18:05:12 +03:00
|
|
|
}
|
2016-05-04 18:06:06 +03:00
|
|
|
}
|
|
|
|
}
|