src/testing/sl4f/src/bluetooth/avrcp_facade.rs - fuchsia - Git at Google

 // Copyright 2021 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 super::types::{
     CustomAvcPanelCommand, CustomBatteryStatus, CustomPlayStatus, CustomPlayerApplicationSettings,
     CustomPlayerApplicationSettingsAttributeIds,
 };
 use crate::common_utils::common::macros::{fx_err_and_bail, with_line};
 use anyhow::Error;
 use fidl::endpoints::create_endpoints;
 use fidl_fuchsia_bluetooth::PeerId;
 use fidl_fuchsia_bluetooth_avrcp::{
     ControllerMarker, ControllerProxy, Notifications, PeerManagerMarker, PeerManagerProxy,
 };
 use fuchsia_component::client;
 use fuchsia_sync::RwLock;
 use tracing::info;
 /// AvrcpFacadeInner contains the proxies used by the AvrcpFacade.
 #[derive(Debug)]
 struct AvrcpFacadeInner {
     /// Proxy for the PeerManager service.
     avrcp_service_proxy: Option<PeerManagerProxy>,
     /// Proxy for the Controller service.
     controller_proxy: Option<ControllerProxy>,
 }

 #[derive(Debug)]
 pub struct AvrcpFacade {
     inner: RwLock<AvrcpFacadeInner>,
 }

 impl AvrcpFacade {
     pub fn new() -> AvrcpFacade {
         AvrcpFacade {
             inner: RwLock::new(AvrcpFacadeInner {
                 avrcp_service_proxy: None,
                 controller_proxy: None,
             }),
         }
     }

     /// Creates the proxy to the PeerManager service.
     async fn create_avrcp_service_proxy(&self) -> Result<PeerManagerProxy, Error> {
         let tag = "AvrcpFacade::create_avrcp_service_proxy";
         match self.inner.read().avrcp_service_proxy.clone() {
             Some(avrcp_service_proxy) => {
                 info!(
                     tag = &with_line!(tag),
                     "Current AVRCP service proxy: {:?}", avrcp_service_proxy
                 );
                 Ok(avrcp_service_proxy)
             }
             None => {
                 let avrcp_service_proxy = client::connect_to_protocol::<PeerManagerMarker>();
                 if let Err(err) = avrcp_service_proxy {
                     fx_err_and_bail!(
                         &with_line!(tag),
                         format_err!("Failed to create AVRCP service proxy: {}", err)
                     );
                 }
                 avrcp_service_proxy
             }
         }
     }

     /// Initialize the AVRCP service and retrieve the controller for the provided Bluetooth target id.
     ///
     /// # Arguments
     /// * `id` - A u64 representing the device ID.
     pub async fn init_avrcp(&self, id: u64) -> Result<(), Error> {
         let tag = "AvrcpFacade::init_avrcp";
         self.inner.write().avrcp_service_proxy = Some(self.create_avrcp_service_proxy().await?);
         let avrcp_service_proxy = match &self.inner.read().avrcp_service_proxy {
             Some(p) => p.clone(),
             None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy created"),
         };
         let (cont_client, cont_server) = create_endpoints::<ControllerMarker>();
         let _status = avrcp_service_proxy
             .get_controller_for_target(&PeerId { value: id }, cont_server)
             .await?;
         self.inner.write().controller_proxy =
             Some(cont_client.into_proxy().expect("Error obtaining controller client proxy"));
         Ok(())
     }

     /// Returns the media attributes from the controller.
     pub async fn get_media_attributes(&self) -> Result<String, Error> {
         let tag = "AvrcpFacade::get_media_attributes";
         match self.inner.read().controller_proxy.clone() {
             Some(proxy) => match proxy.get_media_attributes().await? {
                 Ok(media_attribs) => Ok(format!("Media attributes: {:#?}", media_attribs)),
                 Err(e) => fx_err_and_bail!(
                     &with_line!(tag),
                     format!("Error fetching media attributes: {:?}", e)
                 ),
             },
             None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
         }
     }

     /// Returns the play status from the controller.
     pub async fn get_play_status(&self) -> Result<CustomPlayStatus, Error> {
         let tag = "AvrcpFacade::get_play_status";
         match self.inner.read().controller_proxy.clone() {
             Some(proxy) => match proxy.get_play_status().await? {
                 Ok(play_status) => Ok(CustomPlayStatus::new(&play_status)),
                 Err(e) => fx_err_and_bail!(
                     &with_line!(tag),
                     format!("Error fetching play status: {:?}", e)
                 ),
             },
             None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
         }
     }

     /// Sends an AVCPanelCommand to the controller.
     ///
     /// # Arguments
     /// * `command` - an enum representing the AVCPanelCommand.
     pub async fn send_command(&self, command: CustomAvcPanelCommand) -> Result<(), Error> {
         let tag = "AvrcpFacade::send_command";
         let result = match self.inner.read().controller_proxy.clone() {
             Some(proxy) => proxy.send_command(command.into()).await?,
             None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
         };
         match result {
             Ok(res) => Ok(res),
             Err(err) => {
                 fx_err_and_bail!(&with_line!(tag), format!("Error sending command:{:?}", err))
             }
         }
     }

     /// Sends an AVCPanelCommand to the controller.
     ///
     /// # Arguments
     /// * `absolute_volume` - the value to which the volume is set.
     pub async fn set_absolute_volume(&self, absolute_volume: u8) -> Result<u8, Error> {
         let tag = "AvrcpFacade::set_absolute_volume";
         let result = match self.inner.read().controller_proxy.clone() {
             Some(proxy) => proxy.set_absolute_volume(absolute_volume).await?,
             None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
         };
         match result {
             Ok(res) => Ok(res),
             Err(err) => {
                 fx_err_and_bail!(&with_line!(tag), format!("Error setting volume:{:?}", err))
             }
         }
     }

     /// Returns the player application settings from the controller.
     ///
     /// # Arguments
     /// * `attribute_ids` - the attribute ids for the application settings to return.  If empty, returns all.
     pub async fn get_player_application_settings(
         &self,
         attribute_ids: CustomPlayerApplicationSettingsAttributeIds,
     ) -> Result<CustomPlayerApplicationSettings, Error> {
         let tag = "AvrcpFacade::get_player_application_settings";
         match self.inner.read().controller_proxy.clone() {
             Some(proxy) => {
                 match proxy.get_player_application_settings(&attribute_ids.to_vec()).await? {
                     Ok(player_application_settings) => Ok(player_application_settings.into()),
                     Err(e) => fx_err_and_bail!(
                         &with_line!(tag),
                         format!("Error fetching player application settings: {:?}", e)
                     ),
                 }
             }
             None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
         }
     }

     /// Sets the player application settings on the controller.
     ///
     /// # Arguments
     /// * `settings` - the player application settings to set.
     pub async fn set_player_application_settings(
         &self,
         settings: CustomPlayerApplicationSettings,
     ) -> Result<CustomPlayerApplicationSettings, Error> {
         let tag = "AvrcpFacade::set_player_application_settings";
         match self.inner.read().controller_proxy.clone() {
             Some(proxy) => match proxy.set_player_application_settings(&settings.into()).await? {
                 Ok(player_application_settings) => Ok(player_application_settings.into()),
                 Err(e) => fx_err_and_bail!(
                     &with_line!(tag),
                     format!("Error fetching player application settings: {:?}", e)
                 ),
             },
             None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
         }
     }

     /// Informs battery status on the controller.
     ///
     /// # Arguments
     /// * `battery_status` - the battery status to inform.
     pub async fn inform_battery_status(
         &self,
         battery_status: CustomBatteryStatus,
     ) -> Result<(), Error> {
         let tag = "AvrcpFacade::inform_battery_status";
         match self.inner.read().controller_proxy.clone() {
             Some(proxy) => match proxy.inform_battery_status(battery_status.into()).await? {
                 Ok(()) => Ok(()),
                 Err(e) => fx_err_and_bail!(
                     &with_line!(tag),
                     format!("Error informing battery status: {:?}", e)
                 ),
             },
             None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
         }
     }

     /// Sets addressed player on the controller.
     ///
     /// # Arguments
     /// * `player_id` - the player id to set as the addressed player.
     pub async fn set_addressed_player(&self, player_id: u16) -> Result<(), Error> {
         let tag = "AvrcpFacade::set_addressed_player";
         match self.inner.read().controller_proxy.clone() {
             Some(proxy) => match proxy.set_addressed_player(player_id).await? {
                 Ok(()) => Ok(()),
                 Err(e) => fx_err_and_bail!(
                     &with_line!(tag),
                     format!("Error setting addressed player: {:?}", e)
                 ),
             },
             None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
         }
     }

     /// Sets notification filter on the controller.
     ///
     /// # Arguments
     /// * `notifications_filter` - the notification ids as bit flags for which to filter.
     /// * `position_change_interval` - the interval in seconds that the controller client would
     ///  like to be notified of `TRACK_POS_CHANGED` events.  It is ignored if 'TRACK_POS' bit flag is not set.
     pub async fn set_notification_filter(
         &self,
         notifications_filter: u32,
         position_change_interval: u32,
     ) -> Result<(), Error> {
         let tag = "AvrcpFacade::set_notification_filter";
         let notifications = match Notifications::from_bits(notifications_filter) {
             Some(notifications) => notifications,
             _ => fx_err_and_bail!(
                 &with_line!(tag),
                 format!(
                     "Invalid bit flags value for notifications filter: {:?}",
                     notifications_filter
                 )
             ),
         };
         match self.inner.read().controller_proxy.clone() {
             Some(proxy) => {
                 match proxy.set_notification_filter(notifications, position_change_interval) {
                     Ok(()) => Ok(()),
                     Err(e) => fx_err_and_bail!(
                         &with_line!(tag),
                         format!("Error setting notification filter: {:?}", e)
                     ),
                 }
             }
             None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
         }
     }

     /// Notifies that the OnNotification event was handled.
     pub async fn notify_notification_handled(&self) -> Result<(), Error> {
         let tag = "AvrcpFacade::notify_notification_handled";
         match self.inner.read().controller_proxy.clone() {
             Some(proxy) => match proxy.notify_notification_handled() {
                 Ok(()) => Ok(()),
                 Err(e) => fx_err_and_bail!(
                     &with_line!(tag),
                     format!("Error setting notification filter: {:?}", e)
                 ),
             },
             None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
         }
     }

     /// A function to remove the profile service proxy and clear connected devices.
     fn clear(&self) {
         self.inner.write().avrcp_service_proxy = None;
         self.inner.write().controller_proxy = None;
     }

     /// Cleanup any Profile Server related objects.
     pub async fn cleanup(&self) -> Result<(), Error> {
         self.clear();
         Ok(())
     }
 }

 #[cfg(test)]
 mod tests {

     use super::super::types::{
         CustomCustomAttributeValue, CustomCustomPlayerApplicationSetting, CustomEqualizer,
         CustomRepeatStatusMode, CustomScanMode,
     };
     use super::*;
     use assert_matches::assert_matches;
     use fidl::endpoints::create_proxy_and_stream;
     use fidl_fuchsia_bluetooth_avrcp::{BatteryStatus, ControllerRequest, PlayStatus};
     use fuchsia_async as fasync;
     use futures::prelude::*;
     use lazy_static::lazy_static;

     lazy_static! {
         static ref PLAY_STATUS: CustomPlayStatus = CustomPlayStatus {
             song_length: Some(120),
             song_position: Some(10),
             playback_status: Some(4),
         };
         static ref PLAYER_APPLICATION_SETTINGS: CustomPlayerApplicationSettings =
             CustomPlayerApplicationSettings {
                 equalizer: Some(CustomEqualizer::Off),
                 repeat_status_mode: Some(CustomRepeatStatusMode::AllTrackRepeat),
                 shuffle_mode: None,
                 scan_mode: Some(CustomScanMode::GroupScan),
                 custom_settings: Some(vec![CustomCustomPlayerApplicationSetting {
                     attribute_id: Some(1),
                     attribute_name: Some("attribute".to_string()),
                     possible_values: Some(vec![CustomCustomAttributeValue {
                         description: "description".to_string(),
                         value: 5
                     }]),
                     current_value: Some(5),
                 }])
             };
         static ref PLAYER_APPLICATION_SETTINGS_INPUT: CustomPlayerApplicationSettings =
             CustomPlayerApplicationSettings {
                 equalizer: Some(CustomEqualizer::Off),
                 repeat_status_mode: None,
                 shuffle_mode: None,
                 scan_mode: None,
                 custom_settings: Some(vec![CustomCustomPlayerApplicationSetting {
                     attribute_id: Some(1),
                     attribute_name: Some("attribute".to_string()),
                     possible_values: Some(vec![CustomCustomAttributeValue {
                         description: "description".to_string(),
                         value: 5
                     }]),
                     current_value: Some(5),
                 }])
             };
         static ref PLAYER_APPLICATION_SETTINGS_ATTRIBUTE_IDS: CustomPlayerApplicationSettingsAttributeIds =
             CustomPlayerApplicationSettingsAttributeIds { attribute_ids: Some(vec![1]) };
     }
     struct MockAvrcpTester {
         expected_state: Vec<Box<dyn FnOnce(ControllerRequest) + Send + 'static>>,
     }

     impl MockAvrcpTester {
         fn new() -> Self {
             Self { expected_state: vec![] }
         }

         fn push(mut self, request: impl FnOnce(ControllerRequest) + Send + 'static) -> Self {
             self.expected_state.push(Box::new(request));
             self
         }

         fn build_controller(self) -> (AvrcpFacade, impl Future<Output = ()>) {
             let (proxy, mut stream) = create_proxy_and_stream::<ControllerMarker>().unwrap();
             let fut = async move {
                 for expected in self.expected_state {
                     expected(stream.next().await.unwrap().unwrap());
                 }
                 assert_matches!(stream.next().await, None);
             };
             (
                 AvrcpFacade {
                     inner: RwLock::new(AvrcpFacadeInner {
                         controller_proxy: Some(proxy),
                         avrcp_service_proxy: None,
                     }),
                 },
                 fut,
             )
         }

         fn expect_get_play_status(self, result: CustomPlayStatus) -> Self {
             self.push(move |req| match req {
                 ControllerRequest::GetPlayStatus { responder } => {
                     responder.send(Ok(&PlayStatus::from(result))).unwrap();
                 }
                 _ => {}
             })
         }

         fn expect_get_player_application_settings(
             self,
             result: CustomPlayerApplicationSettings,
             input: &'static CustomPlayerApplicationSettingsAttributeIds,
         ) -> Self {
             self.push(move |req| match req {
                 ControllerRequest::GetPlayerApplicationSettings { attribute_ids, responder } => {
                     assert_eq!(attribute_ids, input.to_vec());
                     responder.send(Ok(&result.into())).unwrap();
                 }
                 _ => {}
             })
         }

         fn expect_set_player_application_settings(
             self,
             result: CustomPlayerApplicationSettings,
             input: &'static CustomPlayerApplicationSettings,
         ) -> Self {
             self.push(move |req| match req {
                 ControllerRequest::SetPlayerApplicationSettings {
                     requested_settings,
                     responder,
                 } => {
                     let player_application_settings: CustomPlayerApplicationSettings =
                         requested_settings.into();
                     assert_eq!(player_application_settings, *input);
                     responder.send(Ok(&result.into())).unwrap();
                 }
                 _ => {}
             })
         }

         fn expect_inform_battery_status(self, input: CustomBatteryStatus) -> Self {
             self.push(move |req| match req {
                 ControllerRequest::InformBatteryStatus { battery_status, responder } => {
                     let battery_status_expected: BatteryStatus = input.into();
                     assert_eq!(battery_status_expected, battery_status);
                     responder.send(Ok(())).unwrap();
                 }
                 _ => {}
             })
         }

         fn expect_set_addressed_player(self, input: u16) -> Self {
             self.push(move |req| match req {
                 ControllerRequest::SetAddressedPlayer { player_id, responder } => {
                     assert_eq!(input, player_id);
                     responder.send(Ok(())).unwrap();
                 }
                 _ => {}
             })
         }

         fn expect_set_notification_filter(
             self,
             input_notification_filter: u32,
             input_position_change_interval: u32,
         ) -> Self {
             self.push(move |req| match req {
                 ControllerRequest::SetNotificationFilter {
                     notifications,
                     position_change_interval,
                     ..
                 } => {
                     assert_eq!(
                         Notifications::from_bits(input_notification_filter).unwrap(),
                         notifications
                     );
                     assert_eq!(input_position_change_interval, position_change_interval);
                 }
                 _ => {}
             })
         }
     }
     #[fasync::run_singlethreaded(test)]
     async fn test_get_play_status() {
         let (facade, play_status_fut) =
             MockAvrcpTester::new().expect_get_play_status(*PLAY_STATUS).build_controller();
         let facade_fut = async move {
             let play_status = facade.get_play_status().await.unwrap();
             assert_eq!(play_status, *PLAY_STATUS);
         };
         future::join(facade_fut, play_status_fut).await;
     }

     #[fasync::run_singlethreaded(test)]
     async fn test_get_player_application_settings() {
         let (facade, application_settings_fut) = MockAvrcpTester::new()
             .expect_get_player_application_settings(
                 PLAYER_APPLICATION_SETTINGS.clone(),
                 &PLAYER_APPLICATION_SETTINGS_ATTRIBUTE_IDS,
             )
             .build_controller();
         let facade_fut = async move {
             let application_settings = facade
                 .get_player_application_settings(PLAYER_APPLICATION_SETTINGS_ATTRIBUTE_IDS.clone())
                 .await
                 .unwrap();
             assert_eq!(application_settings, *PLAYER_APPLICATION_SETTINGS);
         };
         future::join(facade_fut, application_settings_fut).await;
     }

     #[fasync::run_singlethreaded(test)]
     async fn test_set_player_application_settings() {
         let (facade, application_settings_fut) = MockAvrcpTester::new()
             .expect_set_player_application_settings(
                 PLAYER_APPLICATION_SETTINGS.clone(),
                 &PLAYER_APPLICATION_SETTINGS_INPUT,
             )
             .build_controller();
         let facade_fut = async move {
             let application_settings = facade
                 .set_player_application_settings(PLAYER_APPLICATION_SETTINGS_INPUT.clone())
                 .await
                 .unwrap();
             assert_eq!(application_settings, *PLAYER_APPLICATION_SETTINGS);
         };
         future::join(facade_fut, application_settings_fut).await;
     }

     #[fasync::run_singlethreaded(test)]
     async fn test_inform_battery_status() {
         let (facade, battery_status_fut) = MockAvrcpTester::new()
             .expect_inform_battery_status(CustomBatteryStatus::Normal)
             .build_controller();
         let facade_fut = async move {
             facade.inform_battery_status(CustomBatteryStatus::Normal).await.unwrap();
         };
         future::join(facade_fut, battery_status_fut).await;
     }

     #[fasync::run_singlethreaded(test)]
     async fn test_set_addressed_player() {
         let addressed_player = 5;
         let (facade, addressed_player_fut) =
             MockAvrcpTester::new().expect_set_addressed_player(addressed_player).build_controller();
         let facade_fut = async move {
             facade.set_addressed_player(addressed_player).await.unwrap();
         };
         future::join(facade_fut, addressed_player_fut).await;
     }

     #[fasync::run_singlethreaded(test)]
     async fn test_set_notification_filter() {
         let input_notification_filter = 3;
         let input_position_change_interval = 1;
         let (facade, notification_filter_fut) = MockAvrcpTester::new()
             .expect_set_notification_filter(
                 input_notification_filter,
                 input_position_change_interval,
             )
             .build_controller();
         let facade_fut = async move {
             facade
                 .set_notification_filter(input_notification_filter, input_position_change_interval)
                 .await
                 .unwrap();
         };
         future::join(facade_fut, notification_filter_fut).await;
     }
 }
	// Copyright 2021 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 super::types::{
	CustomAvcPanelCommand, CustomBatteryStatus, CustomPlayStatus, CustomPlayerApplicationSettings,
	CustomPlayerApplicationSettingsAttributeIds,
	};
	use crate::common_utils::common::macros::{fx_err_and_bail, with_line};
	use anyhow::Error;
	use fidl::endpoints::create_endpoints;
	use fidl_fuchsia_bluetooth::PeerId;
	use fidl_fuchsia_bluetooth_avrcp::{
	ControllerMarker, ControllerProxy, Notifications, PeerManagerMarker, PeerManagerProxy,
	};
	use fuchsia_component::client;
	use fuchsia_sync::RwLock;
	use tracing::info;
	/// AvrcpFacadeInner contains the proxies used by the AvrcpFacade.
	#[derive(Debug)]
	struct AvrcpFacadeInner {
	/// Proxy for the PeerManager service.
	avrcp_service_proxy: Option<PeerManagerProxy>,
	/// Proxy for the Controller service.
	controller_proxy: Option<ControllerProxy>,
	}

	#[derive(Debug)]
	pub struct AvrcpFacade {
	inner: RwLock<AvrcpFacadeInner>,
	}

	impl AvrcpFacade {
	pub fn new() -> AvrcpFacade {
	AvrcpFacade {
	inner: RwLock::new(AvrcpFacadeInner {
	avrcp_service_proxy: None,
	controller_proxy: None,
	}),
	}
	}

	/// Creates the proxy to the PeerManager service.
	async fn create_avrcp_service_proxy(&self) -> Result<PeerManagerProxy, Error> {
	let tag = "AvrcpFacade::create_avrcp_service_proxy";
	match self.inner.read().avrcp_service_proxy.clone() {
	Some(avrcp_service_proxy) => {
	info!(
	tag = &with_line!(tag),
	"Current AVRCP service proxy: {:?}", avrcp_service_proxy
	);
	Ok(avrcp_service_proxy)
	}
	None => {
	let avrcp_service_proxy = client::connect_to_protocol::<PeerManagerMarker>();
	if let Err(err) = avrcp_service_proxy {
	fx_err_and_bail!(
	&with_line!(tag),
	format_err!("Failed to create AVRCP service proxy: {}", err)
	);
	}
	avrcp_service_proxy
	}
	}
	}

	/// Initialize the AVRCP service and retrieve the controller for the provided Bluetooth target id.
	///
	/// # Arguments
	/// * `id` - A u64 representing the device ID.
	pub async fn init_avrcp(&self, id: u64) -> Result<(), Error> {
	let tag = "AvrcpFacade::init_avrcp";
	self.inner.write().avrcp_service_proxy = Some(self.create_avrcp_service_proxy().await?);
	let avrcp_service_proxy = match &self.inner.read().avrcp_service_proxy {
	Some(p) => p.clone(),
	None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy created"),
	};
	let (cont_client, cont_server) = create_endpoints::<ControllerMarker>();
	let _status = avrcp_service_proxy
	.get_controller_for_target(&PeerId { value: id }, cont_server)
	.await?;
	self.inner.write().controller_proxy =
	Some(cont_client.into_proxy().expect("Error obtaining controller client proxy"));
	Ok(())
	}

	/// Returns the media attributes from the controller.
	pub async fn get_media_attributes(&self) -> Result<String, Error> {
	let tag = "AvrcpFacade::get_media_attributes";
	match self.inner.read().controller_proxy.clone() {
	Some(proxy) => match proxy.get_media_attributes().await? {
	Ok(media_attribs) => Ok(format!("Media attributes: {:#?}", media_attribs)),
	Err(e) => fx_err_and_bail!(
	&with_line!(tag),
	format!("Error fetching media attributes: {:?}", e)
	),
	},
	None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
	}
	}

	/// Returns the play status from the controller.
	pub async fn get_play_status(&self) -> Result<CustomPlayStatus, Error> {
	let tag = "AvrcpFacade::get_play_status";
	match self.inner.read().controller_proxy.clone() {
	Some(proxy) => match proxy.get_play_status().await? {
	Ok(play_status) => Ok(CustomPlayStatus::new(&play_status)),
	Err(e) => fx_err_and_bail!(
	&with_line!(tag),
	format!("Error fetching play status: {:?}", e)
	),
	},
	None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
	}
	}

	/// Sends an AVCPanelCommand to the controller.
	///
	/// # Arguments
	/// * `command` - an enum representing the AVCPanelCommand.
	pub async fn send_command(&self, command: CustomAvcPanelCommand) -> Result<(), Error> {
	let tag = "AvrcpFacade::send_command";
	let result = match self.inner.read().controller_proxy.clone() {
	Some(proxy) => proxy.send_command(command.into()).await?,
	None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
	};
	match result {
	Ok(res) => Ok(res),
	Err(err) => {
	fx_err_and_bail!(&with_line!(tag), format!("Error sending command:{:?}", err))
	}
	}
	}

	/// Sends an AVCPanelCommand to the controller.
	///
	/// # Arguments
	/// * `absolute_volume` - the value to which the volume is set.
	pub async fn set_absolute_volume(&self, absolute_volume: u8) -> Result<u8, Error> {
	let tag = "AvrcpFacade::set_absolute_volume";
	let result = match self.inner.read().controller_proxy.clone() {
	Some(proxy) => proxy.set_absolute_volume(absolute_volume).await?,
	None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
	};
	match result {
	Ok(res) => Ok(res),
	Err(err) => {
	fx_err_and_bail!(&with_line!(tag), format!("Error setting volume:{:?}", err))
	}
	}
	}

	/// Returns the player application settings from the controller.
	///
	/// # Arguments
	/// * `attribute_ids` - the attribute ids for the application settings to return. If empty, returns all.
	pub async fn get_player_application_settings(
	&self,
	attribute_ids: CustomPlayerApplicationSettingsAttributeIds,
	) -> Result<CustomPlayerApplicationSettings, Error> {
	let tag = "AvrcpFacade::get_player_application_settings";
	match self.inner.read().controller_proxy.clone() {
	Some(proxy) => {
	match proxy.get_player_application_settings(&attribute_ids.to_vec()).await? {
	Ok(player_application_settings) => Ok(player_application_settings.into()),
	Err(e) => fx_err_and_bail!(
	&with_line!(tag),
	format!("Error fetching player application settings: {:?}", e)
	),
	}
	}
	None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
	}
	}

	/// Sets the player application settings on the controller.
	///
	/// # Arguments
	/// * `settings` - the player application settings to set.
	pub async fn set_player_application_settings(
	&self,
	settings: CustomPlayerApplicationSettings,
	) -> Result<CustomPlayerApplicationSettings, Error> {
	let tag = "AvrcpFacade::set_player_application_settings";
	match self.inner.read().controller_proxy.clone() {
	Some(proxy) => match proxy.set_player_application_settings(&settings.into()).await? {
	Ok(player_application_settings) => Ok(player_application_settings.into()),
	Err(e) => fx_err_and_bail!(
	&with_line!(tag),
	format!("Error fetching player application settings: {:?}", e)
	),
	},
	None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
	}
	}

	/// Informs battery status on the controller.
	///
	/// # Arguments
	/// * `battery_status` - the battery status to inform.
	pub async fn inform_battery_status(
	&self,
	battery_status: CustomBatteryStatus,
	) -> Result<(), Error> {
	let tag = "AvrcpFacade::inform_battery_status";
	match self.inner.read().controller_proxy.clone() {
	Some(proxy) => match proxy.inform_battery_status(battery_status.into()).await? {
	Ok(()) => Ok(()),
	Err(e) => fx_err_and_bail!(
	&with_line!(tag),
	format!("Error informing battery status: {:?}", e)
	),
	},
	None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
	}
	}

	/// Sets addressed player on the controller.
	///
	/// # Arguments
	/// * `player_id` - the player id to set as the addressed player.
	pub async fn set_addressed_player(&self, player_id: u16) -> Result<(), Error> {
	let tag = "AvrcpFacade::set_addressed_player";
	match self.inner.read().controller_proxy.clone() {
	Some(proxy) => match proxy.set_addressed_player(player_id).await? {
	Ok(()) => Ok(()),
	Err(e) => fx_err_and_bail!(
	&with_line!(tag),
	format!("Error setting addressed player: {:?}", e)
	),
	},
	None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
	}
	}

	/// Sets notification filter on the controller.
	///
	/// # Arguments
	/// * `notifications_filter` - the notification ids as bit flags for which to filter.
	/// * `position_change_interval` - the interval in seconds that the controller client would
	/// like to be notified of `TRACK_POS_CHANGED` events. It is ignored if 'TRACK_POS' bit flag is not set.
	pub async fn set_notification_filter(
	&self,
	notifications_filter: u32,
	position_change_interval: u32,
	) -> Result<(), Error> {
	let tag = "AvrcpFacade::set_notification_filter";
	let notifications = match Notifications::from_bits(notifications_filter) {
	Some(notifications) => notifications,
	_ => fx_err_and_bail!(
	&with_line!(tag),
	format!(
	"Invalid bit flags value for notifications filter: {:?}",
	notifications_filter
	)
	),
	};
	match self.inner.read().controller_proxy.clone() {
	Some(proxy) => {
	match proxy.set_notification_filter(notifications, position_change_interval) {
	Ok(()) => Ok(()),
	Err(e) => fx_err_and_bail!(
	&with_line!(tag),
	format!("Error setting notification filter: {:?}", e)
	),
	}
	}
	None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
	}
	}

	/// Notifies that the OnNotification event was handled.
	pub async fn notify_notification_handled(&self) -> Result<(), Error> {
	let tag = "AvrcpFacade::notify_notification_handled";
	match self.inner.read().controller_proxy.clone() {
	Some(proxy) => match proxy.notify_notification_handled() {
	Ok(()) => Ok(()),
	Err(e) => fx_err_and_bail!(
	&with_line!(tag),
	format!("Error setting notification filter: {:?}", e)
	),
	},
	None => fx_err_and_bail!(&with_line!(tag), "No AVRCP service proxy available"),
	}
	}

	/// A function to remove the profile service proxy and clear connected devices.
	fn clear(&self) {
	self.inner.write().avrcp_service_proxy = None;
	self.inner.write().controller_proxy = None;
	}

	/// Cleanup any Profile Server related objects.
	pub async fn cleanup(&self) -> Result<(), Error> {
	self.clear();
	Ok(())
	}
	}

	#[cfg(test)]
	mod tests {

	use super::super::types::{
	CustomCustomAttributeValue, CustomCustomPlayerApplicationSetting, CustomEqualizer,
	CustomRepeatStatusMode, CustomScanMode,
	};
	use super::*;
	use assert_matches::assert_matches;
	use fidl::endpoints::create_proxy_and_stream;
	use fidl_fuchsia_bluetooth_avrcp::{BatteryStatus, ControllerRequest, PlayStatus};
	use fuchsia_async as fasync;
	use futures::prelude::*;
	use lazy_static::lazy_static;

	lazy_static! {
	static ref PLAY_STATUS: CustomPlayStatus = CustomPlayStatus {
	song_length: Some(120),
	song_position: Some(10),
	playback_status: Some(4),
	};
	static ref PLAYER_APPLICATION_SETTINGS: CustomPlayerApplicationSettings =
	CustomPlayerApplicationSettings {
	equalizer: Some(CustomEqualizer::Off),
	repeat_status_mode: Some(CustomRepeatStatusMode::AllTrackRepeat),
	shuffle_mode: None,
	scan_mode: Some(CustomScanMode::GroupScan),
	custom_settings: Some(vec![CustomCustomPlayerApplicationSetting {
	attribute_id: Some(1),
	attribute_name: Some("attribute".to_string()),
	possible_values: Some(vec![CustomCustomAttributeValue {
	description: "description".to_string(),
	value: 5
	}]),
	current_value: Some(5),
	}])
	};
	static ref PLAYER_APPLICATION_SETTINGS_INPUT: CustomPlayerApplicationSettings =
	CustomPlayerApplicationSettings {
	equalizer: Some(CustomEqualizer::Off),
	repeat_status_mode: None,
	shuffle_mode: None,
	scan_mode: None,
	custom_settings: Some(vec![CustomCustomPlayerApplicationSetting {
	attribute_id: Some(1),
	attribute_name: Some("attribute".to_string()),
	possible_values: Some(vec![CustomCustomAttributeValue {
	description: "description".to_string(),
	value: 5
	}]),
	current_value: Some(5),
	}])
	};
	static ref PLAYER_APPLICATION_SETTINGS_ATTRIBUTE_IDS: CustomPlayerApplicationSettingsAttributeIds =
	CustomPlayerApplicationSettingsAttributeIds { attribute_ids: Some(vec![1]) };
	}
	struct MockAvrcpTester {
	expected_state: Vec<Box<dyn FnOnce(ControllerRequest) + Send + 'static>>,
	}

	impl MockAvrcpTester {
	fn new() -> Self {
	Self { expected_state: vec![] }
	}

	fn push(mut self, request: impl FnOnce(ControllerRequest) + Send + 'static) -> Self {
	self.expected_state.push(Box::new(request));
	self
	}

	fn build_controller(self) -> (AvrcpFacade, impl Future<Output = ()>) {
	let (proxy, mut stream) = create_proxy_and_stream::<ControllerMarker>().unwrap();
	let fut = async move {
	for expected in self.expected_state {
	expected(stream.next().await.unwrap().unwrap());
	}
	assert_matches!(stream.next().await, None);
	};
	(
	AvrcpFacade {
	inner: RwLock::new(AvrcpFacadeInner {
	controller_proxy: Some(proxy),
	avrcp_service_proxy: None,
	}),
	},
	fut,
	)
	}

	fn expect_get_play_status(self, result: CustomPlayStatus) -> Self {
	self.push(move \|req\| match req {
	ControllerRequest::GetPlayStatus { responder } => {
	responder.send(Ok(&PlayStatus::from(result))).unwrap();
	}
	_ => {}
	})
	}

	fn expect_get_player_application_settings(
	self,
	result: CustomPlayerApplicationSettings,
	input: &'static CustomPlayerApplicationSettingsAttributeIds,
	) -> Self {
	self.push(move \|req\| match req {
	ControllerRequest::GetPlayerApplicationSettings { attribute_ids, responder } => {
	assert_eq!(attribute_ids, input.to_vec());
	responder.send(Ok(&result.into())).unwrap();
	}
	_ => {}
	})
	}

	fn expect_set_player_application_settings(
	self,
	result: CustomPlayerApplicationSettings,
	input: &'static CustomPlayerApplicationSettings,
	) -> Self {
	self.push(move \|req\| match req {
	ControllerRequest::SetPlayerApplicationSettings {
	requested_settings,
	responder,
	} => {
	let player_application_settings: CustomPlayerApplicationSettings =
	requested_settings.into();
	assert_eq!(player_application_settings, *input);
	responder.send(Ok(&result.into())).unwrap();
	}
	_ => {}
	})
	}

	fn expect_inform_battery_status(self, input: CustomBatteryStatus) -> Self {
	self.push(move \|req\| match req {
	ControllerRequest::InformBatteryStatus { battery_status, responder } => {
	let battery_status_expected: BatteryStatus = input.into();
	assert_eq!(battery_status_expected, battery_status);
	responder.send(Ok(())).unwrap();
	}
	_ => {}
	})
	}

	fn expect_set_addressed_player(self, input: u16) -> Self {
	self.push(move \|req\| match req {
	ControllerRequest::SetAddressedPlayer { player_id, responder } => {
	assert_eq!(input, player_id);
	responder.send(Ok(())).unwrap();
	}
	_ => {}
	})
	}

	fn expect_set_notification_filter(
	self,
	input_notification_filter: u32,
	input_position_change_interval: u32,
	) -> Self {
	self.push(move \|req\| match req {
	ControllerRequest::SetNotificationFilter {
	notifications,
	position_change_interval,
	..
	} => {
	assert_eq!(
	Notifications::from_bits(input_notification_filter).unwrap(),
	notifications
	);
	assert_eq!(input_position_change_interval, position_change_interval);
	}
	_ => {}
	})
	}
	}
	#[fasync::run_singlethreaded(test)]
	async fn test_get_play_status() {
	let (facade, play_status_fut) =
	MockAvrcpTester::new().expect_get_play_status(*PLAY_STATUS).build_controller();
	let facade_fut = async move {
	let play_status = facade.get_play_status().await.unwrap();
	assert_eq!(play_status, *PLAY_STATUS);
	};
	future::join(facade_fut, play_status_fut).await;
	}

	#[fasync::run_singlethreaded(test)]
	async fn test_get_player_application_settings() {
	let (facade, application_settings_fut) = MockAvrcpTester::new()
	.expect_get_player_application_settings(
	PLAYER_APPLICATION_SETTINGS.clone(),
	&PLAYER_APPLICATION_SETTINGS_ATTRIBUTE_IDS,
	)
	.build_controller();
	let facade_fut = async move {
	let application_settings = facade
	.get_player_application_settings(PLAYER_APPLICATION_SETTINGS_ATTRIBUTE_IDS.clone())
	.await
	.unwrap();
	assert_eq!(application_settings, *PLAYER_APPLICATION_SETTINGS);
	};
	future::join(facade_fut, application_settings_fut).await;
	}

	#[fasync::run_singlethreaded(test)]
	async fn test_set_player_application_settings() {
	let (facade, application_settings_fut) = MockAvrcpTester::new()
	.expect_set_player_application_settings(
	PLAYER_APPLICATION_SETTINGS.clone(),
	&PLAYER_APPLICATION_SETTINGS_INPUT,
	)
	.build_controller();
	let facade_fut = async move {
	let application_settings = facade
	.set_player_application_settings(PLAYER_APPLICATION_SETTINGS_INPUT.clone())
	.await
	.unwrap();
	assert_eq!(application_settings, *PLAYER_APPLICATION_SETTINGS);
	};
	future::join(facade_fut, application_settings_fut).await;
	}

	#[fasync::run_singlethreaded(test)]
	async fn test_inform_battery_status() {
	let (facade, battery_status_fut) = MockAvrcpTester::new()
	.expect_inform_battery_status(CustomBatteryStatus::Normal)
	.build_controller();
	let facade_fut = async move {
	facade.inform_battery_status(CustomBatteryStatus::Normal).await.unwrap();
	};
	future::join(facade_fut, battery_status_fut).await;
	}

	#[fasync::run_singlethreaded(test)]
	async fn test_set_addressed_player() {
	let addressed_player = 5;
	let (facade, addressed_player_fut) =
	MockAvrcpTester::new().expect_set_addressed_player(addressed_player).build_controller();
	let facade_fut = async move {
	facade.set_addressed_player(addressed_player).await.unwrap();
	};
	future::join(facade_fut, addressed_player_fut).await;
	}

	#[fasync::run_singlethreaded(test)]
	async fn test_set_notification_filter() {
	let input_notification_filter = 3;
	let input_position_change_interval = 1;
	let (facade, notification_filter_fut) = MockAvrcpTester::new()
	.expect_set_notification_filter(
	input_notification_filter,
	input_position_change_interval,
	)
	.build_controller();
	let facade_fut = async move {
	facade
	.set_notification_filter(input_notification_filter, input_position_change_interval)
	.await
	.unwrap();
	};
	future::join(facade_fut, notification_filter_fut).await;
	}
	}