use crate::server::Facade;
use anyhow::{format_err, Error};
use async_trait::async_trait;
use bt_rfcomm::ServerChannel;
use fidl_fuchsia_bluetooth::PeerId;
use fidl_fuchsia_bluetooth_a2dp::Role;
use fidl_fuchsia_bluetooth_hfp::{CallDirection, CallState, NetworkInformation, SignalStrength};
use fidl_fuchsia_bluetooth_le::Filter;
use fidl_fuchsia_bluetooth_sys::{LeSecurityMode, Settings};
use serde_json::{from_value, to_value, Value};
use test_call_manager::TestCallManager as HfpFacade;
use test_rfcomm_client::RfcommManager as RfcommFacade;
use crate::bluetooth::a2dp_facade::A2dpFacade;
use crate::bluetooth::avdtp_facade::AvdtpFacade;
use crate::bluetooth::avrcp_facade::AvrcpFacade;
use crate::bluetooth::ble_advertise_facade::BleAdvertiseFacade;
use crate::bluetooth::bt_sys_facade::BluetoothSysFacade;
use crate::bluetooth::gatt_client_facade::GattClientFacade;
use crate::bluetooth::gatt_server_facade::GattServerFacade;
use crate::bluetooth::profile_server_facade::ProfileServerFacade;
use crate::bluetooth::types::{
AbsoluteVolumeCommand, BleAdvertiseResponse, BleConnectPeripheralResponse, CustomBatteryStatus,
CustomNotificationsFilter, CustomPlayerApplicationSettings,
CustomPlayerApplicationSettingsAttributeIds, FacadeArg, GattcDiscoverCharacteristicResponse,
};
use crate::common_utils::common::{
parse_identifier, parse_identifier_as_u64, parse_max_bytes, parse_offset, parse_psm,
parse_service_identifier, parse_u64_identifier, parse_write_value,
};
use crate::common_utils::common::macros::parse_arg;
#[async_trait(?Send)]
impl Facade for BleAdvertiseFacade {
async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
let id = to_value(BleAdvertiseResponse::new(Some("singleton-instance".to_string())))?;
match method.as_ref() {
"BleAdvertise" => {
self.start_adv(args).await?;
}
"BleStopAdvertise" => {
self.stop_adv();
}
_ => return Err(format_err!("Invalid BleAdvertise FIDL method: {:?}", method)),
};
Ok(id)
}
fn cleanup(&self) {
Self::cleanup(self)
}
fn print(&self) {
Self::print(self)
}
}
#[async_trait(?Send)]
impl Facade for BluetoothSysFacade {
async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
match method.as_ref() {
"BluetoothAcceptPairing" => {
let input = parse_arg!(args, as_str, "input")?;
let output = parse_arg!(args, as_str, "output")?;
let result = self.accept_pairing(&input.to_string(), &output.to_string()).await?;
Ok(to_value(result)?)
}
"BluetoothInitSys" => {
let result = self.init_access_proxy().await?;
Ok(to_value(result)?)
}
"BluetoothGetKnownRemoteDevices" => {
let result = self.get_known_remote_devices().await?;
Ok(to_value(result)?)
}
"BluetoothSetDiscoverable" => {
let discoverable = parse_arg!(args, as_bool, "discoverable")?;
let result = self.set_discoverable(discoverable).await?;
Ok(to_value(result)?)
}
"BluetoothSetName" => {
let name = parse_arg!(args, as_str, "name")?;
let result = self.set_name(name.to_string()).await?;
Ok(to_value(result)?)
}
"BluetoothForgetDevice" => {
let identifier = parse_identifier_as_u64(&args)?;
let result = self.forget(identifier).await?;
Ok(to_value(result)?)
}
"BluetoothConnectDevice" => {
let identifier = parse_identifier_as_u64(&args)?;
let result = self.connect(identifier).await?;
Ok(to_value(result)?)
}
"BluetoothDisconnectDevice" => {
let identifier = parse_identifier_as_u64(&args)?;
let result = self.disconnect(identifier).await?;
Ok(to_value(result)?)
}
"BluetoothRequestDiscovery" => {
let discovery = parse_arg!(args, as_bool, "discovery")?;
let result = self.start_discovery(discovery).await?;
Ok(to_value(result)?)
}
"BluetoothInputPairingPin" => {
let pin = parse_arg!(args, as_str, "pin")?;
let result = self.input_pairing_pin(pin.to_string()).await?;
Ok(to_value(result)?)
}
"BluetoothGetPairingPin" => {
let result = self.get_pairing_pin().await?;
Ok(to_value(result)?)
}
"BluetoothGetActiveAdapterAddress" => {
let result = self.get_active_adapter_address().await?;
Ok(to_value(result)?)
}
"BluetoothPairDevice" => {
let identifier = parse_identifier_as_u64(&args)?;
let pairing_security_level =
match parse_arg!(args, as_u64, "pairing_security_level") {
Ok(v) => Some(v),
Err(_e) => None,
};
let non_bondable = match parse_arg!(args, as_bool, "non_bondable") {
Ok(v) => Some(v),
Err(_e) => None,
};
let transport = parse_arg!(args, as_u64, "transport")?;
let result =
self.pair(identifier, pairing_security_level, non_bondable, transport).await?;
Ok(to_value(result)?)
}
"BluetoothUpdateSystemSettings" => {
let le_privacy = parse_arg!(args, as_bool, "le_privacy").ok();
let le_background_scan = parse_arg!(args, as_bool, "le_background_scan").ok();
let bredr_connectable_mode =
parse_arg!(args, as_bool, "bredr_connectable_mode").ok();
let le_security_mode = if let Ok(s) = parse_arg!(args, as_str, "le_security_mode") {
match s.to_uppercase().as_ref() {
"MODE_1" => Some(LeSecurityMode::Mode1),
"SECURE_CONNECTIONS_ONLY" => Some(LeSecurityMode::SecureConnectionsOnly),
_ => bail!(
"Invalid le_security_mode {} passed to BluetoothUpdateSystemSettings",
s
),
}
} else {
None
};
let result = self
.update_settings(Settings {
le_privacy,
le_background_scan,
bredr_connectable_mode,
le_security_mode,
..Default::default()
})
.await?;
Ok(to_value(result)?)
}
_ => bail!("Invalid Bluetooth control FIDL method: {:?}", method),
}
}
fn cleanup(&self) {
Self::cleanup(self)
}
fn print(&self) {
Self::print(self)
}
}
#[async_trait(?Send)]
impl Facade for GattClientFacade {
async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
match method.as_ref() {
"BleStartScan" => {
let scan_filter = FacadeArg::new(args);
start_scan_async(&self, Some(scan_filter.try_into()?)).await
}
"BleStopScan" => stop_scan_async(self).await,
"BleGetDiscoveredDevices" => le_get_discovered_devices_async(self).await,
"BleConnectPeripheral" => {
let id = parse_identifier(args)?;
connect_peripheral_async(self, id).await
}
"BleDisconnectPeripheral" => {
let id = parse_identifier(args)?;
disconnect_peripheral_async(self, id).await
}
"GattcConnectToService" => {
let periph_id = parse_identifier(args.clone())?;
let service_id = parse_service_identifier(args)?;
gattc_connect_to_service_async(self, periph_id, service_id).await
}
"GattcDiscoverCharacteristics" => gattc_discover_characteristics_async(self).await,
"GattcWriteCharacteristicById" => {
let id = parse_u64_identifier(args.clone())?;
let value = parse_write_value(args)?;
gattc_write_char_by_id_async(self, id, value).await
}
"GattcWriteLongCharacteristicById" => {
let id = parse_u64_identifier(args.clone())?;
let offset_as_u64 = parse_offset(args.clone())?;
let offset = offset_as_u64 as u16;
let value = parse_write_value(args.clone())?;
let reliable_mode = parse_arg!(args, as_bool, "reliable_mode")?;
gattc_write_long_char_by_id_async(self, id, offset, value, reliable_mode).await
}
"GattcWriteCharacteristicByIdWithoutResponse" => {
let id = parse_u64_identifier(args.clone())?;
let value = parse_write_value(args)?;
gattc_write_char_by_id_without_response_async(self, id, value).await
}
"GattcEnableNotifyCharacteristic" => {
let id = parse_u64_identifier(args.clone())?;
gattc_toggle_notify_characteristic_async(self, id, true).await
}
"GattcDisableNotifyCharacteristic" => {
let id = parse_u64_identifier(args.clone())?;
gattc_toggle_notify_characteristic_async(self, id, false).await
}
"GattcReadCharacteristicById" => {
let id = parse_u64_identifier(args.clone())?;
gattc_read_char_by_id_async(self, id).await
}
"GattcReadCharacteristicByType" => {
let uuid = parse_arg!(args, as_str, "uuid")?;
let result = self.gattc_read_char_by_type(uuid.to_string()).await?;
Ok(to_value(result)?)
}
"GattcReadLongCharacteristicById" => {
let id = parse_u64_identifier(args.clone())?;
let offset_as_u64 = parse_offset(args.clone())?;
let offset = offset_as_u64 as u16;
let max_bytes_as_u64 = parse_max_bytes(args)?;
let max_bytes = max_bytes_as_u64 as u16;
gattc_read_long_char_by_id_async(self, id, offset, max_bytes).await
}
"GattcReadLongDescriptorById" => {
let id = parse_u64_identifier(args.clone())?;
let offset_as_u64 = parse_offset(args.clone())?;
let offset = offset_as_u64 as u16;
let max_bytes_as_u64 = parse_max_bytes(args)?;
let max_bytes = max_bytes_as_u64 as u16;
gattc_read_long_desc_by_id_async(self, id, offset, max_bytes).await
}
"GattcWriteDescriptorById" => {
let id = parse_u64_identifier(args.clone())?;
let value = parse_write_value(args)?;
gattc_write_desc_by_id_async(self, id, value).await
}
"GattcWriteLongDescriptorById" => {
let id = parse_u64_identifier(args.clone())?;
let offset_as_u64 = parse_offset(args.clone())?;
let offset = offset_as_u64 as u16;
let value = parse_write_value(args)?;
gattc_write_long_desc_by_id_async(self, id, offset, value).await
}
"GattcReadDescriptorById" => {
let id = parse_u64_identifier(args.clone())?;
gattc_read_desc_by_id_async(self, id.clone()).await
}
"GattcListServices" => {
let id = parse_identifier(args)?;
list_services_async(self, id).await
}
_ => return Err(format_err!("Invalid Gatt Client FIDL method: {:?}", method)),
}
}
fn cleanup(&self) {
Self::cleanup(self)
}
fn print(&self) {
Self::print(self)
}
}
#[async_trait(?Send)]
impl Facade for GattServerFacade {
async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
match method.as_ref() {
"GattServerPublishServer" => {
let result = self.publish_server(args).await?;
Ok(to_value(result)?)
}
"GattServerCloseServer" => {
let result = self.close_server().await;
Ok(to_value(result)?)
}
_ => return Err(format_err!("Invalid Gatt Server FIDL method: {:?}", method)),
}
}
fn cleanup(&self) {
Self::cleanup(self)
}
fn print(&self) {
Self::print(self)
}
}
#[async_trait(?Send)]
impl Facade for ProfileServerFacade {
async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
match method.as_ref() {
"ProfileServerInit" => {
let result = self.init_profile_server_proxy().await?;
Ok(to_value(result)?)
}
"ProfileServerAddSearch" => {
let result = self.add_search(args).await?;
Ok(to_value(result)?)
}
"ProfileServerAddService" => {
let result = self.add_service(args).await?;
Ok(to_value(result)?)
}
"ProfileServerCleanup" => {
let result = self.cleanup().await?;
Ok(to_value(result)?)
}
"ProfileServerConnectL2cap" => {
let id = parse_identifier(args.clone())?;
let psm = parse_psm(args.clone())?;
let mode = parse_arg!(args, as_str, "mode")?;
let result = self.connect(id, psm as u16, &mode.to_string()).await?;
Ok(to_value(result)?)
}
"ProfileServerRemoveService" => {
let service_id = parse_u64_identifier(args)? as usize;
let result = self.remove_service(service_id).await?;
Ok(to_value(result)?)
}
_ => return Err(format_err!("Invalid Profile Server FIDL method: {:?}", method)),
}
}
}
#[async_trait(?Send)]
impl Facade for AvdtpFacade {
async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
match method.as_ref() {
"AvdtpInit" => {
let initiator_delay = match parse_arg!(args, as_str, "initiator_delay") {
Ok(v) => Some(v.to_string()),
Err(_e) => None,
};
let result = self.init_avdtp_service_proxy(initiator_delay).await?;
Ok(to_value(result)?)
}
"AvdtpGetConnectedPeers" => {
let result = self.get_connected_peers().await?;
Ok(to_value(result)?)
}
"AvdtpSetConfiguration" => {
let peer_id = parse_u64_identifier(args)?;
let result = self.set_configuration(peer_id).await?;
Ok(to_value(result)?)
}
"AvdtpGetConfiguration" => {
let peer_id = parse_u64_identifier(args)?;
let result = self.get_configuration(peer_id).await?;
Ok(to_value(result)?)
}
"AvdtpGetCapabilities" => {
let peer_id = parse_u64_identifier(args)?;
let result = self.get_capabilities(peer_id).await?;
Ok(to_value(result)?)
}
"AvdtpGetAllCapabilities" => {
let peer_id = parse_u64_identifier(args)?;
let result = self.get_all_capabilities(peer_id).await?;
Ok(to_value(result)?)
}
"AvdtpReconfigureStream" => {
let peer_id = parse_u64_identifier(args)?;
let result = self.reconfigure_stream(peer_id).await?;
Ok(to_value(result)?)
}
"AvdtpSuspendStream" => {
let peer_id = parse_u64_identifier(args)?;
let result = self.suspend_stream(peer_id).await?;
Ok(to_value(result)?)
}
"AvdtpSuspendAndReconfigure" => {
let peer_id = parse_u64_identifier(args)?;
let result = self.suspend_and_reconfigure(peer_id).await?;
Ok(to_value(result)?)
}
"AvdtpReleaseStream" => {
let peer_id = parse_u64_identifier(args)?;
let result = self.release_stream(peer_id).await?;
Ok(to_value(result)?)
}
"AvdtpEstablishStream" => {
let peer_id = parse_u64_identifier(args)?;
let result = self.establish_stream(peer_id).await?;
Ok(to_value(result)?)
}
"AvdtpStartStream" => {
let peer_id = parse_u64_identifier(args)?;
let result = self.start_stream(peer_id).await?;
Ok(to_value(result)?)
}
"AvdtpAbortStream" => {
let peer_id = parse_u64_identifier(args)?;
let result = self.abort_stream(peer_id).await?;
Ok(to_value(result)?)
}
"AvdtpRemoveService" => {
let result = self.remove_service().await;
Ok(to_value(result)?)
}
_ => bail!("Invalid AVDTP FIDL method: {:?}", method),
}
}
}
#[async_trait(?Send)]
impl Facade for A2dpFacade {
async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
match method.as_ref() {
"A2dpSetRole" => {
let a2dp_role = if let Ok(s) = parse_arg!(args, as_str, "a2dp_role") {
match s.to_uppercase().as_ref() {
"SOURCE" => Role::Source,
"SINK" => Role::Sink,
_ => bail!("Invalid A2DP role {} passed to A2dpSetRole", s),
}
} else {
bail!("Could not parse A2DP role passed to A2dpSetRole")
};
self.init_audio_mode_proxy().await?;
let result = self.set_role(a2dp_role).await?;
Ok(to_value(result)?)
}
_ => {
bail!("Invalid A2DP FIDL method: {:?}", method)
}
}
}
}
#[async_trait(?Send)]
impl Facade for AvrcpFacade {
async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
match method.as_ref() {
"AvrcpInit" => {
let target_id = parse_arg!(args, as_str, "target_id")?;
let target_id = target_id.parse::<u64>()?;
let result = self.init_avrcp(target_id).await?;
Ok(to_value(result)?)
}
"AvrcpGetMediaAttributes" => {
let result = self.get_media_attributes().await?;
Ok(to_value(result)?)
}
"AvrcpGetPlayStatus" => {
let result = self.get_play_status().await?;
Ok(to_value(result)?)
}
"AvrcpGetPlayerApplicationSettings" => {
let attribute_ids: CustomPlayerApplicationSettingsAttributeIds =
match from_value(args.clone()) {
Ok(attribute_ids) => attribute_ids,
_ => bail!(
"Invalid json argument to AvrcpGetPlayerApplicationSettings! - {}",
args
),
};
let result = self.get_player_application_settings(attribute_ids.clone()).await?;
Ok(to_value(result)?)
}
"AvrcpInformBatteryStatus" => {
let battery_status: CustomBatteryStatus = match from_value(args.clone()) {
Ok(battery_status) => battery_status,
_ => bail!("Invalid json argument to AvrcpInformBatteryStatus! - {}", args),
};
let result = self.inform_battery_status(battery_status.clone()).await?;
Ok(to_value(result)?)
}
"AvrcpNotifyNotificationHandled" => {
let result = self.notify_notification_handled().await?;
Ok(to_value(result)?)
}
"AvrcpSetAddressedPlayer" => {
let player_id: u16 = match from_value(args.clone()) {
Ok(settings) => settings,
_ => bail!("Invalid json argument to AvrcpSetAddressedPlayer! - {}", args),
};
let result = self.set_addressed_player(player_id.clone()).await?;
Ok(to_value(result)?)
}
"AvrcpSetPlayerApplicationSettings" => {
let settings: CustomPlayerApplicationSettings = match from_value(args.clone()) {
Ok(settings) => settings,
_ => bail!(
"Invalid json argument to AvrcpSetPlayerApplicationSettings! - {}",
args
),
};
let result = self.set_player_application_settings(settings.clone()).await?;
Ok(to_value(result)?)
}
"AvrcpSendCommand" => {
let command_str = parse_arg!(args, as_str, "command")?;
let result = self.send_command(command_str.to_string().into()).await?;
Ok(to_value(result)?)
}
"AvrcpSetAbsoluteVolume" => {
let absolute_volume_command: AbsoluteVolumeCommand = match from_value(args.clone())
{
Ok(absolute_volume) => absolute_volume,
_ => bail!("Invalid json argument to AvrcpSetAbsoluteVolume! - {}", args),
};
let result =
self.set_absolute_volume(absolute_volume_command.absolute_volume).await?;
Ok(to_value(result)?)
}
"AvrcpSetNotificationFilter" => {
let custom_notifications: CustomNotificationsFilter = match from_value(args.clone())
{
Ok(custom_notifications) => custom_notifications,
_ => bail!("Invalid json argument to AvrcpSetNotificationFilter! - {}", args),
};
let result = self
.set_notification_filter(
custom_notifications.notifications,
match custom_notifications.position_change_interval {
Some(position_change_interval) => position_change_interval,
_ => 0,
},
)
.await?;
Ok(to_value(result)?)
}
_ => bail!("Invalid AVRCP FIDL method: {:?}", method),
}
}
fn cleanup(&self) {}
fn print(&self) {}
}
async fn start_scan_async(
facade: &GattClientFacade,
filter: Option<Filter>,
) -> Result<Value, Error> {
let start_scan_result = facade.start_scan(filter).await?;
Ok(to_value(start_scan_result)?)
}
async fn stop_scan_async(facade: &GattClientFacade) -> Result<Value, Error> {
facade.stop_scan().await?;
let devices = facade.get_scan_responses();
match to_value(devices) {
Ok(dev) => Ok(dev),
Err(e) => Err(e.into()),
}
}
async fn le_get_discovered_devices_async(facade: &GattClientFacade) -> Result<Value, Error> {
match to_value(facade.get_scan_responses()) {
Ok(dev) => Ok(dev),
Err(e) => Err(e.into()),
}
}
async fn connect_peripheral_async(facade: &GattClientFacade, id: String) -> Result<Value, Error> {
let connect_periph_result = facade.connect_peripheral(id).await?;
Ok(to_value(connect_periph_result)?)
}
async fn disconnect_peripheral_async(
facade: &GattClientFacade,
id: String,
) -> Result<Value, Error> {
let value = facade.disconnect_peripheral(id).await?;
Ok(to_value(value)?)
}
async fn list_services_async(facade: &GattClientFacade, id: String) -> Result<Value, Error> {
let list_services_result = facade.list_services(id).await?;
Ok(to_value(BleConnectPeripheralResponse::new(list_services_result))?)
}
async fn gattc_connect_to_service_async(
facade: &GattClientFacade,
periph_id: String,
service_id: u64,
) -> Result<Value, Error> {
let connect_to_service_result = facade.gattc_connect_to_service(periph_id, service_id).await?;
Ok(to_value(connect_to_service_result)?)
}
async fn gattc_discover_characteristics_async(facade: &GattClientFacade) -> Result<Value, Error> {
let discover_characteristics_results = facade.gattc_discover_characteristics().await?;
Ok(to_value(GattcDiscoverCharacteristicResponse::new(discover_characteristics_results))?)
}
async fn gattc_write_char_by_id_async(
facade: &GattClientFacade,
id: u64,
write_value: Vec<u8>,
) -> Result<Value, Error> {
let write_char_status = facade.gattc_write_char_by_id(id, write_value).await?;
Ok(to_value(write_char_status)?)
}
async fn gattc_write_long_char_by_id_async(
facade: &GattClientFacade,
id: u64,
offset: u16,
write_value: Vec<u8>,
reliable_mode: bool,
) -> Result<Value, Error> {
let write_char_status =
facade.gattc_write_long_char_by_id(id, offset, write_value, reliable_mode).await?;
Ok(to_value(write_char_status)?)
}
async fn gattc_write_char_by_id_without_response_async(
facade: &GattClientFacade,
id: u64,
write_value: Vec<u8>,
) -> Result<Value, Error> {
let write_char_status = facade.gattc_write_char_by_id_without_response(id, write_value).await?;
Ok(to_value(write_char_status)?)
}
async fn gattc_read_char_by_id_async(facade: &GattClientFacade, id: u64) -> Result<Value, Error> {
let read_char_status = facade.gattc_read_char_by_id(id).await?;
Ok(to_value(read_char_status)?)
}
async fn gattc_read_long_char_by_id_async(
facade: &GattClientFacade,
id: u64,
offset: u16,
max_bytes: u16,
) -> Result<Value, Error> {
let read_long_char_status = facade.gattc_read_long_char_by_id(id, offset, max_bytes).await?;
Ok(to_value(read_long_char_status)?)
}
async fn gattc_read_long_desc_by_id_async(
facade: &GattClientFacade,
id: u64,
offset: u16,
max_bytes: u16,
) -> Result<Value, Error> {
let read_long_desc_status = facade.gattc_read_long_desc_by_id(id, offset, max_bytes).await?;
Ok(to_value(read_long_desc_status)?)
}
async fn gattc_read_desc_by_id_async(facade: &GattClientFacade, id: u64) -> Result<Value, Error> {
let read_desc_status = facade.gattc_read_desc_by_id(id).await?;
Ok(to_value(read_desc_status)?)
}
async fn gattc_write_desc_by_id_async(
facade: &GattClientFacade,
id: u64,
write_value: Vec<u8>,
) -> Result<Value, Error> {
let write_desc_status = facade.gattc_write_desc_by_id(id, write_value).await?;
Ok(to_value(write_desc_status)?)
}
async fn gattc_write_long_desc_by_id_async(
facade: &GattClientFacade,
id: u64,
offset: u16,
write_value: Vec<u8>,
) -> Result<Value, Error> {
let write_desc_status = facade.gattc_write_long_desc_by_id(id, offset, write_value).await?;
Ok(to_value(write_desc_status)?)
}
async fn gattc_toggle_notify_characteristic_async(
facade: &GattClientFacade,
id: u64,
value: bool,
) -> Result<Value, Error> {
let toggle_notify_result = facade.gattc_toggle_notify_characteristic(id, value).await?;
Ok(to_value(toggle_notify_result)?)
}
#[async_trait(?Send)]
impl Facade for HfpFacade {
async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
match method.as_ref() {
"HfpInit" => {
let result = self.init_hfp_service().await?;
Ok(to_value(result)?)
}
"HfpRemoveService" => {
self.cleanup().await;
Ok(to_value(())?)
}
"ListPeers" => {
let result = self.list_peers().await?;
Ok(to_value(result)?)
}
"SetActivePeer" => {
let id = parse_arg!(args, as_u64, "peer_id")?;
let result = self.set_active_peer(id).await?;
Ok(to_value(result)?)
}
"ListCalls" => {
let result = self.list_calls().await?;
Ok(to_value(result)?)
}
"NewCall" => {
let remote = parse_arg!(args, as_str, "remote")?;
let state = parse_arg!(args, as_str, "state")?.to_lowercase();
let state = match &*state {
"ringing" => CallState::IncomingRinging,
"waiting" => CallState::IncomingWaiting,
"dialing" => CallState::OutgoingDialing,
"alerting" => CallState::OutgoingAlerting,
"active" => CallState::OngoingActive,
"held" => CallState::OngoingHeld,
_ => bail!("Invalid state argument: {}", state),
};
let direction = parse_arg!(args, as_str, "direction")?;
let direction = match &*direction {
"incoming" => CallDirection::MobileTerminated,
"outgoing" => CallDirection::MobileOriginated,
_ => bail!("Invalid direction argument: {}", direction),
};
let result = self.new_call(&remote, state, direction).await?;
Ok(to_value(result)?)
}
"IncomingCall" => {
let remote = parse_arg!(args, as_str, "remote")?;
let result = self.incoming_ringing_call(&remote).await?;
Ok(to_value(result)?)
}
"IncomingWaitingCall" => {
let remote = parse_arg!(args, as_str, "remote")?;
let result = self.incoming_waiting_call(&remote).await?;
Ok(to_value(result)?)
}
"OutgoingCall" => {
let remote = parse_arg!(args, as_str, "remote")?;
let result = self.outgoing_call(&remote).await?;
Ok(to_value(result)?)
}
"SetCallActive" => {
let call_id = parse_arg!(args, as_u64, "call_id")?;
let result = self.set_call_active(call_id).await?;
Ok(to_value(result)?)
}
"SetCallHeld" => {
let call_id = parse_arg!(args, as_u64, "call_id")?;
let result = self.set_call_held(call_id).await?;
Ok(to_value(result)?)
}
"SetCallTerminated" => {
let call_id = parse_arg!(args, as_u64, "call_id")?;
let result = self.set_call_terminated(call_id).await?;
Ok(to_value(result)?)
}
"SetCallTransferredToAg" => {
let call_id = parse_arg!(args, as_u64, "call_id")?;
let result = self.set_call_transferred_to_ag(call_id).await?;
Ok(to_value(result)?)
}
"SetSpeakerGain" => {
let value = parse_arg!(args, as_u64, "value")?;
let result = self.set_speaker_gain(value).await?;
Ok(to_value(result)?)
}
"SetMicrophoneGain" => {
let value = parse_arg!(args, as_u64, "value")?;
let result = self.set_microphone_gain(value).await?;
Ok(to_value(result)?)
}
"SetServiceAvailable" => {
let service_available = Some(parse_arg!(args, as_bool, "value")?);
let result = self
.update_network_information(NetworkInformation {
service_available,
..Default::default()
})
.await?;
Ok(to_value(result)?)
}
"SetRoaming" => {
let roaming = Some(parse_arg!(args, as_bool, "value")?);
let result = self
.update_network_information(NetworkInformation {
roaming,
..Default::default()
})
.await?;
Ok(to_value(result)?)
}
"SetSignalStrength" => {
let signal_strength = parse_arg!(args, as_u64, "value")?;
let signal_strength = Some(match signal_strength {
0 => SignalStrength::None,
1 => SignalStrength::VeryLow,
2 => SignalStrength::Low,
3 => SignalStrength::Medium,
4 => SignalStrength::High,
5 => SignalStrength::VeryHigh,
_ => panic!(""),
});
let result = self
.update_network_information(NetworkInformation {
signal_strength,
..Default::default()
})
.await?;
Ok(to_value(result)?)
}
"SetSubscriberNumber" => {
let number = parse_arg!(args, as_str, "value")?;
self.set_subscriber_number(number).await;
Ok(to_value(())?)
}
"SetOperator" => {
let value = parse_arg!(args, as_str, "value")?;
self.set_operator(value).await;
Ok(to_value(())?)
}
"SetNrecSupport" => {
let support = parse_arg!(args, as_bool, "value")?;
self.set_nrec_support(support).await;
Ok(to_value(())?)
}
"SetBatteryLevel" => {
let level = parse_arg!(args, as_u64, "value")?;
self.set_battery_level(level).await?;
Ok(to_value(())?)
}
"SetLastDialed" => {
let number = parse_arg!(args, as_str, "number")?.to_string();
self.set_last_dialed(Some(number)).await;
Ok(to_value(())?)
}
"ClearLastDialed" => {
self.set_last_dialed(None).await;
Ok(to_value(())?)
}
"SetMemoryLocation" => {
let location = parse_arg!(args, as_str, "location")?.to_string();
let number = parse_arg!(args, as_str, "number")?.to_string();
self.set_memory_location(location, Some(number)).await;
Ok(to_value(())?)
}
"ClearMemoryLocation" => {
let location = parse_arg!(args, as_str, "location")?.to_string();
self.set_memory_location(location, None).await;
Ok(to_value(())?)
}
"SetDialResult" => {
let number = parse_arg!(args, as_str, "number")?.to_string();
let status = parse_arg!(args, as_i64, "status")?.try_into()?;
let status = fuchsia_zircon::Status::from_raw(status);
self.set_dial_result(number, status).await;
Ok(to_value(())?)
}
"GetState" => {
let result = self.get_state().await;
Ok(to_value(result)?)
}
"SetConnectionBehavior" => {
let autoconnect = parse_arg!(args, as_bool, "autoconnect")?;
self.set_connection_behavior(autoconnect).await?;
Ok(to_value(())?)
}
_ => bail!("Invalid Hfp FIDL method: {:?}", method),
}
}
}
#[async_trait(?Send)]
impl Facade for RfcommFacade {
async fn handle_request(&self, method: String, args: Value) -> Result<Value, Error> {
match method.as_ref() {
"RfcommInit" => {
let result = self.advertise()?;
Ok(to_value(result)?)
}
"RfcommRemoveService" => {
let result = self.clear_services();
Ok(to_value(result)?)
}
"DisconnectSession" => {
let id = PeerId { value: parse_arg!(args, as_u64, "peer_id")? };
let result = self.close_session(id.into())?;
Ok(to_value(result)?)
}
"ConnectRfcommChannel" => {
let id = PeerId { value: parse_arg!(args, as_u64, "peer_id")? };
let channel_number = parse_arg!(args, as_u64, "server_channel_number")?;
let channel_number = ServerChannel::try_from(u8::try_from(channel_number)?)?;
let result = self.outgoing_rfcomm_channel(id.into(), channel_number).await?;
Ok(to_value(result)?)
}
"DisconnectRfcommChannel" => {
let id = PeerId { value: parse_arg!(args, as_u64, "peer_id")? };
let channel_number = parse_arg!(args, as_u64, "server_channel_number")?;
let channel_number = ServerChannel::try_from(u8::try_from(channel_number)?)?;
let result = self.close_rfcomm_channel(id.into(), channel_number)?;
Ok(to_value(result)?)
}
"SendRemoteLineStatus" => {
let id = PeerId { value: parse_arg!(args, as_u64, "peer_id")? };
let channel_number = parse_arg!(args, as_u64, "server_channel_number")?;
let channel_number = ServerChannel::try_from(u8::try_from(channel_number)?)?;
let result = self.send_rls(id.into(), channel_number)?;
Ok(to_value(result)?)
}
"RfcommWrite" => {
let id = PeerId { value: parse_arg!(args, as_u64, "peer_id")? };
let channel_number = parse_arg!(args, as_u64, "server_channel_number")?;
let channel_number = ServerChannel::try_from(u8::try_from(channel_number)?)?;
let data = parse_arg!(args, as_str, "data")?.to_string();
let result = self.send_user_data(id.into(), channel_number, data.into_bytes())?;
Ok(to_value(result)?)
}
_ => bail!("Invalid RFCOMM method: {:?}", method),
}
}
}