| // Copyright 2020 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 { |
| anyhow::{Context as _, Error}, |
| fidl_fuchsia_settings::{ConfigurationInterfaces, LightState, LightValue, Theme}, |
| fuchsia_component::client::connect_to_service, |
| structopt::StructOpt, |
| }; |
| |
| pub mod accessibility; |
| pub mod audio; |
| pub mod device; |
| pub mod display; |
| pub mod do_not_disturb; |
| pub mod factory_reset; |
| pub mod input; |
| pub mod intl; |
| pub mod light; |
| pub mod night_mode; |
| pub mod privacy; |
| pub mod setup; |
| pub mod utils; |
| pub mod volume_policy; |
| |
| /// SettingClient exercises the functionality found in SetUI service. Currently, |
| /// action parameters are specified at as individual arguments, but the goal is |
| /// to eventually parse details from a JSON file input. |
| #[derive(StructOpt, Debug)] |
| #[structopt(name = "setui_client", about = "set setting values")] |
| pub enum SettingClient { |
| // Operations that use the new interfaces. |
| #[structopt(name = "accessibility")] |
| Accessibility(AccessibilityOptions), |
| |
| #[structopt(name = "audio")] |
| Audio { |
| #[structopt(flatten)] |
| streams: AudioStreams, |
| |
| #[structopt(flatten)] |
| input: AudioInput, |
| }, |
| |
| // Operations that use the Device interface. |
| #[structopt(name = "device")] |
| Device { build_tag: Option<String> }, |
| |
| #[structopt(name = "display")] |
| Display { |
| #[structopt(short = "b", long = "brightness")] |
| brightness: Option<f32>, |
| |
| #[structopt(short = "o", long = "auto_brightness_level")] |
| auto_brightness_level: Option<f32>, |
| |
| #[structopt(short = "a", long = "auto_brightness")] |
| auto_brightness: Option<bool>, |
| |
| #[structopt(short = "l", long = "light_sensor")] |
| light_sensor: bool, |
| |
| #[structopt( |
| short = "m", |
| long = "low_light_mode", |
| parse(try_from_str = "str_to_low_light_mode") |
| )] |
| low_light_mode: Option<fidl_fuchsia_settings::LowLightMode>, |
| |
| #[structopt(short = "t", long = "theme", parse(try_from_str = "str_to_theme"))] |
| theme: Option<fidl_fuchsia_settings::Theme>, |
| |
| #[structopt(short = "s", long = "screen_enabled")] |
| screen_enabled: Option<bool>, |
| }, |
| |
| #[structopt(name = "do_not_disturb")] |
| DoNotDisturb { |
| #[structopt(short = "u", long = "user_dnd")] |
| user_dnd: Option<bool>, |
| |
| #[structopt(short = "n", long = "night_mode_dnd")] |
| night_mode_dnd: Option<bool>, |
| }, |
| |
| #[structopt(name = "factory_reset")] |
| FactoryReset { |
| #[structopt(short = "l", long = "is_local_reset_allowed")] |
| is_local_reset_allowed: Option<bool>, |
| }, |
| |
| #[structopt(name = "input")] |
| Input { |
| #[structopt(short = "m", long = "mic_muted")] |
| mic_muted: Option<bool>, |
| }, |
| |
| // TODO(fxbug.dev/65686): Move back into input when the clients are migrated over. |
| // TODO(fxbug.dev/66186): Support multiple input devices to be set. |
| // For simplicity, currently only supports setting one input device at a time. |
| #[structopt(name = "input2")] |
| Input2 { |
| #[structopt(flatten)] |
| input_device: InputDeviceOptions, |
| }, |
| |
| #[structopt(name = "intl")] |
| Intl { |
| #[structopt(short = "z", long, parse(from_str = "str_to_time_zone"))] |
| time_zone: Option<fidl_fuchsia_intl::TimeZoneId>, |
| |
| #[structopt(short = "u", long, parse(try_from_str = "str_to_temperature_unit"))] |
| // Valid options are Celsius and Fahrenheit, or just "c" and "f". |
| temperature_unit: Option<fidl_fuchsia_intl::TemperatureUnit>, |
| |
| #[structopt(short, long, parse(from_str = "str_to_locale"))] |
| /// List of locales, separated by spaces. |
| locales: Vec<fidl_fuchsia_intl::LocaleId>, |
| |
| #[structopt(short = "h", long, parse(try_from_str = "str_to_hour_cycle"))] |
| hour_cycle: Option<fidl_fuchsia_settings::HourCycle>, |
| |
| #[structopt(long)] |
| /// If set, this flag will set locales as an empty list. Overrides the locales arguments. |
| clear_locales: bool, |
| }, |
| |
| #[structopt(name = "light")] |
| /// Reads and modifies the hardware light state. To get the value of all light types, omit all |
| /// arguments. If setting the value for a light group, name is required, then only one type of |
| /// value between simple, brightness, or rgb should be specified. |
| Light { |
| #[structopt(flatten)] |
| light_group: LightGroup, |
| }, |
| |
| #[structopt(name = "night_mode")] |
| NightMode { |
| #[structopt(short, long)] |
| night_mode_enabled: Option<bool>, |
| }, |
| |
| #[structopt(name = "privacy")] |
| Privacy { |
| #[structopt(short, long)] |
| user_data_sharing_consent: Option<bool>, |
| }, |
| |
| #[structopt(name = "setup")] |
| Setup { |
| #[structopt(short = "i", long = "interfaces", parse(from_str = "str_to_interfaces"))] |
| configuration_interfaces: Option<ConfigurationInterfaces>, |
| }, |
| |
| /// Reads and modifies volume policies that affect the behavior of the fuchsia.settings.audio. |
| /// To list the policies, run the subcommand without any arguments. |
| #[structopt(name = "volume_policy")] |
| VolumePolicy { |
| /// Adds a policy transform. |
| #[structopt(subcommand)] |
| add: Option<VolumePolicyCommands>, |
| |
| /// Removes a policy transform by its policy ID. |
| #[structopt(short, long)] |
| remove: Option<u32>, |
| }, |
| } |
| |
| #[derive(StructOpt, Debug, Clone, Copy, Default)] |
| pub struct AccessibilityOptions { |
| #[structopt(short = "a", long)] |
| pub audio_description: Option<bool>, |
| |
| #[structopt(short = "s", long)] |
| pub screen_reader: Option<bool>, |
| |
| #[structopt(short = "i", long)] |
| pub color_inversion: Option<bool>, |
| |
| #[structopt(short = "m", long)] |
| pub enable_magnification: Option<bool>, |
| |
| #[structopt(short = "c", long, parse(try_from_str = "str_to_color_blindness_type"))] |
| pub color_correction: Option<fidl_fuchsia_settings::ColorBlindnessType>, |
| |
| #[structopt(subcommand)] |
| pub caption_options: Option<CaptionCommands>, |
| } |
| |
| #[derive(StructOpt, Debug, Clone, Copy)] |
| pub enum CaptionCommands { |
| #[structopt(name = "captions")] |
| CaptionOptions(CaptionOptions), |
| } |
| |
| #[derive(StructOpt, Debug, Clone, Copy)] |
| pub struct CaptionOptions { |
| #[structopt(short = "m", long)] |
| /// Enable closed captions for media sources of audio. |
| pub for_media: Option<bool>, |
| |
| #[structopt(short = "t", long)] |
| /// Enable closed captions for Text-To-Speech sources of audio. |
| pub for_tts: Option<bool>, |
| |
| #[structopt(short, long, parse(try_from_str = "str_to_color"))] |
| /// Border color used around the closed captions window. Valid options are red, green, or blue, |
| /// or just the first letter of each color (r, g, b). |
| pub window_color: Option<fidl_fuchsia_ui_types::ColorRgba>, |
| |
| #[structopt(short, long, parse(try_from_str = "str_to_color"))] |
| /// Border color used around the closed captions window. Valid options are red, green, or blue, |
| /// or just the first letter of each color (r, g, b). |
| pub background_color: Option<fidl_fuchsia_ui_types::ColorRgba>, |
| |
| #[structopt(flatten)] |
| pub style: CaptionFontStyle, |
| } |
| |
| #[derive(StructOpt, Debug, Clone, Copy)] |
| pub enum VolumePolicyCommands { |
| #[structopt(name = "add")] |
| AddPolicy(VolumePolicyOptions), |
| } |
| |
| #[derive(StructOpt, Debug, Clone, Copy)] |
| pub struct VolumePolicyOptions { |
| /// Target to apply the policy transform to. |
| #[structopt(parse(try_from_str = "str_to_audio_stream"))] |
| pub target: fidl_fuchsia_media::AudioRenderUsage, |
| |
| #[structopt(long)] |
| pub min: Option<f32>, |
| |
| #[structopt(long)] |
| pub max: Option<f32>, |
| } |
| |
| #[derive(StructOpt, Debug, Clone, Copy)] |
| pub struct CaptionFontStyle { |
| #[structopt(short, long, parse(try_from_str = "str_to_font_family"))] |
| /// Font family for captions, specified by 47 CFR §79.102(k). Valid options are unknown, |
| /// monospaced_serif, proportional_serif, monospaced_sans_serif, proportional_sans_serif, |
| /// casual, cursive, and small_capitals, |
| pub font_family: Option<fidl_fuchsia_settings::CaptionFontFamily>, |
| |
| #[structopt(short = "c", long, parse(try_from_str = "str_to_color"))] |
| /// Color of the closed cpation text. Valid options are red, green, or blue, or just the first |
| /// letter of each color (r, g, b). |
| pub font_color: Option<fidl_fuchsia_ui_types::ColorRgba>, |
| |
| #[structopt(short, long)] |
| /// Size of closed captions text relative to the default captions size. A range of [0.5, 2] is |
| /// guaranteed to be supported (as 47 CFR §79.103(c)(4) establishes). |
| pub relative_size: Option<f32>, |
| |
| #[structopt(short = "e", long, parse(try_from_str = "str_to_edge_style"))] |
| /// Edge style for fonts as specified in 47 CFR §79.103(c)(7), valid options are none, |
| /// drop_shadow, raised, depressed, and outline. |
| pub char_edge_style: Option<fidl_fuchsia_settings::EdgeStyle>, |
| } |
| |
| #[derive(StructOpt, Debug, Clone)] |
| pub struct InputDeviceOptions { |
| #[structopt(short = "t", long = "type", parse(try_from_str = "str_to_device_type"))] |
| /// The type of input device, e.g. camera or microphone. |
| device_type: Option<fidl_fuchsia_settings::DeviceType>, |
| |
| #[structopt(short = "n", long = "name")] |
| /// The name of the device. Must be unique within a device type. |
| device_name: Option<String>, |
| |
| #[structopt(short = "s", long = "state", parse(try_from_str = "str_to_device_state"))] |
| /// The device state flags, represented by the integer value of the bitwise flags. |
| /// |
| /// Available = 1 |
| /// Active = 2 |
| /// Muted = 4 |
| /// Disabled = 8 |
| /// Error = 16 |
| /// |
| /// For combinations of states, add these values together. |
| /// Ex: Available && Active -> 1 + 2 -> 3 |
| device_state: Option<fidl_fuchsia_settings::DeviceState>, |
| } |
| |
| #[derive(StructOpt, Debug)] |
| pub struct AudioStreams { |
| #[structopt(short = "t", long = "stream", parse(try_from_str = "str_to_audio_stream"))] |
| stream: Option<fidl_fuchsia_media::AudioRenderUsage>, |
| #[structopt(short = "s", long = "source", parse(try_from_str = "str_to_audio_source"))] |
| source: Option<fidl_fuchsia_settings::AudioStreamSettingSource>, |
| #[structopt(flatten)] |
| user_volume: UserVolume, |
| } |
| |
| #[derive(StructOpt, Debug)] |
| struct UserVolume { |
| #[structopt(short = "l", long = "level")] |
| level: Option<f32>, |
| |
| #[structopt(short = "v", long = "volume_muted")] |
| volume_muted: Option<bool>, |
| } |
| |
| #[derive(StructOpt, Debug)] |
| pub struct AudioInput { |
| #[structopt(short = "m", long = "input_muted")] |
| input_muted: Option<bool>, |
| } |
| |
| #[derive(StructOpt, Debug, Clone)] |
| pub struct LightGroup { |
| #[structopt(short, long)] |
| /// Name of a light group to set values for. Required if setting the value of a light group. |
| pub name: Option<String>, |
| |
| #[structopt(short, long)] |
| /// Repeated parameter for a list of simple on/off values to set for a light group. |
| pub simple: Vec<bool>, |
| |
| #[structopt(short, long)] |
| /// Repeated parameter for a list of floating point brightness values from 0.0-1.0 inclusive |
| /// to set for a light group, where 0.0 is minimum brightness and 1.0 is maximum. |
| pub brightness: Vec<f64>, |
| |
| #[structopt(short, long, parse(try_from_str = "str_to_rgb"))] |
| /// Repeated parameter for a list of RGB values to set for a light group. Values should be in |
| /// the range of 0.0-1.0 inclusive and should be specified as a comma-separated list of the red, |
| /// green, and blue components. Ex. 0.1,0.4,0.23 |
| pub rgb: Vec<fidl_fuchsia_ui_types::ColorRgb>, |
| } |
| |
| impl Into<Vec<LightState>> for LightGroup { |
| fn into(self) -> Vec<LightState> { |
| if self.simple.len() > 0 { |
| return self |
| .simple |
| .clone() |
| .into_iter() |
| .map(|val| LightState { value: Some(LightValue::On(val)), ..LightState::EMPTY }) |
| .collect::<Vec<_>>(); |
| } |
| |
| if self.brightness.len() > 0 { |
| return self |
| .brightness |
| .clone() |
| .into_iter() |
| .map(|val| LightState { |
| value: Some(LightValue::Brightness(val)), |
| ..LightState::EMPTY |
| }) |
| .collect::<Vec<_>>(); |
| } |
| |
| if self.rgb.len() > 0 { |
| return self |
| .rgb |
| .clone() |
| .into_iter() |
| .map(|val| LightState { value: Some(LightValue::Color(val)), ..LightState::EMPTY }) |
| .collect::<Vec<_>>(); |
| } |
| |
| return Vec::new(); |
| } |
| } |
| |
| pub async fn run_command(command: SettingClient) -> Result<(), Error> { |
| match command { |
| SettingClient::Device { build_tag } => { |
| if let Some(_build_tag_val) = build_tag { |
| panic!("Cannot set device settings"); |
| } |
| let device_service = connect_to_service::<fidl_fuchsia_settings::DeviceMarker>() |
| .context("Failed to connect to device service")?; |
| utils::print_results("Device", device::command(device_service)).await?; |
| } |
| SettingClient::Display { |
| brightness, |
| auto_brightness_level, |
| auto_brightness, |
| light_sensor, |
| low_light_mode, |
| theme, |
| screen_enabled, |
| } => { |
| let display_service = connect_to_service::<fidl_fuchsia_settings::DisplayMarker>() |
| .context("Failed to connect to display service")?; |
| utils::handle_mixed_result( |
| "Display", |
| display::command( |
| display_service, |
| brightness, |
| auto_brightness, |
| auto_brightness_level, |
| light_sensor, |
| low_light_mode, |
| theme, |
| screen_enabled, |
| ) |
| .await, |
| ) |
| .await?; |
| } |
| SettingClient::DoNotDisturb { user_dnd, night_mode_dnd } => { |
| let dnd_service = connect_to_service::<fidl_fuchsia_settings::DoNotDisturbMarker>() |
| .context("Failed to connect to do_not_disturb service")?; |
| utils::handle_mixed_result( |
| "DoNoDisturb", |
| do_not_disturb::command(dnd_service, user_dnd, night_mode_dnd).await, |
| ) |
| .await?; |
| } |
| SettingClient::FactoryReset { is_local_reset_allowed } => { |
| let factory_reset_service = |
| connect_to_service::<fidl_fuchsia_settings::FactoryResetMarker>() |
| .context("Failed to connect to factory_reset service")?; |
| utils::handle_mixed_result( |
| "FactoryReset", |
| factory_reset::command(factory_reset_service, is_local_reset_allowed).await, |
| ) |
| .await?; |
| } |
| SettingClient::Intl { time_zone, temperature_unit, locales, hour_cycle, clear_locales } => { |
| let intl_service = connect_to_service::<fidl_fuchsia_settings::IntlMarker>() |
| .context("Failed to connect to intl service")?; |
| utils::handle_mixed_result( |
| "Intl", |
| intl::command( |
| intl_service, |
| time_zone, |
| temperature_unit, |
| locales, |
| hour_cycle, |
| clear_locales, |
| ) |
| .await, |
| ) |
| .await?; |
| } |
| SettingClient::Light { light_group } => { |
| let light_mode_service = connect_to_service::<fidl_fuchsia_settings::LightMarker>() |
| .context("Failed to connect to light service")?; |
| utils::handle_mixed_result( |
| "Light", |
| light::command(light_mode_service, light_group).await, |
| ) |
| .await?; |
| } |
| SettingClient::NightMode { night_mode_enabled } => { |
| let night_mode_service = connect_to_service::<fidl_fuchsia_settings::NightModeMarker>() |
| .context("Failed to connect to night mode service")?; |
| utils::handle_mixed_result( |
| "NightMode", |
| night_mode::command(night_mode_service, night_mode_enabled).await, |
| ) |
| .await?; |
| } |
| SettingClient::Accessibility(accessibility_options) => { |
| let accessibility_service = |
| connect_to_service::<fidl_fuchsia_settings::AccessibilityMarker>() |
| .context("Failed to connect to accessibility service")?; |
| |
| utils::handle_mixed_result( |
| "Accessibility", |
| accessibility::command(accessibility_service, accessibility_options).await, |
| ) |
| .await?; |
| } |
| SettingClient::Privacy { user_data_sharing_consent } => { |
| let privacy_service = connect_to_service::<fidl_fuchsia_settings::PrivacyMarker>() |
| .context("Failed to connect to privacy service")?; |
| utils::handle_mixed_result( |
| "Privacy", |
| privacy::command(privacy_service, user_data_sharing_consent).await, |
| ) |
| .await?; |
| } |
| SettingClient::Audio { streams, input } => { |
| let audio_service = connect_to_service::<fidl_fuchsia_settings::AudioMarker>() |
| .context("Failed to connect to audio service")?; |
| let stream = streams.stream; |
| let source = streams.source; |
| let level = streams.user_volume.level; |
| let volume_muted = streams.user_volume.volume_muted; |
| let input_muted = input.input_muted; |
| utils::handle_mixed_result( |
| "Audio", |
| audio::command(audio_service, stream, source, level, volume_muted, input_muted) |
| .await, |
| ) |
| .await?; |
| } |
| SettingClient::Input { mic_muted } => { |
| let input_service = connect_to_service::<fidl_fuchsia_settings::InputMarker>() |
| .context("Failed to connect to input service")?; |
| utils::handle_mixed_result("Input", input::command(input_service, mic_muted).await) |
| .await?; |
| } |
| SettingClient::Input2 { input_device } => { |
| let input_service = connect_to_service::<fidl_fuchsia_settings::InputMarker>() |
| .context("Failed to connect to input2 service")?; |
| let device_type = input_device.device_type; |
| let device_name = input_device.device_name; |
| let device_state = input_device.device_state; |
| utils::handle_mixed_result( |
| "Input2", |
| input::command2(input_service, device_type, device_name, device_state).await, |
| ) |
| .await?; |
| } |
| SettingClient::Setup { configuration_interfaces } => { |
| let setup_service = connect_to_service::<fidl_fuchsia_settings::SetupMarker>() |
| .context("Failed to connect to setup service")?; |
| utils::handle_mixed_result( |
| "Setup", |
| setup::command(setup_service, configuration_interfaces).await, |
| ) |
| .await?; |
| } |
| SettingClient::VolumePolicy { add, remove } => { |
| let setup_service = |
| connect_to_service::<fidl_fuchsia_settings_policy::VolumePolicyControllerMarker>() |
| .context("Failed to connect to volume policy service")?; |
| utils::handle_mixed_result( |
| "Volume policy", |
| volume_policy::command(setup_service, add, remove).await, |
| ) |
| .await?; |
| } |
| } |
| Ok(()) |
| } |
| |
| fn str_to_time_zone(src: &&str) -> fidl_fuchsia_intl::TimeZoneId { |
| fidl_fuchsia_intl::TimeZoneId { id: src.to_string() } |
| } |
| |
| fn str_to_locale(src: &str) -> fidl_fuchsia_intl::LocaleId { |
| fidl_fuchsia_intl::LocaleId { id: src.to_string() } |
| } |
| |
| fn str_to_device_type(src: &str) -> Result<fidl_fuchsia_settings::DeviceType, &str> { |
| let device_type = src.to_lowercase(); |
| if device_type.contains("microphone") { |
| Ok(fidl_fuchsia_settings::DeviceType::Microphone) |
| } else if device_type.contains("camera") { |
| Ok(fidl_fuchsia_settings::DeviceType::Camera) |
| } else { |
| Err("Unidentified device type") |
| } |
| } |
| |
| fn str_to_device_state(src: &str) -> Result<fidl_fuchsia_settings::DeviceState, &str> { |
| let bits = src.parse::<u64>().map_err(|_| "Failed to parse device state")?; |
| let mut device_state = fidl_fuchsia_settings::DeviceState::EMPTY; |
| device_state.toggle_flags = fidl_fuchsia_settings::ToggleStateFlags::from_bits(bits); |
| Ok(device_state) |
| } |
| |
| fn str_to_low_light_mode(src: &str) -> Result<fidl_fuchsia_settings::LowLightMode, &str> { |
| if src.contains("enable") { |
| Ok(fidl_fuchsia_settings::LowLightMode::Enable) |
| } else if src.contains("disable") { |
| Ok(fidl_fuchsia_settings::LowLightMode::Disable) |
| } else if src.contains("disableimmediately") { |
| Ok(fidl_fuchsia_settings::LowLightMode::DisableImmediately) |
| } else { |
| Err("Couldn't parse low light mode") |
| } |
| } |
| |
| fn str_to_theme(src: &str) -> Result<fidl_fuchsia_settings::Theme, &str> { |
| match src { |
| "default" => Ok(Theme { |
| theme_type: Some(fidl_fuchsia_settings::ThemeType::Default), |
| ..Theme::EMPTY |
| }), |
| "dark" => { |
| Ok(Theme { theme_type: Some(fidl_fuchsia_settings::ThemeType::Dark), ..Theme::EMPTY }) |
| } |
| "light" => { |
| Ok(Theme { theme_type: Some(fidl_fuchsia_settings::ThemeType::Light), ..Theme::EMPTY }) |
| } |
| "auto" => { |
| Ok(Theme { theme_type: Some(fidl_fuchsia_settings::ThemeType::Auto), ..Theme::EMPTY }) |
| } |
| _ => Err("Couldn't parse theme."), |
| } |
| } |
| |
| fn str_to_interfaces(src: &&str) -> ConfigurationInterfaces { |
| let mut interfaces = ConfigurationInterfaces::empty(); |
| |
| for interface in src.split(",") { |
| match interface.to_lowercase().as_str() { |
| "eth" | "ethernet" => { |
| interfaces = interfaces | ConfigurationInterfaces::Ethernet; |
| } |
| "wireless" | "wifi" => { |
| interfaces = interfaces | ConfigurationInterfaces::Wifi; |
| } |
| _ => {} |
| } |
| } |
| |
| return interfaces; |
| } |
| |
| fn str_to_color(src: &str) -> Result<fidl_fuchsia_ui_types::ColorRgba, &str> { |
| Ok(match src.to_lowercase().as_str() { |
| "red" | "r" => { |
| fidl_fuchsia_ui_types::ColorRgba { red: 255.0, green: 0.0, blue: 0.0, alpha: 255.0 } |
| } |
| "green" | "g" => { |
| fidl_fuchsia_ui_types::ColorRgba { red: 0.0, green: 2.055, blue: 0.0, alpha: 255.0 } |
| } |
| "blue" | "b" => { |
| fidl_fuchsia_ui_types::ColorRgba { red: 0.0, green: 0.0, blue: 255.0, alpha: 255.0 } |
| } |
| _ => return Err("Couldn't parse color"), |
| }) |
| } |
| |
| /// Converts a comma-separated string of RGB values into a fidl_fuchsia_ui_types::ColorRgb. |
| fn str_to_rgb(src: &str) -> Result<fidl_fuchsia_ui_types::ColorRgb, &str> { |
| let mut part_iter = |
| src.split(',').map(|p| p.parse::<f32>().map_err(|_| "failed to parse color value")); |
| |
| const WRONG_COUNT: &str = "wrong number of values"; |
| let color = fidl_fuchsia_ui_types::ColorRgb { |
| red: part_iter.next().unwrap_or_else(|| Err(WRONG_COUNT))?, |
| green: part_iter.next().unwrap_or_else(|| Err(WRONG_COUNT))?, |
| blue: part_iter.next().unwrap_or_else(|| Err(WRONG_COUNT))?, |
| }; |
| part_iter.next().map(|_| Err(WRONG_COUNT)).unwrap_or(Ok(color)) |
| } |
| |
| fn str_to_font_family(src: &str) -> Result<fidl_fuchsia_settings::CaptionFontFamily, &str> { |
| Ok(match src.to_lowercase().as_str() { |
| "unknown" => fidl_fuchsia_settings::CaptionFontFamily::Unknown, |
| "monospaced_serif" => fidl_fuchsia_settings::CaptionFontFamily::MonospacedSerif, |
| "proportional_serif" => fidl_fuchsia_settings::CaptionFontFamily::ProportionalSerif, |
| "monospaced_sans_serif" => fidl_fuchsia_settings::CaptionFontFamily::MonospacedSansSerif, |
| "proportional_sans_serif" => { |
| fidl_fuchsia_settings::CaptionFontFamily::ProportionalSansSerif |
| } |
| "casual" => fidl_fuchsia_settings::CaptionFontFamily::Casual, |
| "cursive" => fidl_fuchsia_settings::CaptionFontFamily::Cursive, |
| "small_capitals" => fidl_fuchsia_settings::CaptionFontFamily::SmallCapitals, |
| _ => return Err("Couldn't parse font family"), |
| }) |
| } |
| |
| fn str_to_edge_style(src: &str) -> Result<fidl_fuchsia_settings::EdgeStyle, &str> { |
| Ok(match src.to_lowercase().as_str() { |
| "none" => fidl_fuchsia_settings::EdgeStyle::None, |
| "drop_shadow" => fidl_fuchsia_settings::EdgeStyle::DropShadow, |
| "raised" => fidl_fuchsia_settings::EdgeStyle::Raised, |
| "depressed" => fidl_fuchsia_settings::EdgeStyle::Depressed, |
| "outline" => fidl_fuchsia_settings::EdgeStyle::Outline, |
| _ => return Err("Couldn't parse edge style"), |
| }) |
| } |
| |
| fn str_to_temperature_unit(src: &str) -> Result<fidl_fuchsia_intl::TemperatureUnit, &str> { |
| match src.to_lowercase().as_str() { |
| "c" | "celsius" => Ok(fidl_fuchsia_intl::TemperatureUnit::Celsius), |
| "f" | "fahrenheit" => Ok(fidl_fuchsia_intl::TemperatureUnit::Fahrenheit), |
| _ => Err("Couldn't parse temperature"), |
| } |
| } |
| |
| fn str_to_hour_cycle(src: &str) -> Result<fidl_fuchsia_settings::HourCycle, &str> { |
| match src.to_lowercase().as_str() { |
| "unknown" => Ok(fidl_fuchsia_settings::HourCycle::Unknown), |
| "h11" => Ok(fidl_fuchsia_settings::HourCycle::H11), |
| "h12" => Ok(fidl_fuchsia_settings::HourCycle::H12), |
| "h23" => Ok(fidl_fuchsia_settings::HourCycle::H23), |
| "h24" => Ok(fidl_fuchsia_settings::HourCycle::H24), |
| _ => Err("Couldn't parse hour cycle"), |
| } |
| } |
| |
| fn str_to_color_blindness_type( |
| src: &str, |
| ) -> Result<fidl_fuchsia_settings::ColorBlindnessType, &str> { |
| match src.to_lowercase().as_str() { |
| "none" | "n" => Ok(fidl_fuchsia_settings::ColorBlindnessType::None), |
| "protanomaly" | "p" => Ok(fidl_fuchsia_settings::ColorBlindnessType::Protanomaly), |
| "deuteranomaly" | "d" => Ok(fidl_fuchsia_settings::ColorBlindnessType::Deuteranomaly), |
| "tritanomaly" | "t" => Ok(fidl_fuchsia_settings::ColorBlindnessType::Tritanomaly), |
| _ => Err("Couldn't parse color blindness type"), |
| } |
| } |
| |
| fn str_to_audio_stream(src: &str) -> Result<fidl_fuchsia_media::AudioRenderUsage, &str> { |
| match src.to_lowercase().as_str() { |
| "background" | "b" => Ok(fidl_fuchsia_media::AudioRenderUsage::Background), |
| "media" | "m" => Ok(fidl_fuchsia_media::AudioRenderUsage::Media), |
| "interruption" | "i" => Ok(fidl_fuchsia_media::AudioRenderUsage::Interruption), |
| "system_agent" | "systemagent" | "system agent" | "s" => { |
| Ok(fidl_fuchsia_media::AudioRenderUsage::SystemAgent) |
| } |
| "communication" | "c" => Ok(fidl_fuchsia_media::AudioRenderUsage::Communication), |
| _ => Err("Couldn't parse audio stream type"), |
| } |
| } |
| |
| fn str_to_audio_source(src: &str) -> Result<fidl_fuchsia_settings::AudioStreamSettingSource, &str> { |
| match src.to_lowercase().as_str() { |
| "user" | "u" => Ok(fidl_fuchsia_settings::AudioStreamSettingSource::User), |
| "system" | "s" => Ok(fidl_fuchsia_settings::AudioStreamSettingSource::System), |
| _ => Err("Couldn't parse audio source type"), |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| |
| /// Unit test for str_to_audio_stream. |
| #[test] |
| fn test_str_to_audio_stream() { |
| println!("Running test_str_to_audio_stream"); |
| let test_cases = vec![ |
| "Background", |
| "MEDIA", |
| "interruption", |
| "SYSTEM_AGENT", |
| "SystemAgent", |
| "system agent", |
| "Communication", |
| "unexpected_stream_type", |
| ]; |
| let expected = vec![ |
| Ok(fidl_fuchsia_media::AudioRenderUsage::Background), |
| Ok(fidl_fuchsia_media::AudioRenderUsage::Media), |
| Ok(fidl_fuchsia_media::AudioRenderUsage::Interruption), |
| Ok(fidl_fuchsia_media::AudioRenderUsage::SystemAgent), |
| Ok(fidl_fuchsia_media::AudioRenderUsage::SystemAgent), |
| Ok(fidl_fuchsia_media::AudioRenderUsage::SystemAgent), |
| Ok(fidl_fuchsia_media::AudioRenderUsage::Communication), |
| Err("Couldn't parse audio stream type"), |
| ]; |
| let mut results = vec![]; |
| for test_case in test_cases { |
| results.push(str_to_audio_stream(test_case)); |
| } |
| for (expected, result) in expected.iter().zip(results.iter()) { |
| assert_eq!(expected, result); |
| } |
| } |
| |
| /// Unit test for str_to_audio_source. |
| #[test] |
| fn test_str_to_audio_source() { |
| println!("Running test_str_to_audio_source"); |
| let test_cases = vec!["USER", "system", "unexpected_source_type"]; |
| let expected = vec![ |
| Ok(fidl_fuchsia_settings::AudioStreamSettingSource::User), |
| Ok(fidl_fuchsia_settings::AudioStreamSettingSource::System), |
| Err("Couldn't parse audio source type"), |
| ]; |
| let mut results = vec![]; |
| for test_case in test_cases { |
| results.push(str_to_audio_source(test_case)); |
| } |
| for (expected, result) in expected.iter().zip(results.iter()) { |
| assert_eq!(expected, result); |
| } |
| } |
| } |
