[SetUI] Use service MessageHub for CameraWatcher.
This changelist moves CameraWatcher from using the
Switchboard MessageHub to the Service MessageHub.
It also consolidates the testing by removing an test whose
coverage was already present in two individual tests.
Bug: 67536
Test: fx test -o setui_service_tests
Change-Id: I4b0eb98f193fb060eb36542675a2e3c368d30c8b
Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/489159
Reviewed-by: Paul Faria <paulfaria@google.com>
diff --git a/garnet/bin/setui/src/agent/camera_watcher.rs b/garnet/bin/setui/src/agent/camera_watcher.rs
index f0c728d..5b408bf 100644
--- a/garnet/bin/setui/src/agent/camera_watcher.rs
+++ b/garnet/bin/setui/src/agent/camera_watcher.rs
@@ -7,13 +7,13 @@
};
use crate::base::SettingType;
use crate::blueprint_definition;
-use crate::handler::base::Request;
+use crate::handler::base::{Payload as HandlerPayload, Request};
use crate::handler::device_storage::DeviceStorageAccess;
use crate::input::common::connect_to_camera;
use crate::internal::agent::Payload;
use crate::internal::event::{camera_watcher, Event, Publisher};
-use crate::internal::switchboard;
use crate::message::base::Audience;
+use crate::service;
use crate::service_context::ServiceContextHandle;
use fuchsia_async as fasync;
use fuchsia_syslog::{fx_log_err, fx_log_info};
@@ -30,7 +30,7 @@
// TODO(fxbug.dev/70195): Extract common template from agents.
pub struct CameraWatcherAgent {
publisher: Publisher,
- switchboard_messenger: switchboard::message::Messenger,
+ messenger: service::message::Messenger,
/// Settings to send camera watcher events to.
recipient_settings: HashSet<SettingType>,
@@ -42,19 +42,12 @@
impl CameraWatcherAgent {
pub async fn create(context: AgentContext) {
- let switchboard_messenger =
- if let Ok(messenger) = context.create_switchboard_messenger().await {
- messenger
- } else {
- context.get_publisher().send_event(Event::Custom(
- "Could not acquire switchboard messenger in CameraWatcherAgent",
- ));
- return;
- };
-
let mut agent = CameraWatcherAgent {
publisher: context.get_publisher(),
- switchboard_messenger,
+ messenger: context
+ .create_messenger()
+ .await
+ .expect("messenger should be created for CameraWatchAgent"),
recipient_settings: context
.available_components
.intersection(&get_event_setting_types())
@@ -90,15 +83,15 @@
Ok(camera_device_client) => {
let mut event_handler = EventHandler {
publisher: self.publisher.clone(),
- switchboard_messenger: self.switchboard_messenger.clone(),
+ messenger: self.messenger.clone(),
recipient_settings: self.recipient_settings.clone(),
sw_muted: false,
};
fasync::Task::spawn(async move {
- // Here we don't care about hw_muted state because the input service would pick up
- // mute changes directly from the switch. We care about sw changes because other
- // clients of the camera3 service could change the sw mute state but not notify
- // the settings service.
+ // Here we don't care about hw_muted state because the input service would pick
+ // up mute changes directly from the switch. We care about sw changes because
+ // other clients of the camera3 service could change the sw mute state but not
+ // notify the settings service.
while let Ok((sw_muted, _hw_muted)) =
camera_device_client.watch_mute_state().await
{
@@ -119,7 +112,7 @@
struct EventHandler {
publisher: Publisher,
- switchboard_messenger: switchboard::message::Messenger,
+ messenger: service::message::Messenger,
recipient_settings: HashSet<SettingType>,
sw_muted: bool,
}
@@ -138,13 +131,10 @@
// Send the event to all the interested setting types that are also available.
for setting_type in self.recipient_settings.iter() {
- self.switchboard_messenger
+ self.messenger
.message(
- switchboard::Payload::Action(switchboard::Action::Request(
- *setting_type,
- setting_request.clone(),
- )),
- Audience::Address(switchboard::Address::Switchboard),
+ HandlerPayload::Request(setting_request.clone()).into(),
+ Audience::Address(service::Address::Handler(*setting_type)),
)
.send();
}
@@ -155,13 +145,10 @@
mod tests {
use super::*;
use crate::internal::event;
- use crate::internal::switchboard;
use crate::message::base::{MessageEvent, MessengerType};
use crate::service_context::ServiceContext;
use crate::tests::fakes::service_registry::ServiceRegistry;
use futures::StreamExt;
- use std::collections::HashMap;
- use std::iter::FromIterator;
// TODO(fxbug.dev/62860): Refactor tests, could use a common setup helper.
@@ -170,20 +157,17 @@
async fn initialization_lifespan_is_unhandled() {
// Setup messengers needed to construct the agent.
let event_message_hub = event::message::create_hub();
- let switchboard_message_hub = switchboard::message::create_hub();
+ let service_message_hub = service::message::create_hub();
let publisher = Publisher::create(&event_message_hub, MessengerType::Unbound).await;
- let (switchboard_messenger, _) = switchboard_message_hub
- .create(MessengerType::Addressable(switchboard::Address::Switchboard))
+ let (messenger, _) = service_message_hub
+ .create(MessengerType::Unbound)
.await
.expect("Unable to create switchboard messenger");
// Construct the agent.
- let mut agent = CameraWatcherAgent {
- publisher,
- switchboard_messenger,
- recipient_settings: HashSet::new(),
- };
+ let mut agent =
+ CameraWatcherAgent { publisher, messenger, recipient_settings: HashSet::new() };
// Try to initiatate the initialization lifespan.
let result = agent
@@ -201,20 +185,17 @@
async fn when_camera3_inaccessible_returns_err() {
// Setup messengers needed to construct the agent.
let event_message_hub = event::message::create_hub();
- let switchboard_message_hub = switchboard::message::create_hub();
+ let service_message_hub = service::message::create_hub();
let publisher = Publisher::create(&event_message_hub, MessengerType::Unbound).await;
- let (switchboard_messenger, _) = switchboard_message_hub
- .create(MessengerType::Addressable(switchboard::Address::Switchboard))
+ let (messenger, _) = service_message_hub
+ .create(MessengerType::Unbound)
.await
.expect("Unable to create switchboard messenger");
// Construct the agent.
- let mut agent = CameraWatcherAgent {
- publisher,
- switchboard_messenger,
- recipient_settings: HashSet::new(),
- };
+ let mut agent =
+ CameraWatcherAgent { publisher, messenger, recipient_settings: HashSet::new() };
let service_context = ServiceContext::create(
// Create a service registry without a camera3 service interface.
@@ -232,7 +213,7 @@
#[fuchsia_async::run_until_stalled(test)]
async fn event_handler_proxies_event() {
let event_message_hub = event::message::create_hub();
- let switchboard_message_hub = switchboard::message::create_hub();
+ let service_message_hub = service::message::create_hub();
// Get the messenger's signature and the receptor for agents. We need
// a different messenger below because a broadcast would not send a message
@@ -250,22 +231,20 @@
// a different messenger below because a broadcast would not send a message
// to itself. The signature is used to delete the original messenger for this
// receptor.
- let switchboard_receptor = switchboard_message_hub
- .create(MessengerType::Addressable(switchboard::Address::Switchboard))
+ let handler_receptor = service_message_hub
+ .create(MessengerType::Addressable(service::Address::Handler(SettingType::Unknown)))
.await
.expect("Unable to create switchboard receptor")
.1;
- let (switchboard_messenger, _) = switchboard_message_hub
- .create(MessengerType::Unbound)
- .await
- .expect("Unable to create switchboard messenger");
- // Make all setting types available.
- let available_components = HashSet::from_iter(get_event_setting_types());
let mut event_handler = EventHandler {
publisher,
- switchboard_messenger,
- recipient_settings: available_components,
+ messenger: service_message_hub
+ .create(MessengerType::Unbound)
+ .await
+ .expect("Unable to create switchboard messenger")
+ .0,
+ recipient_settings: vec![SettingType::Unknown].into_iter().collect(),
sw_muted: false,
};
@@ -274,15 +253,15 @@
// Delete the messengers for the receptors we're selecting below. This
// will allow the `select!` to eventually hit the `complete` case.
- switchboard_message_hub.delete(switchboard_receptor.get_signature());
+ service_message_hub.delete(handler_receptor.get_signature());
event_message_hub.delete(event_receptor.get_signature());
let mut agent_received_sw_mute = false;
- let mut received_events: HashMap<SettingType, u32> = HashMap::new();
+ let mut handler_received_event = false;
let fused_event = event_receptor.fuse();
- let fused_switchboard = switchboard_receptor.fuse();
- futures::pin_mut!(fused_event, fused_switchboard);
+ let fused_setting_handler = handler_receptor.fuse();
+ futures::pin_mut!(fused_event, fused_setting_handler);
// Loop over the select so we can handle the messages as they come in. When all messages
// have been handled, due to the messengers being deleted above, the complete branch should
@@ -302,16 +281,14 @@
}
}
},
- message = fused_switchboard.select_next_some() => {
+ message = fused_setting_handler.select_next_some() => {
if let MessageEvent::Message(
- switchboard::Payload::Action(switchboard::Action::Request(
- setting_type,
- Request::OnCameraSWState(_muted),
- )),
+ service::Payload::Setting(HandlerPayload::Request(
+ Request::OnCameraSWState(_muted))),
_,
) = message
{
- *received_events.entry(setting_type).or_default() += 1;
+ handler_received_event = true;
}
}
complete => break,
@@ -319,38 +296,36 @@
}
assert!(agent_received_sw_mute);
-
- // Verify that we received events for eacn of the expected settings.
- for setting_type in get_event_setting_types() {
- assert_eq!(*received_events.entry(setting_type).or_default(), 1);
- }
+ assert!(handler_received_event);
}
// Tests that events are not sent to unavailable settings.
#[fuchsia_async::run_until_stalled(test)]
async fn event_handler_sends_no_events_if_no_settings_available() {
let event_message_hub = event::message::create_hub();
- let switchboard_message_hub = switchboard::message::create_hub();
+ let service_message_hub = service::message::create_hub();
let publisher = Publisher::create(&event_message_hub, MessengerType::Unbound).await;
+ let handler_address = service::Address::Handler(SettingType::Unknown);
+ let verification_request = Request::Get;
// Get the messenger's signature and the receptor for agents. We need
// a different messenger below because a broadcast would not send a message
// to itself. The signature is used to delete the original messenger for this
// receptor.
- let mut switchboard_receptor = switchboard_message_hub
- .create(MessengerType::Addressable(switchboard::Address::Switchboard))
+ let mut handler_receptor = service_message_hub
+ .create(MessengerType::Addressable(handler_address))
.await
- .expect("Unable to create switchboard receptor")
+ .expect("Unable to create handler receptor")
.1;
- let (switchboard_messenger, _) = switchboard_message_hub
- .create(MessengerType::Unbound)
- .await
- .expect("Unable to create switchboard messenger");
// Declare all settings as unavailable so that no events are sent.
let mut event_handler = EventHandler {
publisher,
- switchboard_messenger,
+ messenger: service_message_hub
+ .create(MessengerType::Unbound)
+ .await
+ .expect("Unable to create messenger")
+ .0,
recipient_settings: HashSet::new(),
sw_muted: false,
};
@@ -358,82 +333,29 @@
// Send the events
event_handler.handle_event(true);
- let mut received_events: HashMap<SettingType, u32> = HashMap::new();
+ // Send a arbitrary request that should be the next payload received.
+ service_message_hub
+ .create(MessengerType::Unbound)
+ .await
+ .expect("Unable to create switchboard messenger")
+ .0
+ .message(
+ HandlerPayload::Request(verification_request.clone()).into(),
+ Audience::Address(handler_address),
+ )
+ .send()
+ .ack();
// Delete the messengers for the receptors we're selecting below. This will allow the while
// loop below to eventually finish.
- switchboard_message_hub.delete(switchboard_receptor.get_signature());
+ service_message_hub.delete(handler_receptor.get_signature());
- while let Some(message) = switchboard_receptor.next().await {
- if let MessageEvent::Message(
- switchboard::Payload::Action(switchboard::Action::Request(setting_type, _)),
- _,
- ) = message
- {
- *received_events.entry(setting_type).or_default() += 1;
- }
- }
-
- // No events were received via the switchboard.
- assert!(received_events.is_empty());
- }
-
- // Tests that events are only sent to settings that are available and no others.
- #[fuchsia_async::run_until_stalled(test)]
- async fn event_handler_sends_events_to_available_settings() {
- let event_message_hub = event::message::create_hub();
- let switchboard_message_hub = switchboard::message::create_hub();
- let publisher = Publisher::create(&event_message_hub, MessengerType::Unbound).await;
-
- let (_, mut switchboard_receptor) = switchboard_message_hub
- .create(MessengerType::Addressable(switchboard::Address::Switchboard))
- .await
- .expect("Unable to create switchboard receptor");
-
- // Run through the test once for each individual setting type among the ones that media
- // buttons sends events to.
- for setting_type in get_event_setting_types() {
- // Get the messenger's signature and the receptor for agents. We need
- // a different messenger below because a broadcast would not send a message
- // to itself. The signature is used to delete the original messenger for this
- // receptor.
- let (event_messenger, _) = switchboard_message_hub
- .create(MessengerType::Unbound)
- .await
- .expect("Unable to create switchboard messenger");
-
- // Declare only a single setting as available so that only it receives events.
- let mut available_components = HashSet::new();
- available_components.insert(setting_type);
- let mut event_handler = EventHandler {
- publisher: publisher.clone(),
- switchboard_messenger: event_messenger,
- recipient_settings: available_components,
- sw_muted: false,
- };
-
- // Send the events
- event_handler.handle_event(true);
-
- let mut received_events: HashMap<SettingType, u32> = HashMap::new();
-
- while let Some(message) = switchboard_receptor.next().await {
- if let MessageEvent::Message(
- switchboard::Payload::Action(switchboard::Action::Request(setting_type, _)),
- _,
- ) = message
- {
- *received_events.entry(setting_type).or_default() += 1;
- }
- // Only check the first event. If unexpected events were queued up, they'll be
- // detected in additional iterations.
- return;
- }
-
- // Only one setting type received events.
- assert_eq!(received_events.len(), 1);
- // All events were received by our specified setting type: for mic, volume, and camera.
- assert_eq!(*received_events.entry(setting_type).or_default(), 1);
+ if let Ok((service::Payload::Setting(HandlerPayload::Request(request)), _)) =
+ handler_receptor.next_payload().await
+ {
+ assert_eq!(request, verification_request);
+ } else {
+ panic!("should have received payload")
}
}
}
