servo/components/net/bluetooth_thread.rs

/* 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/. */

use device::bluetooth::BluetoothAdapter;
use device::bluetooth::BluetoothDevice;
use device::bluetooth::BluetoothGATTCharacteristic;
use device::bluetooth::BluetoothGATTDescriptor;
use device::bluetooth::BluetoothGATTService;
use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
use net_traits::bluetooth_scanfilter::{RequestDeviceoptions, matches_filters};
use net_traits::bluetooth_thread::{BluetoothMethodMsg, BluetoothObjectMsg};
use std::borrow::ToOwned;
use std::collections::HashMap;
use std::string::String;
use util::thread::spawn_named;

macro_rules! send_error(
    ($sender:expr, $error:expr) => (
        return $sender.send(BluetoothObjectMsg::Error { error: String::from($error) }).unwrap();
    );
);

macro_rules! check_cache(
    ($cache:expr, $key:expr) => (
        if $cache.contains_key($key) {
            return $cache.get($key);
        }
    );
);

pub trait BluetoothThreadFactory {
    fn new() -> Self;
}

impl BluetoothThreadFactory for IpcSender<BluetoothMethodMsg> {
    fn new() -> IpcSender<BluetoothMethodMsg> {
        let (sender, receiver) = ipc::channel().unwrap();
        let adapter = match BluetoothAdapter::init() {
            Ok(a) => Some(a),
            Err(_) => None,
        };
        spawn_named("BluetoothThread".to_owned(), move || {
            BluetoothManager::new(receiver, adapter).start();
        });
        sender
    }
}

pub struct BluetoothManager {
    receiver: IpcReceiver<BluetoothMethodMsg>,
    adapter: Option<BluetoothAdapter>,
    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>,
}

impl BluetoothManager {
    pub fn new (receiver: IpcReceiver<BluetoothMethodMsg>, adapter: Option<BluetoothAdapter>) -> BluetoothManager {
        BluetoothManager {
            receiver: receiver,
            adapter: adapter,
            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(),
        }
    }

    fn start(&mut self) {
        loop {
            match self.receiver.recv().unwrap() {
                BluetoothMethodMsg::RequestDevice(options, sender) => {
                    self.request_device(options, sender)
                }
                BluetoothMethodMsg::GATTServerConnect(device_id, sender) => {
                    self.gatt_server_connect(device_id, sender)
                }
                BluetoothMethodMsg::GATTServerDisconnect(device_id, sender) => {
                    self.gatt_server_disconnect(device_id, sender)
                }
                BluetoothMethodMsg::GetPrimaryService(device_id, uuid, sender) => {
                    self.get_primary_service(device_id, uuid, sender)
                }
                BluetoothMethodMsg::GetPrimaryServices(device_id, uuid, sender) => {
                    self.get_primary_services(device_id, uuid, sender)
                }
                BluetoothMethodMsg::GetCharacteristic(service_id, uuid, sender) => {
                    self.get_characteristic(service_id, uuid, sender)
                }
                BluetoothMethodMsg::GetCharacteristics(service_id, uuid, sender) => {
                    self.get_characteristics(service_id, uuid, sender)
                }
                BluetoothMethodMsg::GetDescriptor(characteristic_id, uuid, sender) => {
                    self.get_descriptor(characteristic_id, uuid, sender)
                }
                BluetoothMethodMsg::GetDescriptors(characteristic_id, uuid, sender) => {
                    self.get_descriptors(characteristic_id, uuid, sender)
                }
                BluetoothMethodMsg::ReadValue(id, sender) => {
                    self.read_value(id, sender)
                }
                BluetoothMethodMsg::WriteValue(id, value, sender) => {
                    self.write_value(id, value, sender)
                }
                BluetoothMethodMsg::Exit => {
                    break
                }
            }
        }
    }

    // Adapter

    fn get_adapter(&mut self) -> Option<BluetoothAdapter> {
        if self.adapter.is_none()
        || self.adapter.clone().unwrap().get_address().is_err() {
            self.adapter = BluetoothAdapter::init().ok();
        }
        self.adapter.clone()
    }

