fidl_fuchsia_ui_policy/
fidl_fuchsia_ui_policy.rs

Help
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_ui_policy_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
15pub struct DeviceListenerRegistryRegisterListenerRequest {
16    pub listener: fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>,
17}
18
19impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
20    for DeviceListenerRegistryRegisterListenerRequest
21{
22}
23
24#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
25pub struct DeviceListenerRegistryRegisterMediaButtonsListenerRequest {
26    pub listener: fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>,
27}
28
29impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
30    for DeviceListenerRegistryRegisterMediaButtonsListenerRequest
31{
32}
33
34#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
35pub struct DeviceListenerRegistryMarker;
36
37impl fidl::endpoints::ProtocolMarker for DeviceListenerRegistryMarker {
38    type Proxy = DeviceListenerRegistryProxy;
39    type RequestStream = DeviceListenerRegistryRequestStream;
40    #[cfg(target_os = "fuchsia")]
41    type SynchronousProxy = DeviceListenerRegistrySynchronousProxy;
42
43    const DEBUG_NAME: &'static str = "fuchsia.ui.policy.DeviceListenerRegistry";
44}
45impl fidl::endpoints::DiscoverableProtocolMarker for DeviceListenerRegistryMarker {}
46
47pub trait DeviceListenerRegistryProxyInterface: Send + Sync {
48    fn r#register_media_buttons_listener(
49        &self,
50        listener: fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>,
51    ) -> Result<(), fidl::Error>;
52    type RegisterListenerResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
53    fn r#register_listener(
54        &self,
55        listener: fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>,
56    ) -> Self::RegisterListenerResponseFut;
57}
58#[derive(Debug)]
59#[cfg(target_os = "fuchsia")]
60pub struct DeviceListenerRegistrySynchronousProxy {
61    client: fidl::client::sync::Client,
62}
63
64#[cfg(target_os = "fuchsia")]
65impl fidl::endpoints::SynchronousProxy for DeviceListenerRegistrySynchronousProxy {
66    type Proxy = DeviceListenerRegistryProxy;
67    type Protocol = DeviceListenerRegistryMarker;
68
69    fn from_channel(inner: fidl::Channel) -> Self {
70        Self::new(inner)
71    }
72
73    fn into_channel(self) -> fidl::Channel {
74        self.client.into_channel()
75    }
76
77    fn as_channel(&self) -> &fidl::Channel {
78        self.client.as_channel()
79    }
80}
81
82#[cfg(target_os = "fuchsia")]
83impl DeviceListenerRegistrySynchronousProxy {
84    pub fn new(channel: fidl::Channel) -> Self {
85        let protocol_name =
86            <DeviceListenerRegistryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
87        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
88    }
89
90    pub fn into_channel(self) -> fidl::Channel {
91        self.client.into_channel()
92    }
93
94    /// Waits until an event arrives and returns it. It is safe for other
95    /// threads to make concurrent requests while waiting for an event.
96    pub fn wait_for_event(
97        &self,
98        deadline: zx::MonotonicInstant,
99    ) -> Result<DeviceListenerRegistryEvent, fidl::Error> {
100        DeviceListenerRegistryEvent::decode(self.client.wait_for_event(deadline)?)
101    }
102
103    /// Registers a listener to receive media button related events, such as
104    /// changes from volume buttons and mute switches.
105    pub fn r#register_media_buttons_listener(
106        &self,
107        mut listener: fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>,
108    ) -> Result<(), fidl::Error> {
109        self.client.send::<DeviceListenerRegistryRegisterMediaButtonsListenerRequest>(
110            (listener,),
111            0x3826318765c72e70,
112            fidl::encoding::DynamicFlags::empty(),
113        )
114    }
115
116    /// Registers a listener to receive media button related events, such as
117    /// changes from volume buttons and mute switches.
118    /// On registration, the `listener` receives the last media button event that
119    /// occurred, if one exists, and all media button events going forward.
120    pub fn r#register_listener(
121        &self,
122        mut listener: fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>,
123        ___deadline: zx::MonotonicInstant,
124    ) -> Result<(), fidl::Error> {
125        let _response = self.client.send_query::<
126            DeviceListenerRegistryRegisterListenerRequest,
127            fidl::encoding::EmptyPayload,
128        >(
129            (listener,),
130            0x2f9e7eea89485a7b,
131            fidl::encoding::DynamicFlags::empty(),
132            ___deadline,
133        )?;
134        Ok(_response)
135    }
136}
137
138#[derive(Debug, Clone)]
139pub struct DeviceListenerRegistryProxy {
140    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
141}
142
143impl fidl::endpoints::Proxy for DeviceListenerRegistryProxy {
144    type Protocol = DeviceListenerRegistryMarker;
145
146    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
147        Self::new(inner)
148    }
149
150    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
151        self.client.into_channel().map_err(|client| Self { client })
152    }
153
154    fn as_channel(&self) -> &::fidl::AsyncChannel {
155        self.client.as_channel()
156    }
157}
158
159impl DeviceListenerRegistryProxy {
160    /// Create a new Proxy for fuchsia.ui.policy/DeviceListenerRegistry.
161    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
162        let protocol_name =
163            <DeviceListenerRegistryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
164        Self { client: fidl::client::Client::new(channel, protocol_name) }
165    }
166
167    /// Get a Stream of events from the remote end of the protocol.
168    ///
169    /// # Panics
170    ///
171    /// Panics if the event stream was already taken.
172    pub fn take_event_stream(&self) -> DeviceListenerRegistryEventStream {
173        DeviceListenerRegistryEventStream { event_receiver: self.client.take_event_receiver() }
174    }
175
176    /// Registers a listener to receive media button related events, such as
177    /// changes from volume buttons and mute switches.
178    pub fn r#register_media_buttons_listener(
179        &self,
180        mut listener: fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>,
181    ) -> Result<(), fidl::Error> {
182        DeviceListenerRegistryProxyInterface::r#register_media_buttons_listener(self, listener)
183    }
184
185    /// Registers a listener to receive media button related events, such as
186    /// changes from volume buttons and mute switches.
187    /// On registration, the `listener` receives the last media button event that
188    /// occurred, if one exists, and all media button events going forward.
189    pub fn r#register_listener(
190        &self,
191        mut listener: fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>,
192    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
193        DeviceListenerRegistryProxyInterface::r#register_listener(self, listener)
194    }
195}
196
197impl DeviceListenerRegistryProxyInterface for DeviceListenerRegistryProxy {
198    fn r#register_media_buttons_listener(
199        &self,
200        mut listener: fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>,
201    ) -> Result<(), fidl::Error> {
202        self.client.send::<DeviceListenerRegistryRegisterMediaButtonsListenerRequest>(
203            (listener,),
204            0x3826318765c72e70,
205            fidl::encoding::DynamicFlags::empty(),
206        )
207    }
208
209    type RegisterListenerResponseFut =
210        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
211    fn r#register_listener(
212        &self,
213        mut listener: fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>,
214    ) -> Self::RegisterListenerResponseFut {
215        fn _decode(
216            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
217        ) -> Result<(), fidl::Error> {
218            let _response = fidl::client::decode_transaction_body::<
219                fidl::encoding::EmptyPayload,
220                fidl::encoding::DefaultFuchsiaResourceDialect,
221                0x2f9e7eea89485a7b,
222            >(_buf?)?;
223            Ok(_response)
224        }
225        self.client.send_query_and_decode::<DeviceListenerRegistryRegisterListenerRequest, ()>(
226            (listener,),
227            0x2f9e7eea89485a7b,
228            fidl::encoding::DynamicFlags::empty(),
229            _decode,
230        )
231    }
232}
233
234pub struct DeviceListenerRegistryEventStream {
235    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
236}
237
238impl std::marker::Unpin for DeviceListenerRegistryEventStream {}
239
240impl futures::stream::FusedStream for DeviceListenerRegistryEventStream {
241    fn is_terminated(&self) -> bool {
242        self.event_receiver.is_terminated()
243    }
244}
245
246impl futures::Stream for DeviceListenerRegistryEventStream {
247    type Item = Result<DeviceListenerRegistryEvent, fidl::Error>;
248
249    fn poll_next(
250        mut self: std::pin::Pin<&mut Self>,
251        cx: &mut std::task::Context<'_>,
252    ) -> std::task::Poll<Option<Self::Item>> {
253        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
254            &mut self.event_receiver,
255            cx
256        )?) {
257            Some(buf) => std::task::Poll::Ready(Some(DeviceListenerRegistryEvent::decode(buf))),
258            None => std::task::Poll::Ready(None),
259        }
260    }
261}
262
263#[derive(Debug)]
264pub enum DeviceListenerRegistryEvent {}
265
266impl DeviceListenerRegistryEvent {
267    /// Decodes a message buffer as a [`DeviceListenerRegistryEvent`].
268    fn decode(
269        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
270    ) -> Result<DeviceListenerRegistryEvent, fidl::Error> {
271        let (bytes, _handles) = buf.split_mut();
272        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
273        debug_assert_eq!(tx_header.tx_id, 0);
274        match tx_header.ordinal {
275            _ => Err(fidl::Error::UnknownOrdinal {
276                ordinal: tx_header.ordinal,
277                protocol_name:
278                    <DeviceListenerRegistryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
279            }),
280        }
281    }
282}
283
284/// A Stream of incoming requests for fuchsia.ui.policy/DeviceListenerRegistry.
285pub struct DeviceListenerRegistryRequestStream {
286    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
287    is_terminated: bool,
288}
289
290impl std::marker::Unpin for DeviceListenerRegistryRequestStream {}
291
292impl futures::stream::FusedStream for DeviceListenerRegistryRequestStream {
293    fn is_terminated(&self) -> bool {
294        self.is_terminated
295    }
296}
297
298impl fidl::endpoints::RequestStream for DeviceListenerRegistryRequestStream {
299    type Protocol = DeviceListenerRegistryMarker;
300    type ControlHandle = DeviceListenerRegistryControlHandle;
301
302    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
303        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
304    }
305
306    fn control_handle(&self) -> Self::ControlHandle {
307        DeviceListenerRegistryControlHandle { inner: self.inner.clone() }
308    }
309
310    fn into_inner(
311        self,
312    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
313    {
314        (self.inner, self.is_terminated)
315    }
316
317    fn from_inner(
318        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
319        is_terminated: bool,
320    ) -> Self {
321        Self { inner, is_terminated }
322    }
323}
324
325impl futures::Stream for DeviceListenerRegistryRequestStream {
326    type Item = Result<DeviceListenerRegistryRequest, fidl::Error>;
327
328    fn poll_next(
329        mut self: std::pin::Pin<&mut Self>,
330        cx: &mut std::task::Context<'_>,
331    ) -> std::task::Poll<Option<Self::Item>> {
332        let this = &mut *self;
333        if this.inner.check_shutdown(cx) {
334            this.is_terminated = true;
335            return std::task::Poll::Ready(None);
336        }
337        if this.is_terminated {
338            panic!("polled DeviceListenerRegistryRequestStream after completion");
339        }
340        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
341            |bytes, handles| {
342                match this.inner.channel().read_etc(cx, bytes, handles) {
343                    std::task::Poll::Ready(Ok(())) => {}
344                    std::task::Poll::Pending => return std::task::Poll::Pending,
345                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
346                        this.is_terminated = true;
347                        return std::task::Poll::Ready(None);
348                    }
349                    std::task::Poll::Ready(Err(e)) => {
350                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
351                            e.into(),
352                        ))))
353                    }
354                }
355
356                // A message has been received from the channel
357                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
358
359                std::task::Poll::Ready(Some(match header.ordinal {
360                0x3826318765c72e70 => {
361                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
362                    let mut req = fidl::new_empty!(DeviceListenerRegistryRegisterMediaButtonsListenerRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
363                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceListenerRegistryRegisterMediaButtonsListenerRequest>(&header, _body_bytes, handles, &mut req)?;
364                    let control_handle = DeviceListenerRegistryControlHandle {
365                        inner: this.inner.clone(),
366                    };
367                    Ok(DeviceListenerRegistryRequest::RegisterMediaButtonsListener {listener: req.listener,
368
369                        control_handle,
370                    })
371                }
372                0x2f9e7eea89485a7b => {
373                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
374                    let mut req = fidl::new_empty!(DeviceListenerRegistryRegisterListenerRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
375                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceListenerRegistryRegisterListenerRequest>(&header, _body_bytes, handles, &mut req)?;
376                    let control_handle = DeviceListenerRegistryControlHandle {
377                        inner: this.inner.clone(),
378                    };
379                    Ok(DeviceListenerRegistryRequest::RegisterListener {listener: req.listener,
380
381                        responder: DeviceListenerRegistryRegisterListenerResponder {
382                            control_handle: std::mem::ManuallyDrop::new(control_handle),
383                            tx_id: header.tx_id,
384                        },
385                    })
386                }
387                _ => Err(fidl::Error::UnknownOrdinal {
388                    ordinal: header.ordinal,
389                    protocol_name: <DeviceListenerRegistryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
390                }),
391            }))
392            },
393        )
394    }
395}
396
397/// Service for exposing state and events of devices, such as media buttons.
398#[derive(Debug)]
399pub enum DeviceListenerRegistryRequest {
400    /// Registers a listener to receive media button related events, such as
401    /// changes from volume buttons and mute switches.
402    RegisterMediaButtonsListener {
403        listener: fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>,
404        control_handle: DeviceListenerRegistryControlHandle,
405    },
406    /// Registers a listener to receive media button related events, such as
407    /// changes from volume buttons and mute switches.
408    /// On registration, the `listener` receives the last media button event that
409    /// occurred, if one exists, and all media button events going forward.
410    RegisterListener {
411        listener: fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>,
412        responder: DeviceListenerRegistryRegisterListenerResponder,
413    },
414}
415
416impl DeviceListenerRegistryRequest {
417    #[allow(irrefutable_let_patterns)]
418    pub fn into_register_media_buttons_listener(
419        self,
420    ) -> Option<(
421        fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>,
422        DeviceListenerRegistryControlHandle,
423    )> {
424        if let DeviceListenerRegistryRequest::RegisterMediaButtonsListener {
425            listener,
426            control_handle,
427        } = self
428        {
429            Some((listener, control_handle))
430        } else {
431            None
432        }
433    }
434
435    #[allow(irrefutable_let_patterns)]
436    pub fn into_register_listener(
437        self,
438    ) -> Option<(
439        fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>,
440        DeviceListenerRegistryRegisterListenerResponder,
441    )> {
442        if let DeviceListenerRegistryRequest::RegisterListener { listener, responder } = self {
443            Some((listener, responder))
444        } else {
445            None
446        }
447    }
448
449    /// Name of the method defined in FIDL
450    pub fn method_name(&self) -> &'static str {
451        match *self {
452            DeviceListenerRegistryRequest::RegisterMediaButtonsListener { .. } => {
453                "register_media_buttons_listener"
454            }
455            DeviceListenerRegistryRequest::RegisterListener { .. } => "register_listener",
456        }
457    }
458}
459
460#[derive(Debug, Clone)]
461pub struct DeviceListenerRegistryControlHandle {
462    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
463}
464
465impl fidl::endpoints::ControlHandle for DeviceListenerRegistryControlHandle {
466    fn shutdown(&self) {
467        self.inner.shutdown()
468    }
469    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
470        self.inner.shutdown_with_epitaph(status)
471    }
472
473    fn is_closed(&self) -> bool {
474        self.inner.channel().is_closed()
475    }
476    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
477        self.inner.channel().on_closed()
478    }
479
480    #[cfg(target_os = "fuchsia")]
481    fn signal_peer(
482        &self,
483        clear_mask: zx::Signals,
484        set_mask: zx::Signals,
485    ) -> Result<(), zx_status::Status> {
486        use fidl::Peered;
487        self.inner.channel().signal_peer(clear_mask, set_mask)
488    }
489}
490
491impl DeviceListenerRegistryControlHandle {}
492
493#[must_use = "FIDL methods require a response to be sent"]
494#[derive(Debug)]
495pub struct DeviceListenerRegistryRegisterListenerResponder {
496    control_handle: std::mem::ManuallyDrop<DeviceListenerRegistryControlHandle>,
497    tx_id: u32,
498}
499
500/// Set the the channel to be shutdown (see [`DeviceListenerRegistryControlHandle::shutdown`])
501/// if the responder is dropped without sending a response, so that the client
502/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
503impl std::ops::Drop for DeviceListenerRegistryRegisterListenerResponder {
504    fn drop(&mut self) {
505        self.control_handle.shutdown();
506        // Safety: drops once, never accessed again
507        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
508    }
509}
510
511impl fidl::endpoints::Responder for DeviceListenerRegistryRegisterListenerResponder {
512    type ControlHandle = DeviceListenerRegistryControlHandle;
513
514    fn control_handle(&self) -> &DeviceListenerRegistryControlHandle {
515        &self.control_handle
516    }
517
518    fn drop_without_shutdown(mut self) {
519        // Safety: drops once, never accessed again due to mem::forget
520        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
521        // Prevent Drop from running (which would shut down the channel)
522        std::mem::forget(self);
523    }
524}
525
526impl DeviceListenerRegistryRegisterListenerResponder {
527    /// Sends a response to the FIDL transaction.
528    ///
529    /// Sets the channel to shutdown if an error occurs.
530    pub fn send(self) -> Result<(), fidl::Error> {
531        let _result = self.send_raw();
532        if _result.is_err() {
533            self.control_handle.shutdown();
534        }
535        self.drop_without_shutdown();
536        _result
537    }
538
539    /// Similar to "send" but does not shutdown the channel if an error occurs.
540    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
541        let _result = self.send_raw();
542        self.drop_without_shutdown();
543        _result
544    }
545
546    fn send_raw(&self) -> Result<(), fidl::Error> {
547        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
548            (),
549            self.tx_id,
550            0x2f9e7eea89485a7b,
551            fidl::encoding::DynamicFlags::empty(),
552        )
553    }
554}
555
556#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
557pub struct DisplayBacklightMarker;
558
559impl fidl::endpoints::ProtocolMarker for DisplayBacklightMarker {
560    type Proxy = DisplayBacklightProxy;
561    type RequestStream = DisplayBacklightRequestStream;
562    #[cfg(target_os = "fuchsia")]
563    type SynchronousProxy = DisplayBacklightSynchronousProxy;
564
565    const DEBUG_NAME: &'static str = "fuchsia.ui.policy.DisplayBacklight";
566}
567impl fidl::endpoints::DiscoverableProtocolMarker for DisplayBacklightMarker {}
568
569pub trait DisplayBacklightProxyInterface: Send + Sync {
570    type SetMinimumRgbResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
571    fn r#set_minimum_rgb(&self, minimum_rgb: u8) -> Self::SetMinimumRgbResponseFut;
572}
573#[derive(Debug)]
574#[cfg(target_os = "fuchsia")]
575pub struct DisplayBacklightSynchronousProxy {
576    client: fidl::client::sync::Client,
577}
578
579#[cfg(target_os = "fuchsia")]
580impl fidl::endpoints::SynchronousProxy for DisplayBacklightSynchronousProxy {
581    type Proxy = DisplayBacklightProxy;
582    type Protocol = DisplayBacklightMarker;
583
584    fn from_channel(inner: fidl::Channel) -> Self {
585        Self::new(inner)
586    }
587
588    fn into_channel(self) -> fidl::Channel {
589        self.client.into_channel()
590    }
591
592    fn as_channel(&self) -> &fidl::Channel {
593        self.client.as_channel()
594    }
595}
596
597#[cfg(target_os = "fuchsia")]
598impl DisplayBacklightSynchronousProxy {
599    pub fn new(channel: fidl::Channel) -> Self {
600        let protocol_name = <DisplayBacklightMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
601        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
602    }
603
604    pub fn into_channel(self) -> fidl::Channel {
605        self.client.into_channel()
606    }
607
608    /// Waits until an event arrives and returns it. It is safe for other
609    /// threads to make concurrent requests while waiting for an event.
610    pub fn wait_for_event(
611        &self,
612        deadline: zx::MonotonicInstant,
613    ) -> Result<DisplayBacklightEvent, fidl::Error> {
614        DisplayBacklightEvent::decode(self.client.wait_for_event(deadline)?)
615    }
616
617    /// Submits a new minimum color channel value for display backlight.
618    ///
619    /// The valid range for a minimum value is [0, 255] (inclusive).  For a new
620    /// minimum value M, each color channel's range will be limited to [M, 255].
621    ///
622    /// Flow control: The caller is allowed at most one in-flight
623    /// |SetMinimumRgb| at at time. Subsequent calls must wait until the
624    /// acknowledgment returns. Non-compliance results in channel closure.
625    pub fn r#set_minimum_rgb(
626        &self,
627        mut minimum_rgb: u8,
628        ___deadline: zx::MonotonicInstant,
629    ) -> Result<(), fidl::Error> {
630        let _response = self
631            .client
632            .send_query::<DisplayBacklightSetMinimumRgbRequest, fidl::encoding::EmptyPayload>(
633                (minimum_rgb,),
634                0x25604347bb8a1ca3,
635                fidl::encoding::DynamicFlags::empty(),
636                ___deadline,
637            )?;
638        Ok(_response)
639    }
640}
641
642#[derive(Debug, Clone)]
643pub struct DisplayBacklightProxy {
644    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
645}
646
647impl fidl::endpoints::Proxy for DisplayBacklightProxy {
648    type Protocol = DisplayBacklightMarker;
649
650    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
651        Self::new(inner)
652    }
653
654    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
655        self.client.into_channel().map_err(|client| Self { client })
656    }
657
658    fn as_channel(&self) -> &::fidl::AsyncChannel {
659        self.client.as_channel()
660    }
661}
662
663impl DisplayBacklightProxy {
664    /// Create a new Proxy for fuchsia.ui.policy/DisplayBacklight.
665    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
666        let protocol_name = <DisplayBacklightMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
667        Self { client: fidl::client::Client::new(channel, protocol_name) }
668    }
669
670    /// Get a Stream of events from the remote end of the protocol.
671    ///
672    /// # Panics
673    ///
674    /// Panics if the event stream was already taken.
675    pub fn take_event_stream(&self) -> DisplayBacklightEventStream {
676        DisplayBacklightEventStream { event_receiver: self.client.take_event_receiver() }
677    }
678
679    /// Submits a new minimum color channel value for display backlight.
680    ///
681    /// The valid range for a minimum value is [0, 255] (inclusive).  For a new
682    /// minimum value M, each color channel's range will be limited to [M, 255].
683    ///
684    /// Flow control: The caller is allowed at most one in-flight
685    /// |SetMinimumRgb| at at time. Subsequent calls must wait until the
686    /// acknowledgment returns. Non-compliance results in channel closure.
687    pub fn r#set_minimum_rgb(
688        &self,
689        mut minimum_rgb: u8,
690    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
691        DisplayBacklightProxyInterface::r#set_minimum_rgb(self, minimum_rgb)
692    }
693}
694
695impl DisplayBacklightProxyInterface for DisplayBacklightProxy {
696    type SetMinimumRgbResponseFut =
697        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
698    fn r#set_minimum_rgb(&self, mut minimum_rgb: u8) -> Self::SetMinimumRgbResponseFut {
699        fn _decode(
700            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
701        ) -> Result<(), fidl::Error> {
702            let _response = fidl::client::decode_transaction_body::<
703                fidl::encoding::EmptyPayload,
704                fidl::encoding::DefaultFuchsiaResourceDialect,
705                0x25604347bb8a1ca3,
706            >(_buf?)?;
707            Ok(_response)
708        }
709        self.client.send_query_and_decode::<DisplayBacklightSetMinimumRgbRequest, ()>(
710            (minimum_rgb,),
711            0x25604347bb8a1ca3,
712            fidl::encoding::DynamicFlags::empty(),
713            _decode,
714        )
715    }
716}
717
718pub struct DisplayBacklightEventStream {
719    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
720}
721
722impl std::marker::Unpin for DisplayBacklightEventStream {}
723
724impl futures::stream::FusedStream for DisplayBacklightEventStream {
725    fn is_terminated(&self) -> bool {
726        self.event_receiver.is_terminated()
727    }
728}
729
730impl futures::Stream for DisplayBacklightEventStream {
731    type Item = Result<DisplayBacklightEvent, fidl::Error>;
732
733    fn poll_next(
734        mut self: std::pin::Pin<&mut Self>,
735        cx: &mut std::task::Context<'_>,
736    ) -> std::task::Poll<Option<Self::Item>> {
737        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
738            &mut self.event_receiver,
739            cx
740        )?) {
741            Some(buf) => std::task::Poll::Ready(Some(DisplayBacklightEvent::decode(buf))),
742            None => std::task::Poll::Ready(None),
743        }
744    }
745}
746
747#[derive(Debug)]
748pub enum DisplayBacklightEvent {}
749
750impl DisplayBacklightEvent {
751    /// Decodes a message buffer as a [`DisplayBacklightEvent`].
752    fn decode(
753        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
754    ) -> Result<DisplayBacklightEvent, fidl::Error> {
755        let (bytes, _handles) = buf.split_mut();
756        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
757        debug_assert_eq!(tx_header.tx_id, 0);
758        match tx_header.ordinal {
759            _ => Err(fidl::Error::UnknownOrdinal {
760                ordinal: tx_header.ordinal,
761                protocol_name:
762                    <DisplayBacklightMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
763            }),
764        }
765    }
766}
767
768/// A Stream of incoming requests for fuchsia.ui.policy/DisplayBacklight.
769pub struct DisplayBacklightRequestStream {
770    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
771    is_terminated: bool,
772}
773
774impl std::marker::Unpin for DisplayBacklightRequestStream {}
775
776impl futures::stream::FusedStream for DisplayBacklightRequestStream {
777    fn is_terminated(&self) -> bool {
778        self.is_terminated
779    }
780}
781
782impl fidl::endpoints::RequestStream for DisplayBacklightRequestStream {
783    type Protocol = DisplayBacklightMarker;
784    type ControlHandle = DisplayBacklightControlHandle;
785
786    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
787        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
788    }
789
790    fn control_handle(&self) -> Self::ControlHandle {
791        DisplayBacklightControlHandle { inner: self.inner.clone() }
792    }
793
794    fn into_inner(
795        self,
796    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
797    {
798        (self.inner, self.is_terminated)
799    }
800
801    fn from_inner(
802        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
803        is_terminated: bool,
804    ) -> Self {
805        Self { inner, is_terminated }
806    }
807}
808
809impl futures::Stream for DisplayBacklightRequestStream {
810    type Item = Result<DisplayBacklightRequest, fidl::Error>;
811
812    fn poll_next(
813        mut self: std::pin::Pin<&mut Self>,
814        cx: &mut std::task::Context<'_>,
815    ) -> std::task::Poll<Option<Self::Item>> {
816        let this = &mut *self;
817        if this.inner.check_shutdown(cx) {
818            this.is_terminated = true;
819            return std::task::Poll::Ready(None);
820        }
821        if this.is_terminated {
822            panic!("polled DisplayBacklightRequestStream after completion");
823        }
824        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
825            |bytes, handles| {
826                match this.inner.channel().read_etc(cx, bytes, handles) {
827                    std::task::Poll::Ready(Ok(())) => {}
828                    std::task::Poll::Pending => return std::task::Poll::Pending,
829                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
830                        this.is_terminated = true;
831                        return std::task::Poll::Ready(None);
832                    }
833                    std::task::Poll::Ready(Err(e)) => {
834                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
835                            e.into(),
836                        ))))
837                    }
838                }
839
840                // A message has been received from the channel
841                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
842
843                std::task::Poll::Ready(Some(match header.ordinal {
844                    0x25604347bb8a1ca3 => {
845                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
846                        let mut req = fidl::new_empty!(
847                            DisplayBacklightSetMinimumRgbRequest,
848                            fidl::encoding::DefaultFuchsiaResourceDialect
849                        );
850                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DisplayBacklightSetMinimumRgbRequest>(&header, _body_bytes, handles, &mut req)?;
851                        let control_handle =
852                            DisplayBacklightControlHandle { inner: this.inner.clone() };
853                        Ok(DisplayBacklightRequest::SetMinimumRgb {
854                            minimum_rgb: req.minimum_rgb,
855
856                            responder: DisplayBacklightSetMinimumRgbResponder {
857                                control_handle: std::mem::ManuallyDrop::new(control_handle),
858                                tx_id: header.tx_id,
859                            },
860                        })
861                    }
862                    _ => Err(fidl::Error::UnknownOrdinal {
863                        ordinal: header.ordinal,
864                        protocol_name:
865                            <DisplayBacklightMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
866                    }),
867                }))
868            },
869        )
870    }
871}
872
873/// Manipulates global policy for display backlight. Serves as the main "front
874/// end" interface for usage by UX components; other protocols (such as
875/// fuchsia.ui.scenic.Session and fuchsia.hardware.display.Controller) act as
876/// implementation.
877///
878/// Global Scope. All displays, in all display controllers, are affected uniformly.
879///
880/// Effect Timing. This protocol does not guarantee a deadline by which the
881/// minimum value is applied to a display; it is best effort.
882///
883/// Multiple clients. This protocol does not guarantee unique access to
884/// manipulate display backlight functionality.
885///
886/// Reference. Related to fuchsia.hardware.display.Controller.
887#[derive(Debug)]
888pub enum DisplayBacklightRequest {
889    /// Submits a new minimum color channel value for display backlight.
890    ///
891    /// The valid range for a minimum value is [0, 255] (inclusive).  For a new
892    /// minimum value M, each color channel's range will be limited to [M, 255].
893    ///
894    /// Flow control: The caller is allowed at most one in-flight
895    /// |SetMinimumRgb| at at time. Subsequent calls must wait until the
896    /// acknowledgment returns. Non-compliance results in channel closure.
897    SetMinimumRgb { minimum_rgb: u8, responder: DisplayBacklightSetMinimumRgbResponder },
898}
899
900impl DisplayBacklightRequest {
901    #[allow(irrefutable_let_patterns)]
902    pub fn into_set_minimum_rgb(self) -> Option<(u8, DisplayBacklightSetMinimumRgbResponder)> {
903        if let DisplayBacklightRequest::SetMinimumRgb { minimum_rgb, responder } = self {
904            Some((minimum_rgb, responder))
905        } else {
906            None
907        }
908    }
909
910    /// Name of the method defined in FIDL
911    pub fn method_name(&self) -> &'static str {
912        match *self {
913            DisplayBacklightRequest::SetMinimumRgb { .. } => "set_minimum_rgb",
914        }
915    }
916}
917
918#[derive(Debug, Clone)]
919pub struct DisplayBacklightControlHandle {
920    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
921}
922
923impl fidl::endpoints::ControlHandle for DisplayBacklightControlHandle {
924    fn shutdown(&self) {
925        self.inner.shutdown()
926    }
927    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
928        self.inner.shutdown_with_epitaph(status)
929    }
930
931    fn is_closed(&self) -> bool {
932        self.inner.channel().is_closed()
933    }
934    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
935        self.inner.channel().on_closed()
936    }
937
938    #[cfg(target_os = "fuchsia")]
939    fn signal_peer(
940        &self,
941        clear_mask: zx::Signals,
942        set_mask: zx::Signals,
943    ) -> Result<(), zx_status::Status> {
944        use fidl::Peered;
945        self.inner.channel().signal_peer(clear_mask, set_mask)
946    }
947}
948
949impl DisplayBacklightControlHandle {}
950
951#[must_use = "FIDL methods require a response to be sent"]
952#[derive(Debug)]
953pub struct DisplayBacklightSetMinimumRgbResponder {
954    control_handle: std::mem::ManuallyDrop<DisplayBacklightControlHandle>,
955    tx_id: u32,
956}
957
958/// Set the the channel to be shutdown (see [`DisplayBacklightControlHandle::shutdown`])
959/// if the responder is dropped without sending a response, so that the client
960/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
961impl std::ops::Drop for DisplayBacklightSetMinimumRgbResponder {
962    fn drop(&mut self) {
963        self.control_handle.shutdown();
964        // Safety: drops once, never accessed again
965        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
966    }
967}
968
969impl fidl::endpoints::Responder for DisplayBacklightSetMinimumRgbResponder {
970    type ControlHandle = DisplayBacklightControlHandle;
971
972    fn control_handle(&self) -> &DisplayBacklightControlHandle {
973        &self.control_handle
974    }
975
976    fn drop_without_shutdown(mut self) {
977        // Safety: drops once, never accessed again due to mem::forget
978        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
979        // Prevent Drop from running (which would shut down the channel)
980        std::mem::forget(self);
981    }
982}
983
984impl DisplayBacklightSetMinimumRgbResponder {
985    /// Sends a response to the FIDL transaction.
986    ///
987    /// Sets the channel to shutdown if an error occurs.
988    pub fn send(self) -> Result<(), fidl::Error> {
989        let _result = self.send_raw();
990        if _result.is_err() {
991            self.control_handle.shutdown();
992        }
993        self.drop_without_shutdown();
994        _result
995    }
996
997    /// Similar to "send" but does not shutdown the channel if an error occurs.
998    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
999        let _result = self.send_raw();
1000        self.drop_without_shutdown();
1001        _result
1002    }
1003
1004    fn send_raw(&self) -> Result<(), fidl::Error> {
1005        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
1006            (),
1007            self.tx_id,
1008            0x25604347bb8a1ca3,
1009            fidl::encoding::DynamicFlags::empty(),
1010        )
1011    }
1012}
1013
1014#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1015pub struct MediaButtonsListenerMarker;
1016
1017impl fidl::endpoints::ProtocolMarker for MediaButtonsListenerMarker {
1018    type Proxy = MediaButtonsListenerProxy;
1019    type RequestStream = MediaButtonsListenerRequestStream;
1020    #[cfg(target_os = "fuchsia")]
1021    type SynchronousProxy = MediaButtonsListenerSynchronousProxy;
1022
1023    const DEBUG_NAME: &'static str = "(anonymous) MediaButtonsListener";
1024}
1025
1026pub trait MediaButtonsListenerProxyInterface: Send + Sync {
1027    fn r#on_media_buttons_event(
1028        &self,
1029        event: &fidl_fuchsia_ui_input::MediaButtonsEvent,
1030    ) -> Result<(), fidl::Error>;
1031    type OnEventResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
1032    fn r#on_event(
1033        &self,
1034        event: &fidl_fuchsia_ui_input::MediaButtonsEvent,
1035    ) -> Self::OnEventResponseFut;
1036}
1037#[derive(Debug)]
1038#[cfg(target_os = "fuchsia")]
1039pub struct MediaButtonsListenerSynchronousProxy {
1040    client: fidl::client::sync::Client,
1041}
1042
1043#[cfg(target_os = "fuchsia")]
1044impl fidl::endpoints::SynchronousProxy for MediaButtonsListenerSynchronousProxy {
1045    type Proxy = MediaButtonsListenerProxy;
1046    type Protocol = MediaButtonsListenerMarker;
1047
1048    fn from_channel(inner: fidl::Channel) -> Self {
1049        Self::new(inner)
1050    }
1051
1052    fn into_channel(self) -> fidl::Channel {
1053        self.client.into_channel()
1054    }
1055
1056    fn as_channel(&self) -> &fidl::Channel {
1057        self.client.as_channel()
1058    }
1059}
1060
1061#[cfg(target_os = "fuchsia")]
1062impl MediaButtonsListenerSynchronousProxy {
1063    pub fn new(channel: fidl::Channel) -> Self {
1064        let protocol_name =
1065            <MediaButtonsListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1066        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
1067    }
1068
1069    pub fn into_channel(self) -> fidl::Channel {
1070        self.client.into_channel()
1071    }
1072
1073    /// Waits until an event arrives and returns it. It is safe for other
1074    /// threads to make concurrent requests while waiting for an event.
1075    pub fn wait_for_event(
1076        &self,
1077        deadline: zx::MonotonicInstant,
1078    ) -> Result<MediaButtonsListenerEvent, fidl::Error> {
1079        MediaButtonsListenerEvent::decode(self.client.wait_for_event(deadline)?)
1080    }
1081
1082    pub fn r#on_media_buttons_event(
1083        &self,
1084        mut event: &fidl_fuchsia_ui_input::MediaButtonsEvent,
1085    ) -> Result<(), fidl::Error> {
1086        self.client.send::<MediaButtonsListenerOnMediaButtonsEventRequest>(
1087            (event,),
1088            0x2c2068c386964e00,
1089            fidl::encoding::DynamicFlags::empty(),
1090        )
1091    }
1092
1093    pub fn r#on_event(
1094        &self,
1095        mut event: &fidl_fuchsia_ui_input::MediaButtonsEvent,
1096        ___deadline: zx::MonotonicInstant,
1097    ) -> Result<(), fidl::Error> {
1098        let _response = self
1099            .client
1100            .send_query::<MediaButtonsListenerOnEventRequest, fidl::encoding::EmptyPayload>(
1101                (event,),
1102                0x16e7130ddcaf877c,
1103                fidl::encoding::DynamicFlags::empty(),
1104                ___deadline,
1105            )?;
1106        Ok(_response)
1107    }
1108}
1109
1110#[derive(Debug, Clone)]
1111pub struct MediaButtonsListenerProxy {
1112    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1113}
1114
1115impl fidl::endpoints::Proxy for MediaButtonsListenerProxy {
1116    type Protocol = MediaButtonsListenerMarker;
1117
1118    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1119        Self::new(inner)
1120    }
1121
1122    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1123        self.client.into_channel().map_err(|client| Self { client })
1124    }
1125
1126    fn as_channel(&self) -> &::fidl::AsyncChannel {
1127        self.client.as_channel()
1128    }
1129}
1130
1131impl MediaButtonsListenerProxy {
1132    /// Create a new Proxy for fuchsia.ui.policy/MediaButtonsListener.
1133    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1134        let protocol_name =
1135            <MediaButtonsListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1136        Self { client: fidl::client::Client::new(channel, protocol_name) }
1137    }
1138
1139    /// Get a Stream of events from the remote end of the protocol.
1140    ///
1141    /// # Panics
1142    ///
1143    /// Panics if the event stream was already taken.
1144    pub fn take_event_stream(&self) -> MediaButtonsListenerEventStream {
1145        MediaButtonsListenerEventStream { event_receiver: self.client.take_event_receiver() }
1146    }
1147
1148    pub fn r#on_media_buttons_event(
1149        &self,
1150        mut event: &fidl_fuchsia_ui_input::MediaButtonsEvent,
1151    ) -> Result<(), fidl::Error> {
1152        MediaButtonsListenerProxyInterface::r#on_media_buttons_event(self, event)
1153    }
1154
1155    pub fn r#on_event(
1156        &self,
1157        mut event: &fidl_fuchsia_ui_input::MediaButtonsEvent,
1158    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
1159        MediaButtonsListenerProxyInterface::r#on_event(self, event)
1160    }
1161}
1162
1163impl MediaButtonsListenerProxyInterface for MediaButtonsListenerProxy {
1164    fn r#on_media_buttons_event(
1165        &self,
1166        mut event: &fidl_fuchsia_ui_input::MediaButtonsEvent,
1167    ) -> Result<(), fidl::Error> {
1168        self.client.send::<MediaButtonsListenerOnMediaButtonsEventRequest>(
1169            (event,),
1170            0x2c2068c386964e00,
1171            fidl::encoding::DynamicFlags::empty(),
1172        )
1173    }
1174
1175    type OnEventResponseFut =
1176        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1177    fn r#on_event(
1178        &self,
1179        mut event: &fidl_fuchsia_ui_input::MediaButtonsEvent,
1180    ) -> Self::OnEventResponseFut {
1181        fn _decode(
1182            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1183        ) -> Result<(), fidl::Error> {
1184            let _response = fidl::client::decode_transaction_body::<
1185                fidl::encoding::EmptyPayload,
1186                fidl::encoding::DefaultFuchsiaResourceDialect,
1187                0x16e7130ddcaf877c,
1188            >(_buf?)?;
1189            Ok(_response)
1190        }
1191        self.client.send_query_and_decode::<MediaButtonsListenerOnEventRequest, ()>(
1192            (event,),
1193            0x16e7130ddcaf877c,
1194            fidl::encoding::DynamicFlags::empty(),
1195            _decode,
1196        )
1197    }
1198}
1199
1200pub struct MediaButtonsListenerEventStream {
1201    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
1202}
1203
1204impl std::marker::Unpin for MediaButtonsListenerEventStream {}
1205
1206impl futures::stream::FusedStream for MediaButtonsListenerEventStream {
1207    fn is_terminated(&self) -> bool {
1208        self.event_receiver.is_terminated()
1209    }
1210}
1211
1212impl futures::Stream for MediaButtonsListenerEventStream {
1213    type Item = Result<MediaButtonsListenerEvent, fidl::Error>;
1214
1215    fn poll_next(
1216        mut self: std::pin::Pin<&mut Self>,
1217        cx: &mut std::task::Context<'_>,
1218    ) -> std::task::Poll<Option<Self::Item>> {
1219        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
1220            &mut self.event_receiver,
1221            cx
1222        )?) {
1223            Some(buf) => std::task::Poll::Ready(Some(MediaButtonsListenerEvent::decode(buf))),
1224            None => std::task::Poll::Ready(None),
1225        }
1226    }
1227}
1228
1229#[derive(Debug)]
1230pub enum MediaButtonsListenerEvent {}
1231
1232impl MediaButtonsListenerEvent {
1233    /// Decodes a message buffer as a [`MediaButtonsListenerEvent`].
1234    fn decode(
1235        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
1236    ) -> Result<MediaButtonsListenerEvent, fidl::Error> {
1237        let (bytes, _handles) = buf.split_mut();
1238        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1239        debug_assert_eq!(tx_header.tx_id, 0);
1240        match tx_header.ordinal {
1241            _ => Err(fidl::Error::UnknownOrdinal {
1242                ordinal: tx_header.ordinal,
1243                protocol_name:
1244                    <MediaButtonsListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1245            }),
1246        }
1247    }
1248}
1249
1250/// A Stream of incoming requests for fuchsia.ui.policy/MediaButtonsListener.
1251pub struct MediaButtonsListenerRequestStream {
1252    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1253    is_terminated: bool,
1254}
1255
1256impl std::marker::Unpin for MediaButtonsListenerRequestStream {}
1257
1258impl futures::stream::FusedStream for MediaButtonsListenerRequestStream {
1259    fn is_terminated(&self) -> bool {
1260        self.is_terminated
1261    }
1262}
1263
1264impl fidl::endpoints::RequestStream for MediaButtonsListenerRequestStream {
1265    type Protocol = MediaButtonsListenerMarker;
1266    type ControlHandle = MediaButtonsListenerControlHandle;
1267
1268    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
1269        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
1270    }
1271
1272    fn control_handle(&self) -> Self::ControlHandle {
1273        MediaButtonsListenerControlHandle { inner: self.inner.clone() }
1274    }
1275
1276    fn into_inner(
1277        self,
1278    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1279    {
1280        (self.inner, self.is_terminated)
1281    }
1282
1283    fn from_inner(
1284        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1285        is_terminated: bool,
1286    ) -> Self {
1287        Self { inner, is_terminated }
1288    }
1289}
1290
1291impl futures::Stream for MediaButtonsListenerRequestStream {
1292    type Item = Result<MediaButtonsListenerRequest, fidl::Error>;
1293
1294    fn poll_next(
1295        mut self: std::pin::Pin<&mut Self>,
1296        cx: &mut std::task::Context<'_>,
1297    ) -> std::task::Poll<Option<Self::Item>> {
1298        let this = &mut *self;
1299        if this.inner.check_shutdown(cx) {
1300            this.is_terminated = true;
1301            return std::task::Poll::Ready(None);
1302        }
1303        if this.is_terminated {
1304            panic!("polled MediaButtonsListenerRequestStream after completion");
1305        }
1306        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1307            |bytes, handles| {
1308                match this.inner.channel().read_etc(cx, bytes, handles) {
1309                    std::task::Poll::Ready(Ok(())) => {}
1310                    std::task::Poll::Pending => return std::task::Poll::Pending,
1311                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1312                        this.is_terminated = true;
1313                        return std::task::Poll::Ready(None);
1314                    }
1315                    std::task::Poll::Ready(Err(e)) => {
1316                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1317                            e.into(),
1318                        ))))
1319                    }
1320                }
1321
1322                // A message has been received from the channel
1323                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1324
1325                std::task::Poll::Ready(Some(match header.ordinal {
1326                0x2c2068c386964e00 => {
1327                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
1328                    let mut req = fidl::new_empty!(MediaButtonsListenerOnMediaButtonsEventRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
1329                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MediaButtonsListenerOnMediaButtonsEventRequest>(&header, _body_bytes, handles, &mut req)?;
1330                    let control_handle = MediaButtonsListenerControlHandle {
1331                        inner: this.inner.clone(),
1332                    };
1333                    Ok(MediaButtonsListenerRequest::OnMediaButtonsEvent {event: req.event,
1334
1335                        control_handle,
1336                    })
1337                }
1338                0x16e7130ddcaf877c => {
1339                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1340                    let mut req = fidl::new_empty!(MediaButtonsListenerOnEventRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
1341                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MediaButtonsListenerOnEventRequest>(&header, _body_bytes, handles, &mut req)?;
1342                    let control_handle = MediaButtonsListenerControlHandle {
1343                        inner: this.inner.clone(),
1344                    };
1345                    Ok(MediaButtonsListenerRequest::OnEvent {event: req.event,
1346
1347                        responder: MediaButtonsListenerOnEventResponder {
1348                            control_handle: std::mem::ManuallyDrop::new(control_handle),
1349                            tx_id: header.tx_id,
1350                        },
1351                    })
1352                }
1353                _ => Err(fidl::Error::UnknownOrdinal {
1354                    ordinal: header.ordinal,
1355                    protocol_name: <MediaButtonsListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1356                }),
1357            }))
1358            },
1359        )
1360    }
1361}
1362
1363/// A listener for media buttons events. `DeviceListenerRegistry.RegisterMediaButtonsListener`
1364/// will consume this listener interface and call `OnMediaButtonsEvent` when the
1365/// registered media buttons event occurs.
1366#[derive(Debug)]
1367pub enum MediaButtonsListenerRequest {
1368    OnMediaButtonsEvent {
1369        event: fidl_fuchsia_ui_input::MediaButtonsEvent,
1370        control_handle: MediaButtonsListenerControlHandle,
1371    },
1372    OnEvent {
1373        event: fidl_fuchsia_ui_input::MediaButtonsEvent,
1374        responder: MediaButtonsListenerOnEventResponder,
1375    },
1376}
1377
1378impl MediaButtonsListenerRequest {
1379    #[allow(irrefutable_let_patterns)]
1380    pub fn into_on_media_buttons_event(
1381        self,
1382    ) -> Option<(fidl_fuchsia_ui_input::MediaButtonsEvent, MediaButtonsListenerControlHandle)> {
1383        if let MediaButtonsListenerRequest::OnMediaButtonsEvent { event, control_handle } = self {
1384            Some((event, control_handle))
1385        } else {
1386            None
1387        }
1388    }
1389
1390    #[allow(irrefutable_let_patterns)]
1391    pub fn into_on_event(
1392        self,
1393    ) -> Option<(fidl_fuchsia_ui_input::MediaButtonsEvent, MediaButtonsListenerOnEventResponder)>
1394    {
1395        if let MediaButtonsListenerRequest::OnEvent { event, responder } = self {
1396            Some((event, responder))
1397        } else {
1398            None
1399        }
1400    }
1401
1402    /// Name of the method defined in FIDL
1403    pub fn method_name(&self) -> &'static str {
1404        match *self {
1405            MediaButtonsListenerRequest::OnMediaButtonsEvent { .. } => "on_media_buttons_event",
1406            MediaButtonsListenerRequest::OnEvent { .. } => "on_event",
1407        }
1408    }
1409}
1410
1411#[derive(Debug, Clone)]
1412pub struct MediaButtonsListenerControlHandle {
1413    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1414}
1415
1416impl fidl::endpoints::ControlHandle for MediaButtonsListenerControlHandle {
1417    fn shutdown(&self) {
1418        self.inner.shutdown()
1419    }
1420    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1421        self.inner.shutdown_with_epitaph(status)
1422    }
1423
1424    fn is_closed(&self) -> bool {
1425        self.inner.channel().is_closed()
1426    }
1427    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1428        self.inner.channel().on_closed()
1429    }
1430
1431    #[cfg(target_os = "fuchsia")]
1432    fn signal_peer(
1433        &self,
1434        clear_mask: zx::Signals,
1435        set_mask: zx::Signals,
1436    ) -> Result<(), zx_status::Status> {
1437        use fidl::Peered;
1438        self.inner.channel().signal_peer(clear_mask, set_mask)
1439    }
1440}
1441
1442impl MediaButtonsListenerControlHandle {}
1443
1444#[must_use = "FIDL methods require a response to be sent"]
1445#[derive(Debug)]
1446pub struct MediaButtonsListenerOnEventResponder {
1447    control_handle: std::mem::ManuallyDrop<MediaButtonsListenerControlHandle>,
1448    tx_id: u32,
1449}
1450
1451/// Set the the channel to be shutdown (see [`MediaButtonsListenerControlHandle::shutdown`])
1452/// if the responder is dropped without sending a response, so that the client
1453/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1454impl std::ops::Drop for MediaButtonsListenerOnEventResponder {
1455    fn drop(&mut self) {
1456        self.control_handle.shutdown();
1457        // Safety: drops once, never accessed again
1458        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1459    }
1460}
1461
1462impl fidl::endpoints::Responder for MediaButtonsListenerOnEventResponder {
1463    type ControlHandle = MediaButtonsListenerControlHandle;
1464
1465    fn control_handle(&self) -> &MediaButtonsListenerControlHandle {
1466        &self.control_handle
1467    }
1468
1469    fn drop_without_shutdown(mut self) {
1470        // Safety: drops once, never accessed again due to mem::forget
1471        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1472        // Prevent Drop from running (which would shut down the channel)
1473        std::mem::forget(self);
1474    }
1475}
1476
1477impl MediaButtonsListenerOnEventResponder {
1478    /// Sends a response to the FIDL transaction.
1479    ///
1480    /// Sets the channel to shutdown if an error occurs.
1481    pub fn send(self) -> Result<(), fidl::Error> {
1482        let _result = self.send_raw();
1483        if _result.is_err() {
1484            self.control_handle.shutdown();
1485        }
1486        self.drop_without_shutdown();
1487        _result
1488    }
1489
1490    /// Similar to "send" but does not shutdown the channel if an error occurs.
1491    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
1492        let _result = self.send_raw();
1493        self.drop_without_shutdown();
1494        _result
1495    }
1496
1497    fn send_raw(&self) -> Result<(), fidl::Error> {
1498        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
1499            (),
1500            self.tx_id,
1501            0x16e7130ddcaf877c,
1502            fidl::encoding::DynamicFlags::empty(),
1503        )
1504    }
1505}
1506
1507mod internal {
1508    use super::*;
1509
1510    impl fidl::encoding::ResourceTypeMarker for DeviceListenerRegistryRegisterListenerRequest {
1511        type Borrowed<'a> = &'a mut Self;
1512        fn take_or_borrow<'a>(
1513            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1514        ) -> Self::Borrowed<'a> {
1515            value
1516        }
1517    }
1518
1519    unsafe impl fidl::encoding::TypeMarker for DeviceListenerRegistryRegisterListenerRequest {
1520        type Owned = Self;
1521
1522        #[inline(always)]
1523        fn inline_align(_context: fidl::encoding::Context) -> usize {
1524            4
1525        }
1526
1527        #[inline(always)]
1528        fn inline_size(_context: fidl::encoding::Context) -> usize {
1529            4
1530        }
1531    }
1532
1533    unsafe impl
1534        fidl::encoding::Encode<
1535            DeviceListenerRegistryRegisterListenerRequest,
1536            fidl::encoding::DefaultFuchsiaResourceDialect,
1537        > for &mut DeviceListenerRegistryRegisterListenerRequest
1538    {
1539        #[inline]
1540        unsafe fn encode(
1541            self,
1542            encoder: &mut fidl::encoding::Encoder<
1543                '_,
1544                fidl::encoding::DefaultFuchsiaResourceDialect,
1545            >,
1546            offset: usize,
1547            _depth: fidl::encoding::Depth,
1548        ) -> fidl::Result<()> {
1549            encoder.debug_check_bounds::<DeviceListenerRegistryRegisterListenerRequest>(offset);
1550            // Delegate to tuple encoding.
1551            fidl::encoding::Encode::<
1552                DeviceListenerRegistryRegisterListenerRequest,
1553                fidl::encoding::DefaultFuchsiaResourceDialect,
1554            >::encode(
1555                (
1556                    <fidl::encoding::Endpoint<
1557                        fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>,
1558                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
1559                        &mut self.listener
1560                    ),
1561                ),
1562                encoder,
1563                offset,
1564                _depth,
1565            )
1566        }
1567    }
1568    unsafe impl<
1569            T0: fidl::encoding::Encode<
1570                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>>,
1571                fidl::encoding::DefaultFuchsiaResourceDialect,
1572            >,
1573        >
1574        fidl::encoding::Encode<
1575            DeviceListenerRegistryRegisterListenerRequest,
1576            fidl::encoding::DefaultFuchsiaResourceDialect,
1577        > for (T0,)
1578    {
1579        #[inline]
1580        unsafe fn encode(
1581            self,
1582            encoder: &mut fidl::encoding::Encoder<
1583                '_,
1584                fidl::encoding::DefaultFuchsiaResourceDialect,
1585            >,
1586            offset: usize,
1587            depth: fidl::encoding::Depth,
1588        ) -> fidl::Result<()> {
1589            encoder.debug_check_bounds::<DeviceListenerRegistryRegisterListenerRequest>(offset);
1590            // Zero out padding regions. There's no need to apply masks
1591            // because the unmasked parts will be overwritten by fields.
1592            // Write the fields.
1593            self.0.encode(encoder, offset + 0, depth)?;
1594            Ok(())
1595        }
1596    }
1597
1598    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1599        for DeviceListenerRegistryRegisterListenerRequest
1600    {
1601        #[inline(always)]
1602        fn new_empty() -> Self {
1603            Self {
1604                listener: fidl::new_empty!(
1605                    fidl::encoding::Endpoint<
1606                        fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>,
1607                    >,
1608                    fidl::encoding::DefaultFuchsiaResourceDialect
1609                ),
1610            }
1611        }
1612
1613        #[inline]
1614        unsafe fn decode(
1615            &mut self,
1616            decoder: &mut fidl::encoding::Decoder<
1617                '_,
1618                fidl::encoding::DefaultFuchsiaResourceDialect,
1619            >,
1620            offset: usize,
1621            _depth: fidl::encoding::Depth,
1622        ) -> fidl::Result<()> {
1623            decoder.debug_check_bounds::<Self>(offset);
1624            // Verify that padding bytes are zero.
1625            fidl::decode!(
1626                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>>,
1627                fidl::encoding::DefaultFuchsiaResourceDialect,
1628                &mut self.listener,
1629                decoder,
1630                offset + 0,
1631                _depth
1632            )?;
1633            Ok(())
1634        }
1635    }
1636
1637    impl fidl::encoding::ResourceTypeMarker
1638        for DeviceListenerRegistryRegisterMediaButtonsListenerRequest
1639    {
1640        type Borrowed<'a> = &'a mut Self;
1641        fn take_or_borrow<'a>(
1642            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1643        ) -> Self::Borrowed<'a> {
1644            value
1645        }
1646    }
1647
1648    unsafe impl fidl::encoding::TypeMarker
1649        for DeviceListenerRegistryRegisterMediaButtonsListenerRequest
1650    {
1651        type Owned = Self;
1652
1653        #[inline(always)]
1654        fn inline_align(_context: fidl::encoding::Context) -> usize {
1655            4
1656        }
1657
1658        #[inline(always)]
1659        fn inline_size(_context: fidl::encoding::Context) -> usize {
1660            4
1661        }
1662    }
1663
1664    unsafe impl
1665        fidl::encoding::Encode<
1666            DeviceListenerRegistryRegisterMediaButtonsListenerRequest,
1667            fidl::encoding::DefaultFuchsiaResourceDialect,
1668        > for &mut DeviceListenerRegistryRegisterMediaButtonsListenerRequest
1669    {
1670        #[inline]
1671        unsafe fn encode(
1672            self,
1673            encoder: &mut fidl::encoding::Encoder<
1674                '_,
1675                fidl::encoding::DefaultFuchsiaResourceDialect,
1676            >,
1677            offset: usize,
1678            _depth: fidl::encoding::Depth,
1679        ) -> fidl::Result<()> {
1680            encoder
1681                .debug_check_bounds::<DeviceListenerRegistryRegisterMediaButtonsListenerRequest>(
1682                    offset,
1683                );
1684            // Delegate to tuple encoding.
1685            fidl::encoding::Encode::<
1686                DeviceListenerRegistryRegisterMediaButtonsListenerRequest,
1687                fidl::encoding::DefaultFuchsiaResourceDialect,
1688            >::encode(
1689                (
1690                    <fidl::encoding::Endpoint<
1691                        fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>,
1692                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
1693                        &mut self.listener
1694                    ),
1695                ),
1696                encoder,
1697                offset,
1698                _depth,
1699            )
1700        }
1701    }
1702    unsafe impl<
1703            T0: fidl::encoding::Encode<
1704                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>>,
1705                fidl::encoding::DefaultFuchsiaResourceDialect,
1706            >,
1707        >
1708        fidl::encoding::Encode<
1709            DeviceListenerRegistryRegisterMediaButtonsListenerRequest,
1710            fidl::encoding::DefaultFuchsiaResourceDialect,
1711        > for (T0,)
1712    {
1713        #[inline]
1714        unsafe fn encode(
1715            self,
1716            encoder: &mut fidl::encoding::Encoder<
1717                '_,
1718                fidl::encoding::DefaultFuchsiaResourceDialect,
1719            >,
1720            offset: usize,
1721            depth: fidl::encoding::Depth,
1722        ) -> fidl::Result<()> {
1723            encoder
1724                .debug_check_bounds::<DeviceListenerRegistryRegisterMediaButtonsListenerRequest>(
1725                    offset,
1726                );
1727            // Zero out padding regions. There's no need to apply masks
1728            // because the unmasked parts will be overwritten by fields.
1729            // Write the fields.
1730            self.0.encode(encoder, offset + 0, depth)?;
1731            Ok(())
1732        }
1733    }
1734
1735    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1736        for DeviceListenerRegistryRegisterMediaButtonsListenerRequest
1737    {
1738        #[inline(always)]
1739        fn new_empty() -> Self {
1740            Self {
1741                listener: fidl::new_empty!(
1742                    fidl::encoding::Endpoint<
1743                        fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>,
1744                    >,
1745                    fidl::encoding::DefaultFuchsiaResourceDialect
1746                ),
1747            }
1748        }
1749
1750        #[inline]
1751        unsafe fn decode(
1752            &mut self,
1753            decoder: &mut fidl::encoding::Decoder<
1754                '_,
1755                fidl::encoding::DefaultFuchsiaResourceDialect,
1756            >,
1757            offset: usize,
1758            _depth: fidl::encoding::Depth,
1759        ) -> fidl::Result<()> {
1760            decoder.debug_check_bounds::<Self>(offset);
1761            // Verify that padding bytes are zero.
1762            fidl::decode!(
1763                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<MediaButtonsListenerMarker>>,
1764                fidl::encoding::DefaultFuchsiaResourceDialect,
1765                &mut self.listener,
1766                decoder,
1767                offset + 0,
1768                _depth
1769            )?;
1770            Ok(())
1771        }
1772    }
1773}
fidl_fuchsia_ui_policy/fidl_fuchsia_ui_policy.rs

fidl_fuchsia_ui_policy/
fidl_fuchsia_ui_policy.rs
