blob: bc27e45d750d6cfc3f8165638b9634f9abbde4cf [file]
// Copyright 2019 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.
pub mod input_controller;
pub mod input_device_configuration;
mod input_fidl_handler;
pub mod types;
use self::input_controller::InputController;
pub use self::input_device_configuration::build_input_default_settings;
use self::input_fidl_handler::InputFidlHandler;
use crate::input_device_configuration::InputConfiguration;
use anyhow::{Context, Result};
use fuchsia_async as fasync;
use futures::StreamExt;
use futures::channel::mpsc::{self, UnboundedReceiver, UnboundedSender};
use futures::channel::oneshot;
use input_controller::InputError;
pub use settings_camera::CameraWatcherEvent;
use settings_common::config::default_settings::DefaultSetting;
use settings_common::inspect::event::{
ExternalEventPublisher, RequestType, ResponseType, SettingValuePublisher, UsagePublisher,
};
use settings_common::service_context::ServiceContext;
use settings_storage::device_storage::DeviceStorage;
use settings_storage::storage_factory::StorageFactory;
use std::rc::Rc;
use types::InputInfo;
pub struct SetupResult {
pub input_fidl_handler: InputFidlHandler,
pub camera_watcher_event_tx: UnboundedSender<CameraWatcherEvent>,
pub media_buttons_event_tx: UnboundedSender<settings_media_buttons::Event>,
pub task: fuchsia_async::Task<()>,
}
pub async fn setup_input_api<F>(
service_context: Rc<ServiceContext>,
input_configuration: &mut DefaultSetting<InputConfiguration, &'static str>,
storage_factory: Rc<F>,
setting_value_publisher: SettingValuePublisher<InputInfo>,
usage_publisher: UsagePublisher<InputInfo>,
external_publisher: ExternalEventPublisher,
) -> Result<SetupResult>
where
F: StorageFactory<Storage = DeviceStorage>,
{
let mut input_controller = InputController::new(
service_context,
input_configuration,
storage_factory,
setting_value_publisher.clone(),
external_publisher,
)
.await
.context("initializing input controller")?;
let initial_value = input_controller.restore().await.context("Failed to restore input")?;
let _ = setting_value_publisher.publish(&initial_value);
let (input_fidl_handler, request_rx) =
InputFidlHandler::new(&mut input_controller, usage_publisher.clone(), initial_value);
let (camera_watcher_event_tx, camera_watcher_event_rx) = mpsc::unbounded();
let inner_camera_event_rx =
event_request_logger(camera_watcher_event_rx, usage_publisher.clone(), RequestType::Camera);
let (media_buttons_event_tx, media_buttons_event_rx) = mpsc::unbounded();
let inner_media_buttons_event_rx = event_request_logger(
media_buttons_event_rx,
usage_publisher.clone(),
RequestType::MediaButtons,
);
let task = input_controller
.handle(inner_camera_event_rx, inner_media_buttons_event_rx, request_rx)
.await;
Ok(SetupResult { input_fidl_handler, camera_watcher_event_tx, media_buttons_event_tx, task })
}
type ResultSender = oneshot::Sender<Result<Option<()>, InputError>>;
fn event_request_logger<T>(
mut event_rx: UnboundedReceiver<T>,
usage_publisher: UsagePublisher<InputInfo>,
request_type: RequestType,
) -> UnboundedReceiver<(T, ResultSender)>
where
T: std::fmt::Debug + 'static,
{
let (inner_event_tx, inner_event_rx) = mpsc::unbounded();
fasync::Task::local(async move {
while let Some(event) = event_rx.next().await {
let usage_responder = usage_publisher.request(format!("{event:?}"), request_type);
let (tx, rx) = oneshot::channel::<Result<Option<()>, InputError>>();
let _ = inner_event_tx.unbounded_send((event, tx));
if let Ok(res) = rx.await {
usage_responder.respond(
format!("{res:?}"),
res.map(|res| {
if res.is_some() { ResponseType::OkSome } else { ResponseType::OkNone }
})
.unwrap_or_else(|e| ResponseType::from(&e)),
);
} else {
usage_responder
.respond("Err(ControllerDied)".to_string(), ResponseType::UnexpectedError);
}
}
})
.detach();
inner_event_rx
}
#[cfg(test)]
mod input_device_limit_tests;
#[cfg(test)]
mod input_test_environment;
#[cfg(test)]
mod input_tests;