fidl_fuchsia_media_audio/
fidl_fuchsia_media_audio.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fuchsia_media_audio_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
15pub struct EffectsControllerMarker;
16
17impl fidl::endpoints::ProtocolMarker for EffectsControllerMarker {
18    type Proxy = EffectsControllerProxy;
19    type RequestStream = EffectsControllerRequestStream;
20    #[cfg(target_os = "fuchsia")]
21    type SynchronousProxy = EffectsControllerSynchronousProxy;
22
23    const DEBUG_NAME: &'static str = "fuchsia.media.audio.EffectsController";
24}
25impl fidl::endpoints::DiscoverableProtocolMarker for EffectsControllerMarker {}
26pub type EffectsControllerUpdateEffectResult = Result<(), UpdateEffectError>;
27
28pub trait EffectsControllerProxyInterface: Send + Sync {
29    type UpdateEffectResponseFut: std::future::Future<Output = Result<EffectsControllerUpdateEffectResult, fidl::Error>>
30        + Send;
31    fn r#update_effect(&self, effect_name: &str, config: &str) -> Self::UpdateEffectResponseFut;
32}
33#[derive(Debug)]
34#[cfg(target_os = "fuchsia")]
35pub struct EffectsControllerSynchronousProxy {
36    client: fidl::client::sync::Client,
37}
38
39#[cfg(target_os = "fuchsia")]
40impl fidl::endpoints::SynchronousProxy for EffectsControllerSynchronousProxy {
41    type Proxy = EffectsControllerProxy;
42    type Protocol = EffectsControllerMarker;
43
44    fn from_channel(inner: fidl::Channel) -> Self {
45        Self::new(inner)
46    }
47
48    fn into_channel(self) -> fidl::Channel {
49        self.client.into_channel()
50    }
51
52    fn as_channel(&self) -> &fidl::Channel {
53        self.client.as_channel()
54    }
55}
56
57#[cfg(target_os = "fuchsia")]
58impl EffectsControllerSynchronousProxy {
59    pub fn new(channel: fidl::Channel) -> Self {
60        let protocol_name =
61            <EffectsControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
62        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
63    }
64
65    pub fn into_channel(self) -> fidl::Channel {
66        self.client.into_channel()
67    }
68
69    /// Waits until an event arrives and returns it. It is safe for other
70    /// threads to make concurrent requests while waiting for an event.
71    pub fn wait_for_event(
72        &self,
73        deadline: zx::MonotonicInstant,
74    ) -> Result<EffectsControllerEvent, fidl::Error> {
75        EffectsControllerEvent::decode(self.client.wait_for_event(deadline)?)
76    }
77
78    /// Sends the `config` message to an audio effect named `effect_name`. If the
79    /// server closes the `EffectsController` connection for any reason, that
80    /// indicates that the effects have been reset and any state associated with
81    /// previous `UpdateEffect` messages have been lost. Clients who wish to re-apply
82    /// state should respond by reconnecting and resending any needed `UpdateEffect`
83    /// messages. If a client closes the connection, no state will be lost but the
84    /// client will also be unable to determine if and when any state associated with
85    /// previous messages have been lost.
86    ///
87    /// Returns success (empty response) if the message was accepted by an
88    /// effect named `effect_name`.
89    ///
90    /// Returns `UpdateEffectError.INVALID_CONFIG` if an effect with the name
91    /// `effect_name` was found, but the `config` message was rejected.
92    ///
93    /// Returns `UpdateEffectError.NOT_FOUND` if no effect with name `effect_name`
94    /// could be located.
95    pub fn r#update_effect(
96        &self,
97        mut effect_name: &str,
98        mut config: &str,
99        ___deadline: zx::MonotonicInstant,
100    ) -> Result<EffectsControllerUpdateEffectResult, fidl::Error> {
101        let _response = self.client.send_query::<
102            EffectsControllerUpdateEffectRequest,
103            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, UpdateEffectError>,
104        >(
105            (effect_name, config,),
106            0x4e39e4b5e6279125,
107            fidl::encoding::DynamicFlags::empty(),
108            ___deadline,
109        )?;
110        Ok(_response.map(|x| x))
111    }
112}
113
114#[cfg(target_os = "fuchsia")]
115impl From<EffectsControllerSynchronousProxy> for zx::Handle {
116    fn from(value: EffectsControllerSynchronousProxy) -> Self {
117        value.into_channel().into()
118    }
119}
120
121#[cfg(target_os = "fuchsia")]
122impl From<fidl::Channel> for EffectsControllerSynchronousProxy {
123    fn from(value: fidl::Channel) -> Self {
124        Self::new(value)
125    }
126}
127
128#[derive(Debug, Clone)]
129pub struct EffectsControllerProxy {
130    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
131}
132
133impl fidl::endpoints::Proxy for EffectsControllerProxy {
134    type Protocol = EffectsControllerMarker;
135
136    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
137        Self::new(inner)
138    }
139
140    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
141        self.client.into_channel().map_err(|client| Self { client })
142    }
143
144    fn as_channel(&self) -> &::fidl::AsyncChannel {
145        self.client.as_channel()
146    }
147}
148
149impl EffectsControllerProxy {
150    /// Create a new Proxy for fuchsia.media.audio/EffectsController.
151    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
152        let protocol_name =
153            <EffectsControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
154        Self { client: fidl::client::Client::new(channel, protocol_name) }
155    }
156
157    /// Get a Stream of events from the remote end of the protocol.
158    ///
159    /// # Panics
160    ///
161    /// Panics if the event stream was already taken.
162    pub fn take_event_stream(&self) -> EffectsControllerEventStream {
163        EffectsControllerEventStream { event_receiver: self.client.take_event_receiver() }
164    }
165
166    /// Sends the `config` message to an audio effect named `effect_name`. If the
167    /// server closes the `EffectsController` connection for any reason, that
168    /// indicates that the effects have been reset and any state associated with
169    /// previous `UpdateEffect` messages have been lost. Clients who wish to re-apply
170    /// state should respond by reconnecting and resending any needed `UpdateEffect`
171    /// messages. If a client closes the connection, no state will be lost but the
172    /// client will also be unable to determine if and when any state associated with
173    /// previous messages have been lost.
174    ///
175    /// Returns success (empty response) if the message was accepted by an
176    /// effect named `effect_name`.
177    ///
178    /// Returns `UpdateEffectError.INVALID_CONFIG` if an effect with the name
179    /// `effect_name` was found, but the `config` message was rejected.
180    ///
181    /// Returns `UpdateEffectError.NOT_FOUND` if no effect with name `effect_name`
182    /// could be located.
183    pub fn r#update_effect(
184        &self,
185        mut effect_name: &str,
186        mut config: &str,
187    ) -> fidl::client::QueryResponseFut<
188        EffectsControllerUpdateEffectResult,
189        fidl::encoding::DefaultFuchsiaResourceDialect,
190    > {
191        EffectsControllerProxyInterface::r#update_effect(self, effect_name, config)
192    }
193}
194
195impl EffectsControllerProxyInterface for EffectsControllerProxy {
196    type UpdateEffectResponseFut = fidl::client::QueryResponseFut<
197        EffectsControllerUpdateEffectResult,
198        fidl::encoding::DefaultFuchsiaResourceDialect,
199    >;
200    fn r#update_effect(
201        &self,
202        mut effect_name: &str,
203        mut config: &str,
204    ) -> Self::UpdateEffectResponseFut {
205        fn _decode(
206            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
207        ) -> Result<EffectsControllerUpdateEffectResult, fidl::Error> {
208            let _response = fidl::client::decode_transaction_body::<
209                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, UpdateEffectError>,
210                fidl::encoding::DefaultFuchsiaResourceDialect,
211                0x4e39e4b5e6279125,
212            >(_buf?)?;
213            Ok(_response.map(|x| x))
214        }
215        self.client.send_query_and_decode::<
216            EffectsControllerUpdateEffectRequest,
217            EffectsControllerUpdateEffectResult,
218        >(
219            (effect_name, config,),
220            0x4e39e4b5e6279125,
221            fidl::encoding::DynamicFlags::empty(),
222            _decode,
223        )
224    }
225}
226
227pub struct EffectsControllerEventStream {
228    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
229}
230
231impl std::marker::Unpin for EffectsControllerEventStream {}
232
233impl futures::stream::FusedStream for EffectsControllerEventStream {
234    fn is_terminated(&self) -> bool {
235        self.event_receiver.is_terminated()
236    }
237}
238
239impl futures::Stream for EffectsControllerEventStream {
240    type Item = Result<EffectsControllerEvent, fidl::Error>;
241
242    fn poll_next(
243        mut self: std::pin::Pin<&mut Self>,
244        cx: &mut std::task::Context<'_>,
245    ) -> std::task::Poll<Option<Self::Item>> {
246        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
247            &mut self.event_receiver,
248            cx
249        )?) {
250            Some(buf) => std::task::Poll::Ready(Some(EffectsControllerEvent::decode(buf))),
251            None => std::task::Poll::Ready(None),
252        }
253    }
254}
255
256#[derive(Debug)]
257pub enum EffectsControllerEvent {}
258
259impl EffectsControllerEvent {
260    /// Decodes a message buffer as a [`EffectsControllerEvent`].
261    fn decode(
262        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
263    ) -> Result<EffectsControllerEvent, fidl::Error> {
264        let (bytes, _handles) = buf.split_mut();
265        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
266        debug_assert_eq!(tx_header.tx_id, 0);
267        match tx_header.ordinal {
268            _ => Err(fidl::Error::UnknownOrdinal {
269                ordinal: tx_header.ordinal,
270                protocol_name:
271                    <EffectsControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
272            }),
273        }
274    }
275}
276
277/// A Stream of incoming requests for fuchsia.media.audio/EffectsController.
278pub struct EffectsControllerRequestStream {
279    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
280    is_terminated: bool,
281}
282
283impl std::marker::Unpin for EffectsControllerRequestStream {}
284
285impl futures::stream::FusedStream for EffectsControllerRequestStream {
286    fn is_terminated(&self) -> bool {
287        self.is_terminated
288    }
289}
290
291impl fidl::endpoints::RequestStream for EffectsControllerRequestStream {
292    type Protocol = EffectsControllerMarker;
293    type ControlHandle = EffectsControllerControlHandle;
294
295    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
296        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
297    }
298
299    fn control_handle(&self) -> Self::ControlHandle {
300        EffectsControllerControlHandle { inner: self.inner.clone() }
301    }
302
303    fn into_inner(
304        self,
305    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
306    {
307        (self.inner, self.is_terminated)
308    }
309
310    fn from_inner(
311        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
312        is_terminated: bool,
313    ) -> Self {
314        Self { inner, is_terminated }
315    }
316}
317
318impl futures::Stream for EffectsControllerRequestStream {
319    type Item = Result<EffectsControllerRequest, fidl::Error>;
320
321    fn poll_next(
322        mut self: std::pin::Pin<&mut Self>,
323        cx: &mut std::task::Context<'_>,
324    ) -> std::task::Poll<Option<Self::Item>> {
325        let this = &mut *self;
326        if this.inner.check_shutdown(cx) {
327            this.is_terminated = true;
328            return std::task::Poll::Ready(None);
329        }
330        if this.is_terminated {
331            panic!("polled EffectsControllerRequestStream after completion");
332        }
333        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
334            |bytes, handles| {
335                match this.inner.channel().read_etc(cx, bytes, handles) {
336                    std::task::Poll::Ready(Ok(())) => {}
337                    std::task::Poll::Pending => return std::task::Poll::Pending,
338                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
339                        this.is_terminated = true;
340                        return std::task::Poll::Ready(None);
341                    }
342                    std::task::Poll::Ready(Err(e)) => {
343                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
344                            e.into(),
345                        ))))
346                    }
347                }
348
349                // A message has been received from the channel
350                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
351
352                std::task::Poll::Ready(Some(match header.ordinal {
353                    0x4e39e4b5e6279125 => {
354                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
355                        let mut req = fidl::new_empty!(
356                            EffectsControllerUpdateEffectRequest,
357                            fidl::encoding::DefaultFuchsiaResourceDialect
358                        );
359                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EffectsControllerUpdateEffectRequest>(&header, _body_bytes, handles, &mut req)?;
360                        let control_handle =
361                            EffectsControllerControlHandle { inner: this.inner.clone() };
362                        Ok(EffectsControllerRequest::UpdateEffect {
363                            effect_name: req.effect_name,
364                            config: req.config,
365
366                            responder: EffectsControllerUpdateEffectResponder {
367                                control_handle: std::mem::ManuallyDrop::new(control_handle),
368                                tx_id: header.tx_id,
369                            },
370                        })
371                    }
372                    _ => Err(fidl::Error::UnknownOrdinal {
373                        ordinal: header.ordinal,
374                        protocol_name:
375                            <EffectsControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
376                    }),
377                }))
378            },
379        )
380    }
381}
382
383#[derive(Debug)]
384pub enum EffectsControllerRequest {
385    /// Sends the `config` message to an audio effect named `effect_name`. If the
386    /// server closes the `EffectsController` connection for any reason, that
387    /// indicates that the effects have been reset and any state associated with
388    /// previous `UpdateEffect` messages have been lost. Clients who wish to re-apply
389    /// state should respond by reconnecting and resending any needed `UpdateEffect`
390    /// messages. If a client closes the connection, no state will be lost but the
391    /// client will also be unable to determine if and when any state associated with
392    /// previous messages have been lost.
393    ///
394    /// Returns success (empty response) if the message was accepted by an
395    /// effect named `effect_name`.
396    ///
397    /// Returns `UpdateEffectError.INVALID_CONFIG` if an effect with the name
398    /// `effect_name` was found, but the `config` message was rejected.
399    ///
400    /// Returns `UpdateEffectError.NOT_FOUND` if no effect with name `effect_name`
401    /// could be located.
402    UpdateEffect {
403        effect_name: String,
404        config: String,
405        responder: EffectsControllerUpdateEffectResponder,
406    },
407}
408
409impl EffectsControllerRequest {
410    #[allow(irrefutable_let_patterns)]
411    pub fn into_update_effect(
412        self,
413    ) -> Option<(String, String, EffectsControllerUpdateEffectResponder)> {
414        if let EffectsControllerRequest::UpdateEffect { effect_name, config, responder } = self {
415            Some((effect_name, config, responder))
416        } else {
417            None
418        }
419    }
420
421    /// Name of the method defined in FIDL
422    pub fn method_name(&self) -> &'static str {
423        match *self {
424            EffectsControllerRequest::UpdateEffect { .. } => "update_effect",
425        }
426    }
427}
428
429#[derive(Debug, Clone)]
430pub struct EffectsControllerControlHandle {
431    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
432}
433
434impl fidl::endpoints::ControlHandle for EffectsControllerControlHandle {
435    fn shutdown(&self) {
436        self.inner.shutdown()
437    }
438    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
439        self.inner.shutdown_with_epitaph(status)
440    }
441
442    fn is_closed(&self) -> bool {
443        self.inner.channel().is_closed()
444    }
445    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
446        self.inner.channel().on_closed()
447    }
448
449    #[cfg(target_os = "fuchsia")]
450    fn signal_peer(
451        &self,
452        clear_mask: zx::Signals,
453        set_mask: zx::Signals,
454    ) -> Result<(), zx_status::Status> {
455        use fidl::Peered;
456        self.inner.channel().signal_peer(clear_mask, set_mask)
457    }
458}
459
460impl EffectsControllerControlHandle {}
461
462#[must_use = "FIDL methods require a response to be sent"]
463#[derive(Debug)]
464pub struct EffectsControllerUpdateEffectResponder {
465    control_handle: std::mem::ManuallyDrop<EffectsControllerControlHandle>,
466    tx_id: u32,
467}
468
469/// Set the the channel to be shutdown (see [`EffectsControllerControlHandle::shutdown`])
470/// if the responder is dropped without sending a response, so that the client
471/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
472impl std::ops::Drop for EffectsControllerUpdateEffectResponder {
473    fn drop(&mut self) {
474        self.control_handle.shutdown();
475        // Safety: drops once, never accessed again
476        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
477    }
478}
479
480impl fidl::endpoints::Responder for EffectsControllerUpdateEffectResponder {
481    type ControlHandle = EffectsControllerControlHandle;
482
483    fn control_handle(&self) -> &EffectsControllerControlHandle {
484        &self.control_handle
485    }
486
487    fn drop_without_shutdown(mut self) {
488        // Safety: drops once, never accessed again due to mem::forget
489        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
490        // Prevent Drop from running (which would shut down the channel)
491        std::mem::forget(self);
492    }
493}
494
495impl EffectsControllerUpdateEffectResponder {
496    /// Sends a response to the FIDL transaction.
497    ///
498    /// Sets the channel to shutdown if an error occurs.
499    pub fn send(self, mut result: Result<(), UpdateEffectError>) -> Result<(), fidl::Error> {
500        let _result = self.send_raw(result);
501        if _result.is_err() {
502            self.control_handle.shutdown();
503        }
504        self.drop_without_shutdown();
505        _result
506    }
507
508    /// Similar to "send" but does not shutdown the channel if an error occurs.
509    pub fn send_no_shutdown_on_err(
510        self,
511        mut result: Result<(), UpdateEffectError>,
512    ) -> Result<(), fidl::Error> {
513        let _result = self.send_raw(result);
514        self.drop_without_shutdown();
515        _result
516    }
517
518    fn send_raw(&self, mut result: Result<(), UpdateEffectError>) -> Result<(), fidl::Error> {
519        self.control_handle.inner.send::<fidl::encoding::ResultType<
520            fidl::encoding::EmptyStruct,
521            UpdateEffectError,
522        >>(
523            result,
524            self.tx_id,
525            0x4e39e4b5e6279125,
526            fidl::encoding::DynamicFlags::empty(),
527        )
528    }
529}
530
531#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
532pub struct GainControlMarker;
533
534impl fidl::endpoints::ProtocolMarker for GainControlMarker {
535    type Proxy = GainControlProxy;
536    type RequestStream = GainControlRequestStream;
537    #[cfg(target_os = "fuchsia")]
538    type SynchronousProxy = GainControlSynchronousProxy;
539
540    const DEBUG_NAME: &'static str = "(anonymous) GainControl";
541}
542
543pub trait GainControlProxyInterface: Send + Sync {
544    fn r#set_gain(&self, gain_db: f32) -> Result<(), fidl::Error>;
545    fn r#set_gain_with_ramp(
546        &self,
547        gain_db: f32,
548        duration: i64,
549        ramp_type: RampType,
550    ) -> Result<(), fidl::Error>;
551    fn r#set_mute(&self, muted: bool) -> Result<(), fidl::Error>;
552}
553#[derive(Debug)]
554#[cfg(target_os = "fuchsia")]
555pub struct GainControlSynchronousProxy {
556    client: fidl::client::sync::Client,
557}
558
559#[cfg(target_os = "fuchsia")]
560impl fidl::endpoints::SynchronousProxy for GainControlSynchronousProxy {
561    type Proxy = GainControlProxy;
562    type Protocol = GainControlMarker;
563
564    fn from_channel(inner: fidl::Channel) -> Self {
565        Self::new(inner)
566    }
567
568    fn into_channel(self) -> fidl::Channel {
569        self.client.into_channel()
570    }
571
572    fn as_channel(&self) -> &fidl::Channel {
573        self.client.as_channel()
574    }
575}
576
577#[cfg(target_os = "fuchsia")]
578impl GainControlSynchronousProxy {
579    pub fn new(channel: fidl::Channel) -> Self {
580        let protocol_name = <GainControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
581        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
582    }
583
584    pub fn into_channel(self) -> fidl::Channel {
585        self.client.into_channel()
586    }
587
588    /// Waits until an event arrives and returns it. It is safe for other
589    /// threads to make concurrent requests while waiting for an event.
590    pub fn wait_for_event(
591        &self,
592        deadline: zx::MonotonicInstant,
593    ) -> Result<GainControlEvent, fidl::Error> {
594        GainControlEvent::decode(self.client.wait_for_event(deadline)?)
595    }
596
597    /// Sets the gain in decibels.
598    pub fn r#set_gain(&self, mut gain_db: f32) -> Result<(), fidl::Error> {
599        self.client.send::<GainControlSetGainRequest>(
600            (gain_db,),
601            0x2fc070871d033f64,
602            fidl::encoding::DynamicFlags::empty(),
603        )
604    }
605
606    /// Smoothly changes gain from its current value to specified value, over the
607    /// specified duration (in milliseconds). If 'duration_ns' is 0, gain changes
608    /// immediately. Otherwise, gain changes only while the stream is running.
609    ///
610    /// Any active or pending ramp is cancelled by subsequent call to SetGain.
611    ///
612    /// There can be at most 1 active ramp at any time. Any active or pending
613    /// ramp is replaced by a later call to SetGainWithRamp (even if duration is
614    /// 0). In this case gain would ramps directly from its most recent
615    /// (mid-ramp) value to the newly-specified one, over the new duration,
616    /// using the new easing.
617    ///
618    /// Usage example (using time in seconds):
619    ///  Time 0
620    ///      SetGainWithRamp(`MUTED_GAIN_DB`, 0, SCALE_LINEAR)         // Ramp 1
621    ///      SetGainWithRamp(0.0f, `ZX_SEC`(4), SCALE_LINEAR)          // Ramp 2
622    ///  Time 3
623    ///      PlayNoReply(kNoTimestamp, any_media_time)
624    ///  Time 4
625    ///      PauseNoReply()
626    ///  Time 7
627    ///      PlayNoReply(kNoTimestamp, any_media_time)
628    ///  Time 8
629    ///      SetGainWithRamp(`MUTED_GAIN_DB`, ZX_SEC(1), SCALE_LINEAR) // Ramp 3
630    ///
631    ///
632    /// Time 0: Ramp 1 completes immediately, changing the gain to `MUTED_GAIN_DB`.
633    ///         Ramp 2 is pending, since we are not in playback.
634    /// Time 3, Ramp 2 begins ramping from `MUTED_GAIN_DB` to 0 dB
635    ///         (scale 0.0=>1.0).
636    /// Time 4: Ramp 2 pauses (3s remain). Per `SCALE_LINEAR`, scale is approx.
637    ///         0.25.
638    /// Time 7: Ramp 2 resumes from most recent value toward the target.
639    /// Time 8: Ramp 3 replaces Ramp 2 and starts from current scale
640    ///         (approx 0.5).
641    /// Time 9: Ramp 3 completes; current scale value is now 0.0 (`MUTED_GAIN_DB`).
642    pub fn r#set_gain_with_ramp(
643        &self,
644        mut gain_db: f32,
645        mut duration: i64,
646        mut ramp_type: RampType,
647    ) -> Result<(), fidl::Error> {
648        self.client.send::<GainControlSetGainWithRampRequest>(
649            (gain_db, duration, ramp_type),
650            0x3a175b2d6979e8ea,
651            fidl::encoding::DynamicFlags::empty(),
652        )
653    }
654
655    /// Sets the mute value. Ramping and mute are fully independent, although
656    /// they both affect the scaling that is applied.
657    pub fn r#set_mute(&self, mut muted: bool) -> Result<(), fidl::Error> {
658        self.client.send::<GainControlSetMuteRequest>(
659            (muted,),
660            0x5415723c1e31448,
661            fidl::encoding::DynamicFlags::empty(),
662        )
663    }
664}
665
666#[cfg(target_os = "fuchsia")]
667impl From<GainControlSynchronousProxy> for zx::Handle {
668    fn from(value: GainControlSynchronousProxy) -> Self {
669        value.into_channel().into()
670    }
671}
672
673#[cfg(target_os = "fuchsia")]
674impl From<fidl::Channel> for GainControlSynchronousProxy {
675    fn from(value: fidl::Channel) -> Self {
676        Self::new(value)
677    }
678}
679
680#[derive(Debug, Clone)]
681pub struct GainControlProxy {
682    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
683}
684
685impl fidl::endpoints::Proxy for GainControlProxy {
686    type Protocol = GainControlMarker;
687
688    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
689        Self::new(inner)
690    }
691
692    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
693        self.client.into_channel().map_err(|client| Self { client })
694    }
695
696    fn as_channel(&self) -> &::fidl::AsyncChannel {
697        self.client.as_channel()
698    }
699}
700
701impl GainControlProxy {
702    /// Create a new Proxy for fuchsia.media.audio/GainControl.
703    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
704        let protocol_name = <GainControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
705        Self { client: fidl::client::Client::new(channel, protocol_name) }
706    }
707
708    /// Get a Stream of events from the remote end of the protocol.
709    ///
710    /// # Panics
711    ///
712    /// Panics if the event stream was already taken.
713    pub fn take_event_stream(&self) -> GainControlEventStream {
714        GainControlEventStream { event_receiver: self.client.take_event_receiver() }
715    }
716
717    /// Sets the gain in decibels.
718    pub fn r#set_gain(&self, mut gain_db: f32) -> Result<(), fidl::Error> {
719        GainControlProxyInterface::r#set_gain(self, gain_db)
720    }
721
722    /// Smoothly changes gain from its current value to specified value, over the
723    /// specified duration (in milliseconds). If 'duration_ns' is 0, gain changes
724    /// immediately. Otherwise, gain changes only while the stream is running.
725    ///
726    /// Any active or pending ramp is cancelled by subsequent call to SetGain.
727    ///
728    /// There can be at most 1 active ramp at any time. Any active or pending
729    /// ramp is replaced by a later call to SetGainWithRamp (even if duration is
730    /// 0). In this case gain would ramps directly from its most recent
731    /// (mid-ramp) value to the newly-specified one, over the new duration,
732    /// using the new easing.
733    ///
734    /// Usage example (using time in seconds):
735    ///  Time 0
736    ///      SetGainWithRamp(`MUTED_GAIN_DB`, 0, SCALE_LINEAR)         // Ramp 1
737    ///      SetGainWithRamp(0.0f, `ZX_SEC`(4), SCALE_LINEAR)          // Ramp 2
738    ///  Time 3
739    ///      PlayNoReply(kNoTimestamp, any_media_time)
740    ///  Time 4
741    ///      PauseNoReply()
742    ///  Time 7
743    ///      PlayNoReply(kNoTimestamp, any_media_time)
744    ///  Time 8
745    ///      SetGainWithRamp(`MUTED_GAIN_DB`, ZX_SEC(1), SCALE_LINEAR) // Ramp 3
746    ///
747    ///
748    /// Time 0: Ramp 1 completes immediately, changing the gain to `MUTED_GAIN_DB`.
749    ///         Ramp 2 is pending, since we are not in playback.
750    /// Time 3, Ramp 2 begins ramping from `MUTED_GAIN_DB` to 0 dB
751    ///         (scale 0.0=>1.0).
752    /// Time 4: Ramp 2 pauses (3s remain). Per `SCALE_LINEAR`, scale is approx.
753    ///         0.25.
754    /// Time 7: Ramp 2 resumes from most recent value toward the target.
755    /// Time 8: Ramp 3 replaces Ramp 2 and starts from current scale
756    ///         (approx 0.5).
757    /// Time 9: Ramp 3 completes; current scale value is now 0.0 (`MUTED_GAIN_DB`).
758    pub fn r#set_gain_with_ramp(
759        &self,
760        mut gain_db: f32,
761        mut duration: i64,
762        mut ramp_type: RampType,
763    ) -> Result<(), fidl::Error> {
764        GainControlProxyInterface::r#set_gain_with_ramp(self, gain_db, duration, ramp_type)
765    }
766
767    /// Sets the mute value. Ramping and mute are fully independent, although
768    /// they both affect the scaling that is applied.
769    pub fn r#set_mute(&self, mut muted: bool) -> Result<(), fidl::Error> {
770        GainControlProxyInterface::r#set_mute(self, muted)
771    }
772}
773
774impl GainControlProxyInterface for GainControlProxy {
775    fn r#set_gain(&self, mut gain_db: f32) -> Result<(), fidl::Error> {
776        self.client.send::<GainControlSetGainRequest>(
777            (gain_db,),
778            0x2fc070871d033f64,
779            fidl::encoding::DynamicFlags::empty(),
780        )
781    }
782
783    fn r#set_gain_with_ramp(
784        &self,
785        mut gain_db: f32,
786        mut duration: i64,
787        mut ramp_type: RampType,
788    ) -> Result<(), fidl::Error> {
789        self.client.send::<GainControlSetGainWithRampRequest>(
790            (gain_db, duration, ramp_type),
791            0x3a175b2d6979e8ea,
792            fidl::encoding::DynamicFlags::empty(),
793        )
794    }
795
796    fn r#set_mute(&self, mut muted: bool) -> Result<(), fidl::Error> {
797        self.client.send::<GainControlSetMuteRequest>(
798            (muted,),
799            0x5415723c1e31448,
800            fidl::encoding::DynamicFlags::empty(),
801        )
802    }
803}
804
805pub struct GainControlEventStream {
806    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
807}
808
809impl std::marker::Unpin for GainControlEventStream {}
810
811impl futures::stream::FusedStream for GainControlEventStream {
812    fn is_terminated(&self) -> bool {
813        self.event_receiver.is_terminated()
814    }
815}
816
817impl futures::Stream for GainControlEventStream {
818    type Item = Result<GainControlEvent, fidl::Error>;
819
820    fn poll_next(
821        mut self: std::pin::Pin<&mut Self>,
822        cx: &mut std::task::Context<'_>,
823    ) -> std::task::Poll<Option<Self::Item>> {
824        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
825            &mut self.event_receiver,
826            cx
827        )?) {
828            Some(buf) => std::task::Poll::Ready(Some(GainControlEvent::decode(buf))),
829            None => std::task::Poll::Ready(None),
830        }
831    }
832}
833
834#[derive(Debug)]
835pub enum GainControlEvent {
836    OnGainMuteChanged { gain_db: f32, muted: bool },
837}
838
839impl GainControlEvent {
840    #[allow(irrefutable_let_patterns)]
841    pub fn into_on_gain_mute_changed(self) -> Option<(f32, bool)> {
842        if let GainControlEvent::OnGainMuteChanged { gain_db, muted } = self {
843            Some((gain_db, muted))
844        } else {
845            None
846        }
847    }
848
849    /// Decodes a message buffer as a [`GainControlEvent`].
850    fn decode(
851        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
852    ) -> Result<GainControlEvent, fidl::Error> {
853        let (bytes, _handles) = buf.split_mut();
854        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
855        debug_assert_eq!(tx_header.tx_id, 0);
856        match tx_header.ordinal {
857            0x66d528cad4e0d753 => {
858                let mut out = fidl::new_empty!(
859                    GainControlOnGainMuteChangedRequest,
860                    fidl::encoding::DefaultFuchsiaResourceDialect
861                );
862                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GainControlOnGainMuteChangedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
863                Ok((GainControlEvent::OnGainMuteChanged { gain_db: out.gain_db, muted: out.muted }))
864            }
865            _ => Err(fidl::Error::UnknownOrdinal {
866                ordinal: tx_header.ordinal,
867                protocol_name: <GainControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
868            }),
869        }
870    }
871}
872
873/// A Stream of incoming requests for fuchsia.media.audio/GainControl.
874pub struct GainControlRequestStream {
875    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
876    is_terminated: bool,
877}
878
879impl std::marker::Unpin for GainControlRequestStream {}
880
881impl futures::stream::FusedStream for GainControlRequestStream {
882    fn is_terminated(&self) -> bool {
883        self.is_terminated
884    }
885}
886
887impl fidl::endpoints::RequestStream for GainControlRequestStream {
888    type Protocol = GainControlMarker;
889    type ControlHandle = GainControlControlHandle;
890
891    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
892        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
893    }
894
895    fn control_handle(&self) -> Self::ControlHandle {
896        GainControlControlHandle { inner: self.inner.clone() }
897    }
898
899    fn into_inner(
900        self,
901    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
902    {
903        (self.inner, self.is_terminated)
904    }
905
906    fn from_inner(
907        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
908        is_terminated: bool,
909    ) -> Self {
910        Self { inner, is_terminated }
911    }
912}
913
914impl futures::Stream for GainControlRequestStream {
915    type Item = Result<GainControlRequest, fidl::Error>;
916
917    fn poll_next(
918        mut self: std::pin::Pin<&mut Self>,
919        cx: &mut std::task::Context<'_>,
920    ) -> std::task::Poll<Option<Self::Item>> {
921        let this = &mut *self;
922        if this.inner.check_shutdown(cx) {
923            this.is_terminated = true;
924            return std::task::Poll::Ready(None);
925        }
926        if this.is_terminated {
927            panic!("polled GainControlRequestStream after completion");
928        }
929        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
930            |bytes, handles| {
931                match this.inner.channel().read_etc(cx, bytes, handles) {
932                    std::task::Poll::Ready(Ok(())) => {}
933                    std::task::Poll::Pending => return std::task::Poll::Pending,
934                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
935                        this.is_terminated = true;
936                        return std::task::Poll::Ready(None);
937                    }
938                    std::task::Poll::Ready(Err(e)) => {
939                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
940                            e.into(),
941                        ))))
942                    }
943                }
944
945                // A message has been received from the channel
946                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
947
948                std::task::Poll::Ready(Some(match header.ordinal {
949                    0x2fc070871d033f64 => {
950                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
951                        let mut req = fidl::new_empty!(
952                            GainControlSetGainRequest,
953                            fidl::encoding::DefaultFuchsiaResourceDialect
954                        );
955                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GainControlSetGainRequest>(&header, _body_bytes, handles, &mut req)?;
956                        let control_handle = GainControlControlHandle { inner: this.inner.clone() };
957                        Ok(GainControlRequest::SetGain { gain_db: req.gain_db, control_handle })
958                    }
959                    0x3a175b2d6979e8ea => {
960                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
961                        let mut req = fidl::new_empty!(
962                            GainControlSetGainWithRampRequest,
963                            fidl::encoding::DefaultFuchsiaResourceDialect
964                        );
965                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GainControlSetGainWithRampRequest>(&header, _body_bytes, handles, &mut req)?;
966                        let control_handle = GainControlControlHandle { inner: this.inner.clone() };
967                        Ok(GainControlRequest::SetGainWithRamp {
968                            gain_db: req.gain_db,
969                            duration: req.duration,
970                            ramp_type: req.ramp_type,
971
972                            control_handle,
973                        })
974                    }
975                    0x5415723c1e31448 => {
976                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
977                        let mut req = fidl::new_empty!(
978                            GainControlSetMuteRequest,
979                            fidl::encoding::DefaultFuchsiaResourceDialect
980                        );
981                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GainControlSetMuteRequest>(&header, _body_bytes, handles, &mut req)?;
982                        let control_handle = GainControlControlHandle { inner: this.inner.clone() };
983                        Ok(GainControlRequest::SetMute { muted: req.muted, control_handle })
984                    }
985                    _ => Err(fidl::Error::UnknownOrdinal {
986                        ordinal: header.ordinal,
987                        protocol_name:
988                            <GainControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
989                    }),
990                }))
991            },
992        )
993    }
994}
995
996/// Enables control and monitoring of audio gain. This interface is typically
997/// a tear-off of other interfaces. For example, `fuchsia.media.audio.Renderer`
998/// has a `BindGainControl` method that binds to a gain control that controls
999/// gain for the renderer.
1000#[derive(Debug)]
1001pub enum GainControlRequest {
1002    /// Sets the gain in decibels.
1003    SetGain { gain_db: f32, control_handle: GainControlControlHandle },
1004    /// Smoothly changes gain from its current value to specified value, over the
1005    /// specified duration (in milliseconds). If 'duration_ns' is 0, gain changes
1006    /// immediately. Otherwise, gain changes only while the stream is running.
1007    ///
1008    /// Any active or pending ramp is cancelled by subsequent call to SetGain.
1009    ///
1010    /// There can be at most 1 active ramp at any time. Any active or pending
1011    /// ramp is replaced by a later call to SetGainWithRamp (even if duration is
1012    /// 0). In this case gain would ramps directly from its most recent
1013    /// (mid-ramp) value to the newly-specified one, over the new duration,
1014    /// using the new easing.
1015    ///
1016    /// Usage example (using time in seconds):
1017    ///  Time 0
1018    ///      SetGainWithRamp(`MUTED_GAIN_DB`, 0, SCALE_LINEAR)         // Ramp 1
1019    ///      SetGainWithRamp(0.0f, `ZX_SEC`(4), SCALE_LINEAR)          // Ramp 2
1020    ///  Time 3
1021    ///      PlayNoReply(kNoTimestamp, any_media_time)
1022    ///  Time 4
1023    ///      PauseNoReply()
1024    ///  Time 7
1025    ///      PlayNoReply(kNoTimestamp, any_media_time)
1026    ///  Time 8
1027    ///      SetGainWithRamp(`MUTED_GAIN_DB`, ZX_SEC(1), SCALE_LINEAR) // Ramp 3
1028    ///
1029    ///
1030    /// Time 0: Ramp 1 completes immediately, changing the gain to `MUTED_GAIN_DB`.
1031    ///         Ramp 2 is pending, since we are not in playback.
1032    /// Time 3, Ramp 2 begins ramping from `MUTED_GAIN_DB` to 0 dB
1033    ///         (scale 0.0=>1.0).
1034    /// Time 4: Ramp 2 pauses (3s remain). Per `SCALE_LINEAR`, scale is approx.
1035    ///         0.25.
1036    /// Time 7: Ramp 2 resumes from most recent value toward the target.
1037    /// Time 8: Ramp 3 replaces Ramp 2 and starts from current scale
1038    ///         (approx 0.5).
1039    /// Time 9: Ramp 3 completes; current scale value is now 0.0 (`MUTED_GAIN_DB`).
1040    SetGainWithRamp {
1041        gain_db: f32,
1042        duration: i64,
1043        ramp_type: RampType,
1044        control_handle: GainControlControlHandle,
1045    },
1046    /// Sets the mute value. Ramping and mute are fully independent, although
1047    /// they both affect the scaling that is applied.
1048    SetMute { muted: bool, control_handle: GainControlControlHandle },
1049}
1050
1051impl GainControlRequest {
1052    #[allow(irrefutable_let_patterns)]
1053    pub fn into_set_gain(self) -> Option<(f32, GainControlControlHandle)> {
1054        if let GainControlRequest::SetGain { gain_db, control_handle } = self {
1055            Some((gain_db, control_handle))
1056        } else {
1057            None
1058        }
1059    }
1060
1061    #[allow(irrefutable_let_patterns)]
1062    pub fn into_set_gain_with_ramp(self) -> Option<(f32, i64, RampType, GainControlControlHandle)> {
1063        if let GainControlRequest::SetGainWithRamp {
1064            gain_db,
1065            duration,
1066            ramp_type,
1067            control_handle,
1068        } = self
1069        {
1070            Some((gain_db, duration, ramp_type, control_handle))
1071        } else {
1072            None
1073        }
1074    }
1075
1076    #[allow(irrefutable_let_patterns)]
1077    pub fn into_set_mute(self) -> Option<(bool, GainControlControlHandle)> {
1078        if let GainControlRequest::SetMute { muted, control_handle } = self {
1079            Some((muted, control_handle))
1080        } else {
1081            None
1082        }
1083    }
1084
1085    /// Name of the method defined in FIDL
1086    pub fn method_name(&self) -> &'static str {
1087        match *self {
1088            GainControlRequest::SetGain { .. } => "set_gain",
1089            GainControlRequest::SetGainWithRamp { .. } => "set_gain_with_ramp",
1090            GainControlRequest::SetMute { .. } => "set_mute",
1091        }
1092    }
1093}
1094
1095#[derive(Debug, Clone)]
1096pub struct GainControlControlHandle {
1097    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1098}
1099
1100impl fidl::endpoints::ControlHandle for GainControlControlHandle {
1101    fn shutdown(&self) {
1102        self.inner.shutdown()
1103    }
1104    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1105        self.inner.shutdown_with_epitaph(status)
1106    }
1107
1108    fn is_closed(&self) -> bool {
1109        self.inner.channel().is_closed()
1110    }
1111    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1112        self.inner.channel().on_closed()
1113    }
1114
1115    #[cfg(target_os = "fuchsia")]
1116    fn signal_peer(
1117        &self,
1118        clear_mask: zx::Signals,
1119        set_mask: zx::Signals,
1120    ) -> Result<(), zx_status::Status> {
1121        use fidl::Peered;
1122        self.inner.channel().signal_peer(clear_mask, set_mask)
1123    }
1124}
1125
1126impl GainControlControlHandle {
1127    pub fn send_on_gain_mute_changed(
1128        &self,
1129        mut gain_db: f32,
1130        mut muted: bool,
1131    ) -> Result<(), fidl::Error> {
1132        self.inner.send::<GainControlOnGainMuteChangedRequest>(
1133            (gain_db, muted),
1134            0,
1135            0x66d528cad4e0d753,
1136            fidl::encoding::DynamicFlags::empty(),
1137        )
1138    }
1139}
1140
1141#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1142pub struct VolumeControlMarker;
1143
1144impl fidl::endpoints::ProtocolMarker for VolumeControlMarker {
1145    type Proxy = VolumeControlProxy;
1146    type RequestStream = VolumeControlRequestStream;
1147    #[cfg(target_os = "fuchsia")]
1148    type SynchronousProxy = VolumeControlSynchronousProxy;
1149
1150    const DEBUG_NAME: &'static str = "(anonymous) VolumeControl";
1151}
1152
1153pub trait VolumeControlProxyInterface: Send + Sync {
1154    fn r#set_volume(&self, volume: f32) -> Result<(), fidl::Error>;
1155    fn r#set_mute(&self, mute: bool) -> Result<(), fidl::Error>;
1156}
1157#[derive(Debug)]
1158#[cfg(target_os = "fuchsia")]
1159pub struct VolumeControlSynchronousProxy {
1160    client: fidl::client::sync::Client,
1161}
1162
1163#[cfg(target_os = "fuchsia")]
1164impl fidl::endpoints::SynchronousProxy for VolumeControlSynchronousProxy {
1165    type Proxy = VolumeControlProxy;
1166    type Protocol = VolumeControlMarker;
1167
1168    fn from_channel(inner: fidl::Channel) -> Self {
1169        Self::new(inner)
1170    }
1171
1172    fn into_channel(self) -> fidl::Channel {
1173        self.client.into_channel()
1174    }
1175
1176    fn as_channel(&self) -> &fidl::Channel {
1177        self.client.as_channel()
1178    }
1179}
1180
1181#[cfg(target_os = "fuchsia")]
1182impl VolumeControlSynchronousProxy {
1183    pub fn new(channel: fidl::Channel) -> Self {
1184        let protocol_name = <VolumeControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1185        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
1186    }
1187
1188    pub fn into_channel(self) -> fidl::Channel {
1189        self.client.into_channel()
1190    }
1191
1192    /// Waits until an event arrives and returns it. It is safe for other
1193    /// threads to make concurrent requests while waiting for an event.
1194    pub fn wait_for_event(
1195        &self,
1196        deadline: zx::MonotonicInstant,
1197    ) -> Result<VolumeControlEvent, fidl::Error> {
1198        VolumeControlEvent::decode(self.client.wait_for_event(deadline)?)
1199    }
1200
1201    /// Sets the volume of the audio element to the given value in
1202    /// [0.0, 1.0]. If the value is provided is outside of [0.0, 1.0],
1203    /// the value is clamped before application.
1204    pub fn r#set_volume(&self, mut volume: f32) -> Result<(), fidl::Error> {
1205        self.client.send::<VolumeControlSetVolumeRequest>(
1206            (volume,),
1207            0x6ff4231809a697da,
1208            fidl::encoding::DynamicFlags::empty(),
1209        )
1210    }
1211
1212    /// Sets whether the controlled element is muted. Mute is not the same
1213    /// as setting volume to 0.0; volume will persist for the duration of
1214    /// a mute. If volume was 0.5 before mute, volume will resume at 0.5
1215    /// following unmute.
1216    pub fn r#set_mute(&self, mut mute: bool) -> Result<(), fidl::Error> {
1217        self.client.send::<VolumeControlSetMuteRequest>(
1218            (mute,),
1219            0x50c10c28bba46425,
1220            fidl::encoding::DynamicFlags::empty(),
1221        )
1222    }
1223}
1224
1225#[cfg(target_os = "fuchsia")]
1226impl From<VolumeControlSynchronousProxy> for zx::Handle {
1227    fn from(value: VolumeControlSynchronousProxy) -> Self {
1228        value.into_channel().into()
1229    }
1230}
1231
1232#[cfg(target_os = "fuchsia")]
1233impl From<fidl::Channel> for VolumeControlSynchronousProxy {
1234    fn from(value: fidl::Channel) -> Self {
1235        Self::new(value)
1236    }
1237}
1238
1239#[derive(Debug, Clone)]
1240pub struct VolumeControlProxy {
1241    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1242}
1243
1244impl fidl::endpoints::Proxy for VolumeControlProxy {
1245    type Protocol = VolumeControlMarker;
1246
1247    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1248        Self::new(inner)
1249    }
1250
1251    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1252        self.client.into_channel().map_err(|client| Self { client })
1253    }
1254
1255    fn as_channel(&self) -> &::fidl::AsyncChannel {
1256        self.client.as_channel()
1257    }
1258}
1259
1260impl VolumeControlProxy {
1261    /// Create a new Proxy for fuchsia.media.audio/VolumeControl.
1262    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1263        let protocol_name = <VolumeControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1264        Self { client: fidl::client::Client::new(channel, protocol_name) }
1265    }
1266
1267    /// Get a Stream of events from the remote end of the protocol.
1268    ///
1269    /// # Panics
1270    ///
1271    /// Panics if the event stream was already taken.
1272    pub fn take_event_stream(&self) -> VolumeControlEventStream {
1273        VolumeControlEventStream { event_receiver: self.client.take_event_receiver() }
1274    }
1275
1276    /// Sets the volume of the audio element to the given value in
1277    /// [0.0, 1.0]. If the value is provided is outside of [0.0, 1.0],
1278    /// the value is clamped before application.
1279    pub fn r#set_volume(&self, mut volume: f32) -> Result<(), fidl::Error> {
1280        VolumeControlProxyInterface::r#set_volume(self, volume)
1281    }
1282
1283    /// Sets whether the controlled element is muted. Mute is not the same
1284    /// as setting volume to 0.0; volume will persist for the duration of
1285    /// a mute. If volume was 0.5 before mute, volume will resume at 0.5
1286    /// following unmute.
1287    pub fn r#set_mute(&self, mut mute: bool) -> Result<(), fidl::Error> {
1288        VolumeControlProxyInterface::r#set_mute(self, mute)
1289    }
1290}
1291
1292impl VolumeControlProxyInterface for VolumeControlProxy {
1293    fn r#set_volume(&self, mut volume: f32) -> Result<(), fidl::Error> {
1294        self.client.send::<VolumeControlSetVolumeRequest>(
1295            (volume,),
1296            0x6ff4231809a697da,
1297            fidl::encoding::DynamicFlags::empty(),
1298        )
1299    }
1300
1301    fn r#set_mute(&self, mut mute: bool) -> Result<(), fidl::Error> {
1302        self.client.send::<VolumeControlSetMuteRequest>(
1303            (mute,),
1304            0x50c10c28bba46425,
1305            fidl::encoding::DynamicFlags::empty(),
1306        )
1307    }
1308}
1309
1310pub struct VolumeControlEventStream {
1311    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
1312}
1313
1314impl std::marker::Unpin for VolumeControlEventStream {}
1315
1316impl futures::stream::FusedStream for VolumeControlEventStream {
1317    fn is_terminated(&self) -> bool {
1318        self.event_receiver.is_terminated()
1319    }
1320}
1321
1322impl futures::Stream for VolumeControlEventStream {
1323    type Item = Result<VolumeControlEvent, fidl::Error>;
1324
1325    fn poll_next(
1326        mut self: std::pin::Pin<&mut Self>,
1327        cx: &mut std::task::Context<'_>,
1328    ) -> std::task::Poll<Option<Self::Item>> {
1329        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
1330            &mut self.event_receiver,
1331            cx
1332        )?) {
1333            Some(buf) => std::task::Poll::Ready(Some(VolumeControlEvent::decode(buf))),
1334            None => std::task::Poll::Ready(None),
1335        }
1336    }
1337}
1338
1339#[derive(Debug)]
1340pub enum VolumeControlEvent {
1341    OnVolumeMuteChanged { new_volume: f32, new_muted: bool },
1342}
1343
1344impl VolumeControlEvent {
1345    #[allow(irrefutable_let_patterns)]
1346    pub fn into_on_volume_mute_changed(self) -> Option<(f32, bool)> {
1347        if let VolumeControlEvent::OnVolumeMuteChanged { new_volume, new_muted } = self {
1348            Some((new_volume, new_muted))
1349        } else {
1350            None
1351        }
1352    }
1353
1354    /// Decodes a message buffer as a [`VolumeControlEvent`].
1355    fn decode(
1356        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
1357    ) -> Result<VolumeControlEvent, fidl::Error> {
1358        let (bytes, _handles) = buf.split_mut();
1359        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1360        debug_assert_eq!(tx_header.tx_id, 0);
1361        match tx_header.ordinal {
1362            0x9cea352bd86c171 => {
1363                let mut out = fidl::new_empty!(
1364                    VolumeControlOnVolumeMuteChangedRequest,
1365                    fidl::encoding::DefaultFuchsiaResourceDialect
1366                );
1367                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VolumeControlOnVolumeMuteChangedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
1368                Ok((VolumeControlEvent::OnVolumeMuteChanged {
1369                    new_volume: out.new_volume,
1370                    new_muted: out.new_muted,
1371                }))
1372            }
1373            _ => Err(fidl::Error::UnknownOrdinal {
1374                ordinal: tx_header.ordinal,
1375                protocol_name: <VolumeControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1376            }),
1377        }
1378    }
1379}
1380
1381/// A Stream of incoming requests for fuchsia.media.audio/VolumeControl.
1382pub struct VolumeControlRequestStream {
1383    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1384    is_terminated: bool,
1385}
1386
1387impl std::marker::Unpin for VolumeControlRequestStream {}
1388
1389impl futures::stream::FusedStream for VolumeControlRequestStream {
1390    fn is_terminated(&self) -> bool {
1391        self.is_terminated
1392    }
1393}
1394
1395impl fidl::endpoints::RequestStream for VolumeControlRequestStream {
1396    type Protocol = VolumeControlMarker;
1397    type ControlHandle = VolumeControlControlHandle;
1398
1399    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
1400        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
1401    }
1402
1403    fn control_handle(&self) -> Self::ControlHandle {
1404        VolumeControlControlHandle { inner: self.inner.clone() }
1405    }
1406
1407    fn into_inner(
1408        self,
1409    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1410    {
1411        (self.inner, self.is_terminated)
1412    }
1413
1414    fn from_inner(
1415        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1416        is_terminated: bool,
1417    ) -> Self {
1418        Self { inner, is_terminated }
1419    }
1420}
1421
1422impl futures::Stream for VolumeControlRequestStream {
1423    type Item = Result<VolumeControlRequest, fidl::Error>;
1424
1425    fn poll_next(
1426        mut self: std::pin::Pin<&mut Self>,
1427        cx: &mut std::task::Context<'_>,
1428    ) -> std::task::Poll<Option<Self::Item>> {
1429        let this = &mut *self;
1430        if this.inner.check_shutdown(cx) {
1431            this.is_terminated = true;
1432            return std::task::Poll::Ready(None);
1433        }
1434        if this.is_terminated {
1435            panic!("polled VolumeControlRequestStream after completion");
1436        }
1437        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1438            |bytes, handles| {
1439                match this.inner.channel().read_etc(cx, bytes, handles) {
1440                    std::task::Poll::Ready(Ok(())) => {}
1441                    std::task::Poll::Pending => return std::task::Poll::Pending,
1442                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1443                        this.is_terminated = true;
1444                        return std::task::Poll::Ready(None);
1445                    }
1446                    std::task::Poll::Ready(Err(e)) => {
1447                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1448                            e.into(),
1449                        ))))
1450                    }
1451                }
1452
1453                // A message has been received from the channel
1454                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1455
1456                std::task::Poll::Ready(Some(match header.ordinal {
1457                    0x6ff4231809a697da => {
1458                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
1459                        let mut req = fidl::new_empty!(
1460                            VolumeControlSetVolumeRequest,
1461                            fidl::encoding::DefaultFuchsiaResourceDialect
1462                        );
1463                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VolumeControlSetVolumeRequest>(&header, _body_bytes, handles, &mut req)?;
1464                        let control_handle =
1465                            VolumeControlControlHandle { inner: this.inner.clone() };
1466                        Ok(VolumeControlRequest::SetVolume { volume: req.volume, control_handle })
1467                    }
1468                    0x50c10c28bba46425 => {
1469                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
1470                        let mut req = fidl::new_empty!(
1471                            VolumeControlSetMuteRequest,
1472                            fidl::encoding::DefaultFuchsiaResourceDialect
1473                        );
1474                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VolumeControlSetMuteRequest>(&header, _body_bytes, handles, &mut req)?;
1475                        let control_handle =
1476                            VolumeControlControlHandle { inner: this.inner.clone() };
1477                        Ok(VolumeControlRequest::SetMute { mute: req.mute, control_handle })
1478                    }
1479                    _ => Err(fidl::Error::UnknownOrdinal {
1480                        ordinal: header.ordinal,
1481                        protocol_name:
1482                            <VolumeControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1483                    }),
1484                }))
1485            },
1486        )
1487    }
1488}
1489
1490/// A protocol for controlling volume.
1491#[derive(Debug)]
1492pub enum VolumeControlRequest {
1493    /// Sets the volume of the audio element to the given value in
1494    /// [0.0, 1.0]. If the value is provided is outside of [0.0, 1.0],
1495    /// the value is clamped before application.
1496    SetVolume { volume: f32, control_handle: VolumeControlControlHandle },
1497    /// Sets whether the controlled element is muted. Mute is not the same
1498    /// as setting volume to 0.0; volume will persist for the duration of
1499    /// a mute. If volume was 0.5 before mute, volume will resume at 0.5
1500    /// following unmute.
1501    SetMute { mute: bool, control_handle: VolumeControlControlHandle },
1502}
1503
1504impl VolumeControlRequest {
1505    #[allow(irrefutable_let_patterns)]
1506    pub fn into_set_volume(self) -> Option<(f32, VolumeControlControlHandle)> {
1507        if let VolumeControlRequest::SetVolume { volume, control_handle } = self {
1508            Some((volume, control_handle))
1509        } else {
1510            None
1511        }
1512    }
1513
1514    #[allow(irrefutable_let_patterns)]
1515    pub fn into_set_mute(self) -> Option<(bool, VolumeControlControlHandle)> {
1516        if let VolumeControlRequest::SetMute { mute, control_handle } = self {
1517            Some((mute, control_handle))
1518        } else {
1519            None
1520        }
1521    }
1522
1523    /// Name of the method defined in FIDL
1524    pub fn method_name(&self) -> &'static str {
1525        match *self {
1526            VolumeControlRequest::SetVolume { .. } => "set_volume",
1527            VolumeControlRequest::SetMute { .. } => "set_mute",
1528        }
1529    }
1530}
1531
1532#[derive(Debug, Clone)]
1533pub struct VolumeControlControlHandle {
1534    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1535}
1536
1537impl fidl::endpoints::ControlHandle for VolumeControlControlHandle {
1538    fn shutdown(&self) {
1539        self.inner.shutdown()
1540    }
1541    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1542        self.inner.shutdown_with_epitaph(status)
1543    }
1544
1545    fn is_closed(&self) -> bool {
1546        self.inner.channel().is_closed()
1547    }
1548    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1549        self.inner.channel().on_closed()
1550    }
1551
1552    #[cfg(target_os = "fuchsia")]
1553    fn signal_peer(
1554        &self,
1555        clear_mask: zx::Signals,
1556        set_mask: zx::Signals,
1557    ) -> Result<(), zx_status::Status> {
1558        use fidl::Peered;
1559        self.inner.channel().signal_peer(clear_mask, set_mask)
1560    }
1561}
1562
1563impl VolumeControlControlHandle {
1564    pub fn send_on_volume_mute_changed(
1565        &self,
1566        mut new_volume: f32,
1567        mut new_muted: bool,
1568    ) -> Result<(), fidl::Error> {
1569        self.inner.send::<VolumeControlOnVolumeMuteChangedRequest>(
1570            (new_volume, new_muted),
1571            0,
1572            0x9cea352bd86c171,
1573            fidl::encoding::DynamicFlags::empty(),
1574        )
1575    }
1576}
1577
1578mod internal {
1579    use super::*;
1580}
fidl_fuchsia_media_audio/fidl_fuchsia_media_audio.rs

fidl_fuchsia_media_audio/
fidl_fuchsia_media_audio.rs
