settings/audio/
stream_volume_control.rs

1// Copyright 2019 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::audio::types::AudioStream;
6use crate::audio::utils::round_volume_level;
7use crate::base::SettingType;
8use crate::event::{Event, Publisher};
9use crate::handler::setting_handler::ControllerError;
10use crate::service_context::{ExternalServiceEvent, ExternalServiceProxy};
11use crate::{call, clock, trace, trace_guard};
12use fidl::endpoints::create_proxy;
13use fidl_fuchsia_media::Usage2;
14use fidl_fuchsia_media_audio::VolumeControlProxy;
15use futures::channel::oneshot::Sender;
16use futures::TryStreamExt;
17use std::rc::Rc;
18use {fuchsia_async as fasync, fuchsia_trace as ftrace};
19
20const PUBLISHER_EVENT_NAME: &str = "volume_control_events";
21const CONTROLLER_ERROR_DEPENDENCY: &str = "fuchsia.media.audio";
22const UNKNOWN_INSPECT_STRING: &str = "unknown";
23
24/// Closure definition for an action that can be triggered by ActionFuse.
25pub(crate) type ExitAction = Rc<dyn Fn()>;
26
27// Stores an AudioStream and a VolumeControl proxy bound to the AudioCore
28// service for |stored_stream|'s stream type. |proxy| is set to None if it
29// fails to bind to the AudioCore service. |early_exit_action| specifies a
30// closure to be run if the StreamVolumeControl exits prematurely.
31pub struct StreamVolumeControl {
32    pub stored_stream: AudioStream,
33    proxy: Option<VolumeControlProxy>,
34    audio_service: ExternalServiceProxy<fidl_fuchsia_media::AudioCoreProxy>,
35    publisher: Option<Publisher>,
36    early_exit_action: Option<ExitAction>,
37    listen_exit_tx: Option<Sender<()>>,
38}
39
40impl Drop for StreamVolumeControl {
41    fn drop(&mut self) {
42        if let Some(exit_tx) = self.listen_exit_tx.take() {
43            // Do not signal exit if receiver is already closed.
44            if exit_tx.is_canceled() {
45                return;
46            }
47
48            // Consider panic! is likely to be abort in the drop method, only log info for
49            // unbounded_send failure.
50            exit_tx.send(()).unwrap_or_else(|_| {
51                log::warn!("StreamVolumeControl::drop, exit_tx failed to send exit signal")
52            });
53        }
54    }
55}
56
57impl StreamVolumeControl {
58    pub(crate) async fn create(
59        id: ftrace::Id,
60        audio_service: &ExternalServiceProxy<fidl_fuchsia_media::AudioCoreProxy>,
61        stream: AudioStream,
62        early_exit_action: Option<ExitAction>,
63        publisher: Option<Publisher>,
64    ) -> Result<Self, ControllerError> {
65        // Stream input should be valid. Input comes from restore should be valid
66        // and from set request has the validation.
67        assert!(stream.has_valid_volume_level());
68
69        trace!(id, c"StreamVolumeControl ctor");
70        let mut control = StreamVolumeControl {
71            stored_stream: stream,
72            proxy: None,
73            audio_service: audio_service.clone(),
74            publisher,
75            listen_exit_tx: None,
76            early_exit_action,
77        };
78
79        control.bind_volume_control(id).await?;
80        Ok(control)
81    }
82
83    pub(crate) async fn set_volume(
84        &mut self,
85        id: ftrace::Id,
86        stream: AudioStream,
87    ) -> Result<(), ControllerError> {
88        assert_eq!(self.stored_stream.stream_type, stream.stream_type);
89        // Stream input should be valid. Input comes from restore should be valid
90        // and from set request has the validation.
91        assert!(stream.has_valid_volume_level());
92
93        // Try to create and bind a new VolumeControl.
94        if self.proxy.is_none() {
95            self.bind_volume_control(id).await?;
96        }
97
98        // Round volume level from user input.
99        let mut new_stream_value = stream;
100        new_stream_value.user_volume_level = round_volume_level(stream.user_volume_level);
101
102        let proxy = self.proxy.as_ref().expect("no volume control proxy");
103
104        if (self.stored_stream.user_volume_level - new_stream_value.user_volume_level).abs()
105            > f32::EPSILON
106        {
107            if let Err(e) = proxy.set_volume(new_stream_value.user_volume_level) {
108                self.stored_stream = new_stream_value;
109                return Err(ControllerError::ExternalFailure(
110                    SettingType::Audio,
111                    CONTROLLER_ERROR_DEPENDENCY.into(),
112                    "set volume".into(),
113                    format!("{e:?}").into(),
114                ));
115            }
116        }
117
118        if self.stored_stream.user_volume_muted != new_stream_value.user_volume_muted {
119            if let Err(e) = proxy.set_mute(stream.user_volume_muted) {
120                self.stored_stream = new_stream_value;
121                return Err(ControllerError::ExternalFailure(
122                    SettingType::Audio,
123                    CONTROLLER_ERROR_DEPENDENCY.into(),
124                    "set mute".into(),
125                    format!("{e:?}").into(),
126                ));
127            }
128        }
129
130        self.stored_stream = new_stream_value;
131        Ok(())
132    }
133
134    async fn bind_volume_control(&mut self, id: ftrace::Id) -> Result<(), ControllerError> {
135        trace!(id, c"bind volume control");
136        if self.proxy.is_some() {
137            return Ok(());
138        }
139
140        let (vol_control_proxy, server_end) = create_proxy();
141        let stream_type = self.stored_stream.stream_type;
142        let usage = Usage2::RenderUsage(stream_type.into());
143
144        let guard = trace_guard!(id, c"bind usage volume control");
145        if let Err(e) = call!(self.audio_service => bind_usage_volume_control2(&usage, server_end))
146        {
147            return Err(ControllerError::ExternalFailure(
148                SettingType::Audio,
149                CONTROLLER_ERROR_DEPENDENCY.into(),
150                format!("bind_usage_volume_control2 for audio_core {usage:?}").into(),
151                format!("{e:?}").into(),
152            ));
153        }
154        drop(guard);
155
156        let guard = trace_guard!(id, c"set values");
157        // Once the volume control is bound, apply the persisted audio settings to it.
158        if let Err(e) = vol_control_proxy.set_volume(self.stored_stream.user_volume_level) {
159            return Err(ControllerError::ExternalFailure(
160                SettingType::Audio,
161                CONTROLLER_ERROR_DEPENDENCY.into(),
162                format!("set_volume for vol_control {stream_type:?}").into(),
163                format!("{e:?}").into(),
164            ));
165        }
166
167        if let Err(e) = vol_control_proxy.set_mute(self.stored_stream.user_volume_muted) {
168            return Err(ControllerError::ExternalFailure(
169                SettingType::Audio,
170                CONTROLLER_ERROR_DEPENDENCY.into(),
171                "set_mute for vol_control".into(),
172                format!("{e:?}").into(),
173            ));
174        }
175        drop(guard);
176
177        if let Some(exit_tx) = self.listen_exit_tx.take() {
178            // exit_rx needs this signal to end leftover spawn.
179            exit_tx.send(()).expect(
180                "StreamVolumeControl::bind_volume_control, listen_exit_tx failed to send exit \
181                signal",
182            );
183        }
184
185        trace!(id, c"setup listener");
186
187        let (exit_tx, mut exit_rx) = futures::channel::oneshot::channel::<()>();
188        let publisher_clone = self.publisher.clone();
189        let mut volume_events = vol_control_proxy.take_event_stream();
190        let early_exit_action = self.early_exit_action.clone();
191        fasync::Task::local(async move {
192            let id = ftrace::Id::new();
193            trace!(id, c"bind volume handler");
194            loop {
195                futures::select! {
196                    _ = exit_rx => {
197                        trace!(id, c"exit");
198                        if let Some(publisher) = publisher_clone {
199                            // Send UNKNOWN_INSPECT_STRING for request-related args because it
200                            // can't be tied back to the event that caused the proxy to close.
201                            publisher.send_event(
202                                Event::ExternalServiceEvent(
203                                    ExternalServiceEvent::Closed(
204                                        PUBLISHER_EVENT_NAME,
205                                        UNKNOWN_INSPECT_STRING.into(),
206                                        UNKNOWN_INSPECT_STRING.into(),
207                                        clock::inspect_format_now().into(),
208                                    )
209                                )
210                            );
211                        }
212                        return;
213                    }
214                    volume_event = volume_events.try_next() => {
215                        trace!(id, c"volume_event");
216                        if volume_event.is_err() ||
217                            volume_event.expect("should not be error").is_none()
218                        {
219                            if let Some(action) = early_exit_action {
220                                (action)();
221                            }
222                            return;
223                        }
224                    }
225
226                }
227            }
228        })
229        .detach();
230
231        self.listen_exit_tx = Some(exit_tx);
232        self.proxy = Some(vol_control_proxy);
233        Ok(())
234    }
235}
settings/audio/stream_volume_control.rs

settings/audio/
stream_volume_control.rs
