| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| use { |
| failure::{bail, Error}, |
| fidl_fuchsia_bluetooth_control as fidl_control, |
| fuchsia_bluetooth::{ |
| assigned_numbers::find_service_uuid, |
| types::Bool, |
| util::{clone_bt_fidl_bool, clone_host_state}, |
| }, |
| std::fmt::{self, Write}, |
| }; |
| |
| pub struct AdapterInfo(fidl_control::AdapterInfo); |
| |
| impl From<fidl_control::AdapterInfo> for AdapterInfo { |
| fn from(b: fidl_control::AdapterInfo) -> AdapterInfo { |
| AdapterInfo(b) |
| } |
| } |
| impl Into<fidl_control::AdapterInfo> for AdapterInfo { |
| fn into(self) -> fidl_control::AdapterInfo { |
| self.0 |
| } |
| } |
| |
| impl fmt::Display for AdapterInfo { |
| fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { |
| writeln!(fmt, "Adapter:")?; |
| writeln!(fmt, "\tIdentifier:\t{}", self.0.identifier)?; |
| writeln!(fmt, "\tAddress:\t{}", self.0.address)?; |
| writeln!(fmt, "\tTechnology:\t{:?}", self.0.technology)?; |
| if let Some(ref state) = self.0.state { |
| for line in AdapterState::from(clone_host_state(state)).to_string().lines() { |
| writeln!(fmt, "\t{}", line)?; |
| } |
| } |
| Ok(()) |
| } |
| } |
| |
| pub struct AdapterState(fidl_control::AdapterState); |
| |
| impl From<fidl_control::AdapterState> for AdapterState { |
| fn from(b: fidl_control::AdapterState) -> AdapterState { |
| AdapterState(b) |
| } |
| } |
| impl Into<fidl_control::AdapterState> for AdapterState { |
| fn into(self) -> fidl_control::AdapterState { |
| self.0 |
| } |
| } |
| |
| impl fmt::Display for AdapterState { |
| fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { |
| if let Some(ref local_name) = self.0.local_name { |
| writeln!(fmt, "Local Name:\t{}", local_name)?; |
| } |
| if let Some(ref discoverable) = self.0.discoverable { |
| writeln!(fmt, "Discoverable:\t{}", Bool::from(clone_bt_fidl_bool(discoverable)))?; |
| } |
| if let Some(ref discovering) = self.0.discovering { |
| writeln!(fmt, "Discovering:\t{}", Bool::from(clone_bt_fidl_bool(discovering)))?; |
| } |
| writeln!(fmt, "Local UUIDs:\t{:#?}", self.0.local_service_uuids) |
| } |
| } |
| |
| pub struct RemoteDevice(pub fidl_control::RemoteDevice); |
| |
| impl RemoteDevice { |
| /// Construct a concise summary of a `RemoteDevice`'s information. |
| pub fn summary(&self) -> String { |
| let mut msg = String::new(); |
| write!(msg, "Device {}", self.0.address).expect("Error occurred writing to String"); |
| if let Some(rssi) = &self.0.rssi { |
| write!(msg, ", RSSI {}", rssi.value).expect("Error occurred writing to String"); |
| } |
| if let Some(name) = &self.0.name { |
| write!(msg, ", Name {}", name).expect("Error occurred writing to String"); |
| } |
| if self.0.bonded { |
| write!(msg, " [bonded]").expect("Error occurred writing to String"); |
| } |
| if self.0.connected { |
| write!(msg, " [connected]").expect("Error occurred writing to String"); |
| } |
| msg |
| } |
| } |
| |
| impl From<fidl_control::RemoteDevice> for RemoteDevice { |
| fn from(b: fidl_control::RemoteDevice) -> RemoteDevice { |
| RemoteDevice(b) |
| } |
| } |
| impl Into<fidl_control::RemoteDevice> for RemoteDevice { |
| fn into(self) -> fidl_control::RemoteDevice { |
| self.0 |
| } |
| } |
| |
| impl fmt::Display for RemoteDevice { |
| fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { |
| writeln!(fmt, "Remote Device:")?; |
| writeln!(fmt, "\tIdentifier:\t{}", self.0.identifier)?; |
| writeln!(fmt, "\tAddress:\t{}", self.0.address)?; |
| writeln!(fmt, "\tTechnology:\t{:?}", self.0.technology)?; |
| if let Some(name) = &self.0.name { |
| writeln!(fmt, "\tName:\t\t{}", name)?; |
| } |
| writeln!(fmt, "\tAppearance:\t{:?}", self.0.appearance)?; |
| if let Some(rssi) = &self.0.rssi { |
| writeln!(fmt, "\tRSSI:\t\t{}", rssi.value)?; |
| } |
| if let Some(tx_power) = &self.0.tx_power { |
| writeln!(fmt, "\tTX Power:\t{}", tx_power.value)?; |
| } |
| writeln!(fmt, "\tConnected:\t{}", self.0.connected)?; |
| writeln!(fmt, "\tBonded:\t\t{}", self.0.bonded)?; |
| writeln!( |
| fmt, |
| "\tServices:\t{:?}", |
| self.0 |
| .service_uuids |
| .iter() |
| .map(|uuid| find_service_uuid(uuid).map(|an| an.name).unwrap_or(uuid)) |
| .collect::<Vec<_>>(), |
| )?; |
| Ok(()) |
| } |
| } |
| |
| pub trait TryInto<T> { |
| fn try_into(self) -> Result<T, Error>; |
| } |
| |
| #[repr(u32)] |
| /// Represents the major class of a device as defined by the Bluetooth specification: |
| /// https://www.bluetooth.com/specifications/assigned-numbers/baseband |
| pub enum MajorClass { |
| Miscellaneous = 0b00000, |
| Computer = 0b00001, |
| Phone = 0b00010, |
| Lan = 0b00011, |
| AudioVideo = 0b00100, |
| Peripheral = 0b00101, |
| Imaging = 0b00110, |
| Wearable = 0b00111, |
| Toy = 0b01000, |
| Health = 0b01001, |
| Uncategorized = 0b11111, |
| } |
| |
| impl TryInto<MajorClass> for &str { |
| fn try_into(self) -> Result<MajorClass, Error> { |
| Ok(match &*self.to_uppercase() { |
| "MISCELLANEOUS" => MajorClass::Miscellaneous, |
| "COMPUTER" => MajorClass::Computer, |
| "PHONE" => MajorClass::Phone, |
| "LAN" => MajorClass::Lan, |
| "AUDIOVIDEO" => MajorClass::AudioVideo, |
| "PERIPHERAL" => MajorClass::Peripheral, |
| "IMAGING" => MajorClass::Imaging, |
| "WEARABLE" => MajorClass::Wearable, |
| "TOY" => MajorClass::Toy, |
| "HEALTH" => MajorClass::Health, |
| "UNCATEGORIZED" => MajorClass::Uncategorized, |
| v => bail!("Invalid Major Class value provided: '{}'", v), |
| }) |
| } |
| } |
| |
| /// Represents the minor class associated with a device. The meaning of the minor class value |
| /// depends on the major class of the device. Values defined in the Bluetooth specification: |
| /// https://www.bluetooth.com/specifications/assigned-numbers/baseband |
| pub struct MinorClass(u32); |
| |
| impl MinorClass { |
| pub fn not_set() -> MinorClass { |
| MinorClass(0) |
| } |
| } |
| |
| impl TryInto<MinorClass> for &str { |
| fn try_into(self) -> Result<MinorClass, Error> { |
| let value = self.parse()?; |
| if value > 0b11_1111 { |
| bail!("Invalid Minor Class value (number too large)") |
| } |
| Ok(MinorClass(value)) |
| } |
| } |
| |
| /// Represents the complete list of service classes assigned to a device. Values defined in the |
| /// Bluetooth specification: https://www.bluetooth.com/specifications/assigned-numbers/baseband |
| pub struct ServiceClass(u32); |
| |
| impl ServiceClass { |
| const LIMITED_DISCOVERABLE_MODE: u32 = 1; |
| const POSITIONING: u32 = 1 << 3; |
| const NETWORKING: u32 = 1 << 4; |
| const RENDERING: u32 = 1 << 5; |
| const CAPTURING: u32 = 1 << 6; |
| const OBJECT_TRANSFER: u32 = 1 << 7; |
| const AUDIO: u32 = 1 << 8; |
| const TELEPHONY: u32 = 1 << 9; |
| const INFORMATION: u32 = 1 << 10; |
| } |
| |
| // Construct a `ServiceClass` from an `Iterator` over `&str` values |
| impl<'a, I> TryInto<ServiceClass> for I |
| where |
| I: Iterator<Item = &'a &'a str>, |
| { |
| fn try_into(self) -> Result<ServiceClass, Error> { |
| let mut invalid_inputs = vec![]; |
| let mut class_value = 0; |
| for input in self { |
| let value = match &*input.to_uppercase() { |
| "LIMITED_DISCOVERABLE_MODE" => ServiceClass::LIMITED_DISCOVERABLE_MODE, |
| "POSITIONING" => ServiceClass::POSITIONING, |
| "NETWORKING" => ServiceClass::NETWORKING, |
| "RENDERING" => ServiceClass::RENDERING, |
| "CAPTURING" => ServiceClass::CAPTURING, |
| "OBJECT_TRANSFER" => ServiceClass::OBJECT_TRANSFER, |
| "AUDIO" => ServiceClass::AUDIO, |
| "TELEPHONY" => ServiceClass::TELEPHONY, |
| "INFORMATION" => ServiceClass::INFORMATION, |
| _ => { |
| invalid_inputs.push(input); |
| continue; |
| } |
| }; |
| class_value |= value; |
| } |
| if !invalid_inputs.is_empty() { |
| bail!("Invalid Service Class value(s) provided: {:?}", invalid_inputs); |
| } |
| Ok(ServiceClass(class_value)) |
| } |
| } |
| |
| pub struct DeviceClass { |
| pub major: MajorClass, |
| pub minor: MinorClass, |
| pub service: ServiceClass, |
| } |
| |
| impl From<DeviceClass> for fidl_control::DeviceClass { |
| fn from(cod: DeviceClass) -> Self { |
| let value = (cod.minor.0 & 0b11_1111) << 2 // bits [2,7] represent the minor class |
| | (((cod.major as u32) & 0b1_1111) << 8) // bits [8,12] represent the major class |
| | (cod.service.0 & 0b111_1111_1111) << 13; // bits [13,23] represent the service class |
| fidl_control::DeviceClass { value } |
| } |
| } |
