Add screenreader support to steamos-manager.

Add ScreenReader1 interface to xml to enable/disable using screen
reader.
Implements getting and setting pitch, rate, volume, enabled.
Restarts orca when any of the above properties are changed.
Load values from orca user-settings.conf
Use systemd unit to start/stop/restart orca.

src/manager/user.rs

@@ -31,6 +31,7 @@ use crate::power::{
     get_gpu_clocks, get_gpu_clocks_range, get_gpu_performance_level, get_gpu_power_profile,
     get_max_charge_level, get_platform_profile, tdp_limit_manager, TdpManagerCommand,
 };
+use crate::screenreader::OrcaManager;
 use crate::wifi::{
     get_wifi_backend, get_wifi_power_management_state, list_wifi_interfaces, WifiBackend,
 };
@@ -153,6 +154,10 @@ struct PerformanceProfile1 {
     tdp_limit_manager: UnboundedSender<TdpManagerCommand>,
 }
 
+struct ScreenReader1 {
+    screen_reader: OrcaManager<'static>,
+}
+
 struct Storage1 {
     proxy: Proxy<'static>,
     job_manager: UnboundedSender<JobManagerCommand>,
@@ -618,6 +623,80 @@ impl PerformanceProfile1 {
     }
 }
 
+impl ScreenReader1 {
+    async fn new(connection: &Connection) -> Result<ScreenReader1> {
+        let screen_reader = OrcaManager::new(connection).await?;
+        Ok(ScreenReader1 { screen_reader })
+    }
+}
+
+#[interface(name = "com.steampowered.SteamOSManager1.ScreenReader1")]
+impl ScreenReader1 {
+    #[zbus(property)]
+    async fn enabled(&self) -> fdo::Result<bool> {
+        match self.screen_reader.enabled().await {
+            Ok(enabled) => Ok(enabled),
+            Err(e) => Err(to_zbus_fdo_error(e)),
+        }
+    }
+
+    #[zbus(property)]
+    async fn set_enabled(&mut self, enabled: bool) -> fdo::Result<()> {
+        self.screen_reader
+            .set_enabled(enabled)
+            .await
+            .map_err(to_zbus_fdo_error)
+    }
+
+    #[zbus(property)]
+    async fn rate(&self) -> fdo::Result<f64> {
+        match self.screen_reader.rate().await {
+            Ok(rate) => Ok(rate),
+            Err(e) => Err(to_zbus_fdo_error(e)),
+        }
+    }
+
+    #[zbus(property)]
+    async fn set_rate(&mut self, rate: f64) -> fdo::Result<()> {
+        self.screen_reader
+            .set_rate(rate)
+            .await
+            .map_err(to_zbus_fdo_error)
+    }
+
+    #[zbus(property)]
+    async fn pitch(&self) -> fdo::Result<f64> {
+        match self.screen_reader.pitch().await {
+            Ok(pitch) => Ok(pitch),
+            Err(e) => Err(to_zbus_fdo_error(e)),
+        }
+    }
+
+    #[zbus(property)]
+    async fn set_pitch(&mut self, pitch: f64) -> fdo::Result<()> {
+        self.screen_reader
+            .set_pitch(pitch)
+            .await
+            .map_err(to_zbus_fdo_error)
+    }
+
+    #[zbus(property)]
+    async fn volume(&self) -> fdo::Result<f64> {
+        match self.screen_reader.volume().await {
+            Ok(volume) => Ok(volume),
+            Err(e) => Err(to_zbus_fdo_error(e)),
+        }
+    }
+
+    #[zbus(property)]
+    async fn set_volume(&mut self, volume: f64) -> fdo::Result<()> {
+        self.screen_reader
+            .set_volume(volume)
+            .await
+            .map_err(to_zbus_fdo_error)
+    }
+}
+
 #[interface(name = "com.steampowered.SteamOSManager1.Storage1")]
 impl Storage1 {
     async fn format_device(
@@ -919,6 +998,7 @@ pub(crate) async fn create_interfaces(
         proxy: proxy.clone(),
         channel: daemon,
     };
+    let screen_reader = ScreenReader1::new(&session).await?;
     let wifi_debug = WifiDebug1 {
         proxy: proxy.clone(),
     };
@@ -971,6 +1051,8 @@ pub(crate) async fn create_interfaces(
 
     object_server.at(MANAGER_PATH, manager2).await?;
 
+    object_server.at(MANAGER_PATH, screen_reader).await?;
+
     if steam_deck_variant().await.unwrap_or_default() == SteamDeckVariant::Galileo {
         object_server.at(MANAGER_PATH, wifi_debug).await?;
     }