    // Device

    fn get_devices(&mut self, adapter: &mut BluetoothAdapter) -> Vec<BluetoothDevice> {
        let devices = adapter.get_devices().unwrap_or(vec!());
        for device in &devices {
            self.cached_devices.insert(device.get_address().unwrap_or("".to_owned()), device.clone());
        }
        devices
    }

    fn get_device(&mut self, adapter: &mut BluetoothAdapter, device_id: &str) -> Option<&BluetoothDevice> {
        check_cache!(self.cached_devices, device_id);
        // Update cache
        self.get_devices(adapter);
        check_cache!(self.cached_devices, device_id);
        None
    }

    // Service

    fn get_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 {
            self.cached_services.insert(service.get_object_path(), service.clone());
            self.service_to_device.insert(service.get_object_path(), device_id.to_owned());
        }
        services
    }

    fn get_gatt_service(&mut self,
                        adapter: &mut BluetoothAdapter,
                        service_id: &str)
                        -> Option<&BluetoothGATTService> {
        check_cache!(self.cached_services, service_id);
        let device_id = match self.service_to_device.get_mut(service_id) {
            Some(d) => d.clone(),
            None => return None,
        };
        // Update cache
        self.get_gatt_services(adapter, &device_id);
        check_cache!(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 mut services_vec: Vec<BluetoothGATTService> = vec!();
        let services = self.get_gatt_services(adapter, device_id);
        for service in services {
            if service.get_uuid().unwrap_or("".to_owned()) == service_uuid {
                services_vec.push(service.clone());
            }
        }
        services_vec
    }

    // Characteristic

    fn get_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 {
            self.cached_characteristics.insert(characteristic.get_object_path(), characteristic.clone());
            self.characteristic_to_service.insert(characteristic.get_object_path(), service_id.to_owned());
        }
        characteristics
    }

    fn get_gatt_characteristic(&mut self,
                               adapter: &mut BluetoothAdapter,
                               characteristic_id: &str)
                               -> Option<&BluetoothGATTCharacteristic> {
        check_cache!(self.cached_characteristics, characteristic_id);
        let service_id = match self.characteristic_to_service.get_mut(characteristic_id) {
            Some(s) => s.clone(),
            None => return None,
        };
        // Update cache
        self.get_gatt_characteristics(adapter, &service_id);
        check_cache!(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 mut characteristics_vec: Vec<BluetoothGATTCharacteristic> = vec!();
        let characteristics = self.get_gatt_characteristics(adapter, service_id);
        for characteristic in characteristics {
            if characteristic.get_uuid().unwrap_or("".to_owned()) == characteristic_uuid {
                characteristics_vec.push(characteristic.clone());
            }
        }
        characteristics_vec
    }

    fn get_characteristic_properties(&self, characteristic: &BluetoothGATTCharacteristic) -> [bool; 9] {
        let mut props = [false; 9];
        let flags = characteristic.get_flags().unwrap_or(vec!());
        for flag in flags {
            match flag.as_ref() {
                "broadcast" => props[0] = true,
                "read" => props[1] = true,
                "write_without_response" => props[2] = true,
                "write" => props[3] = true,
                "notify" => props[4] = true,
                "indicate" => props[5] = true,
                "authenticated_signed_writes" => props[6] = true,
                "reliable_write" => props[7] = true,
                "writable_auxiliaries" => props[8] = true,
                _ => (),
            }
        }
        props
    }

    // Descriptor

    fn get_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 {
            self.cached_descriptors.insert(descriptor.get_object_path(), descriptor.clone());
            self.descriptor_to_characteristic.insert(descriptor.get_object_path(), characteristic_id.to_owned());
        }
        descriptors
    }

    fn get_gatt_descriptor(&mut self,
                           adapter: &mut BluetoothAdapter,
                           descriptor_id: &str)
                           -> Option<&BluetoothGATTDescriptor> {
        check_cache!(self.cached_descriptors, descriptor_id);
        let characteristic_id = match self.descriptor_to_characteristic.get_mut(descriptor_id) {
            Some(c) => c.clone(),
            None => return None,
        };
        // Update cache
        self.get_gatt_descriptors(adapter, &characteristic_id);
        check_cache!(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 mut descriptors_vec: Vec<BluetoothGATTDescriptor> = vec!();
        let descriptors = self.get_gatt_descriptors(adapter, characteristic_id);
        for descriptor in descriptors {
            if descriptor.get_uuid().unwrap_or("".to_owned()) == descriptor_uuid {
                descriptors_vec.push(descriptor.clone());
            }
        }
        descriptors_vec
    }

    // Methods

    fn request_device(&mut self,
                      options: RequestDeviceoptions,
                      sender: IpcSender<BluetoothObjectMsg>) {
        let mut adapter = match self.get_adapter() {
            Some(a) => a,
            None => send_error!(sender, "No adapter found"),
        };
        let devices = self.get_devices(&mut adapter);
        if devices.is_empty() {
            send_error!(sender, "No device found");
        }

        let matched_devices: Vec<BluetoothDevice> = devices.into_iter()
                                                           .filter(|d| matches_filters(d, options.get_filters()))
                                                           .collect();
        for device in matched_devices {
            if let Ok(address) = device.get_address() {
                let message = BluetoothObjectMsg::BluetoothDevice {
                    id: address,
                    name: device.get_name().ok(),
                    device_class: device.get_class().ok(),
                    vendor_id_source: device.get_vendor_id_source().ok(),
                    vendor_id: device.get_vendor_id().ok(),
                    product_id: device.get_product_id().ok(),
                    product_version: device.get_device_id().ok(),
                    appearance: device.get_appearance().ok(),
                    tx_power: match device.get_tx_power() {
                        Ok(p) => Some(p as i8),
                        Err(_) => None,
                    },
                    rssi: match device.get_rssi() {
                        Ok(p) => Some(p as i8),
                        Err(_) => None,
                    },
                };
                return sender.send(message).unwrap();
            }
        }
        send_error!(sender, "No device found, that matches the given options");
    }

    pub fn gatt_server_connect(&mut self, device_id: String, sender: IpcSender<BluetoothObjectMsg>) {
        let mut adapter = match self.get_adapter() {
            Some(a) => a,
            None => send_error!(sender, "No adapter found"),
        };

        let connected = match self.get_device(&mut adapter, &device_id) {
            Some(d) => {
                if d.is_connected().unwrap_or(false) {
                    true
                } else {
                    !d.connect().is_err()
                }
            }
            None => send_error!(sender, "No device found"),
        };

        let message = BluetoothObjectMsg::BluetoothServer {
            connected: connected
        };
        sender.send(message).unwrap();
    }

    pub fn gatt_server_disconnect(&mut self, device_id: String, sender: IpcSender<BluetoothObjectMsg>) {
        let mut adapter = match self.get_adapter() {
            Some(a) => a,
            None => send_error!(sender, "No adapter found"),
        };

        let connected = match self.get_device(&mut adapter, &device_id) {
            Some(d) => {
                if d.is_connected().unwrap_or(false) {
                    d.disconnect().is_err()
                } else {
                    false
                }
            }
            None => send_error!(sender, "No device found"),
        };

        let message = BluetoothObjectMsg::BluetoothServer {
            connected: connected
        };
        sender.send(message).unwrap();
    }

    pub fn get_primary_service(&mut self, device_id: String, uuid: String, sender: IpcSender<BluetoothObjectMsg>) {
        let mut adapter = match self.get_adapter() {
            Some(a) => a,
            None => send_error!(sender, "No adapter found"),
        };
        let services = self.get_gatt_services_by_uuid(&mut adapter, &device_id, &uuid);
        if services.is_empty() {
            send_error!(sender, "No primary service found");
        }
        for service in services {
            if service.is_primary().unwrap_or(false) {
                if let Ok(uuid) = service.get_uuid() {
                    let message = BluetoothObjectMsg::BluetoothService {
                        uuid: uuid,
                        is_primary: true,
                        instance_id: service.get_object_path(),
                    };
                    return sender.send(message).unwrap();
                }
            }
        }
        send_error!(sender, "No primary service found");
    }

    pub fn get_primary_services(&mut self,
                                device_id: String,
                                uuid: Option<String>,
                                sender: IpcSender<BluetoothObjectMsg>) {
        let mut adapter = match self.get_adapter() {
            Some(a) => a,
            None => send_error!(sender, "No adapter found"),
        };
        let services: Vec<BluetoothGATTService> = match uuid {
            Some(id) => self.get_gatt_services_by_uuid(&mut adapter, &device_id, &id),
            None => self.get_gatt_services(&mut adapter, &device_id),
        };
        if services.is_empty() {
            send_error!(sender, "No service found");
        }
        let mut services_vec: Vec<BluetoothObjectMsg> = vec!();
        for service in services {
            if service.is_primary().unwrap_or(false) {
                services_vec.push(BluetoothObjectMsg::BluetoothService {
                    uuid: service.get_uuid().unwrap_or("".to_owned()),
                    is_primary: true,
                    instance_id: service.get_object_path(),
                });
            }
        }
        if services_vec.is_empty() {
            send_error!(sender, "No service found");
        }
        let message = BluetoothObjectMsg::BluetoothServices { services_vec: services_vec };
        sender.send(message).unwrap();
    }

    pub fn get_characteristic(&mut self, service_id: String, uuid: String, sender: IpcSender<BluetoothObjectMsg>) {
        let mut adapter = match self.get_adapter() {
            Some(a) => a,
            None => send_error!(sender, "No adapter found"),
        };
        let characteristics = self.get_gatt_characteristics_by_uuid(&mut adapter, &service_id, &uuid);
        if characteristics.is_empty() {
            send_error!(sender, "No characteristic found");
        }
        for characteristic in characteristics {
            if let Ok(uuid) = characteristic.get_uuid() {
                let properties = self.get_characteristic_properties(&characteristic);
                let message = BluetoothObjectMsg::BluetoothCharacteristic {
                    uuid: uuid,
                    instance_id: characteristic.get_object_path(),
                    broadcast: properties[0],
                    read: properties[1],
                    write_without_response: properties[2],
                    write: properties[3],
                    notify: properties[4],
                    indicate: properties[5],
                    authenticated_signed_writes: properties[6],
                    reliable_write: properties[7],
                    writable_auxiliaries: properties[8],
                };
                return sender.send(message).unwrap();
            }
        }
        send_error!(sender, "No characteristic found");
    }

    pub fn get_characteristics(&mut self,
                               service_id: String,
                               uuid: Option<String>,
                               sender: IpcSender<BluetoothObjectMsg>) {
        let mut adapter = match self.get_adapter() {
            Some(a) => a,
            None => send_error!(sender, "No adapter found"),
        };
        let characteristics = match uuid {
            Some(id) => self.get_gatt_characteristics_by_uuid(&mut adapter, &service_id, &id),
            None => self.get_gatt_characteristics(&mut adapter, &service_id),
        };
        if characteristics.is_empty() {
            send_error!(sender, "No characteristic found");
        }
        let mut characteristics_vec: Vec<BluetoothObjectMsg> = vec!();
        for characteristic in characteristics {
            let properties = self.get_characteristic_properties(&characteristic);
            characteristics_vec.push(BluetoothObjectMsg::BluetoothCharacteristic {
                uuid: characteristic.get_uuid().unwrap_or("".to_owned()),
                instance_id: characteristic.get_object_path(),
                broadcast: properties[0],
                read: properties[1],
                write_without_response: properties[2],
                write: properties[3],
                notify: properties[4],
                indicate: properties[5],
                authenticated_signed_writes: properties[6],
                reliable_write: properties[7],
                writable_auxiliaries: properties[8],
            });
        }
        if characteristics_vec.is_empty() {
            send_error!(sender, "No characteristic found");
        }
        let message = BluetoothObjectMsg::BluetoothCharacteristics { characteristics_vec: characteristics_vec };
        sender.send(message).unwrap();
    }

    pub fn get_descriptor(&mut self,
                          characteristic_id: String,
                          uuid: String,
                          sender: IpcSender<BluetoothObjectMsg>) {
        let mut adapter = match self.get_adapter() {
            Some(a) => a,
            None => send_error!(sender, "No adapter found"),
        };
        let descriptors = self.get_gatt_descriptors_by_uuid(&mut adapter, &characteristic_id, &uuid);
        if descriptors.is_empty() {
            send_error!(sender, "No descriptor found");
        }
        for descriptor in descriptors {
            if let Ok(uuid) = descriptor.get_uuid() {
                let message = BluetoothObjectMsg::BluetoothDescriptor {
                    uuid: uuid,
                    instance_id: descriptor.get_object_path(),
                };
                return sender.send(message).unwrap();
            }
        }
        send_error!(sender, "No descriptor found");
    }

    pub fn get_descriptors(&mut self,
                           characteristic_id: String,
                           uuid: Option<String>,
                           sender: IpcSender<BluetoothObjectMsg>) {
        let mut adapter = match self.get_adapter() {
            Some(a) => a,
            None => send_error!(sender, "No adapter found"),
        };
        let descriptors = match uuid {
            Some(id) => self.get_gatt_descriptors_by_uuid(&mut adapter, &characteristic_id, &id),
            None => self.get_gatt_descriptors(&mut adapter, &characteristic_id),
        };
        if descriptors.is_empty() {
            send_error!(sender, "No descriptor found");
        }
        let mut descriptors_vec: Vec<BluetoothObjectMsg> = vec!();
        for descriptor in descriptors {
            descriptors_vec.push(BluetoothObjectMsg::BluetoothDescriptor {
                uuid: descriptor.get_uuid().unwrap_or("".to_owned()),
                instance_id: descriptor.get_object_path(),
            });
        }
        if descriptors_vec.is_empty() {
            send_error!(sender, "No descriptor found");
        }
        let message = BluetoothObjectMsg::BluetoothDescriptors { descriptors_vec: descriptors_vec };
        sender.send(message).unwrap();
    }

    pub fn read_value(&mut self, id: String, sender: IpcSender<BluetoothObjectMsg>) {
        let mut adapter = match self.get_adapter() {
            Some(a) => a,
            None => send_error!(sender, "No adapter found"),
        };
        let mut value = match self.get_gatt_characteristic(&mut adapter, &id) {
            Some(c) => Some(c.read_value().unwrap_or(vec!())),
            None => None,
        };
        if value.is_none() {
            value = match self.get_gatt_descriptor(&mut adapter, &id) {
                Some(d) => Some(d.read_value().unwrap_or(vec!())),
                None => None,
            };
        }

        let message = match value {
            Some(v) => BluetoothObjectMsg::BluetoothReadValue { value: v },
            None => send_error!(sender, "No characteristic or descriptor found with that id"),
        };

        sender.send(message).unwrap();
    }

    pub fn write_value(&mut self, id: String, value: Vec<u8>, sender: IpcSender<BluetoothObjectMsg>) {
        let mut adapter = match self.get_adapter() {
            Some(a) => a,
            None => send_error!(sender, "No adapter found"),
        };
        let mut result = match self.get_gatt_characteristic(&mut adapter, &id) {
            Some(c) => Some(c.write_value(value.clone())),
            None => None,
        };
        if result.is_none() {
            result = match self.get_gatt_descriptor(&mut adapter, &id) {
                Some(d) => Some(d.write_value(value.clone())),
                None => None,
            };
        }

        let message = match result {
            Some(v) => match v {
                Ok(_) => BluetoothObjectMsg::BluetoothWriteValue,
                Err(e) => send_error!(sender, e.to_string()),
            },
            None => send_error!(sender, "No characteristic or descriptor found with that id"),
        };

        sender.send(message).unwrap();
    }
}