fidl_fuchsia_hardware_suspend/
fidl_fuchsia_hardware_suspend.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_hardware_suspend_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
15pub struct SuspenderMarker;
16
17impl fidl::endpoints::ProtocolMarker for SuspenderMarker {
18    type Proxy = SuspenderProxy;
19    type RequestStream = SuspenderRequestStream;
20    #[cfg(target_os = "fuchsia")]
21    type SynchronousProxy = SuspenderSynchronousProxy;
22
23    const DEBUG_NAME: &'static str = "(anonymous) Suspender";
24}
25pub type SuspenderGetSuspendStatesResult = Result<SuspenderGetSuspendStatesResponse, i32>;
26pub type SuspenderSuspendResult = Result<SuspenderSuspendResponse, i32>;
27
28pub trait SuspenderProxyInterface: Send + Sync {
29    type GetSuspendStatesResponseFut: std::future::Future<Output = Result<SuspenderGetSuspendStatesResult, fidl::Error>>
30        + Send;
31    fn r#get_suspend_states(&self) -> Self::GetSuspendStatesResponseFut;
32    type SuspendResponseFut: std::future::Future<Output = Result<SuspenderSuspendResult, fidl::Error>>
33        + Send;
34    fn r#suspend(&self, payload: &SuspenderSuspendRequest) -> Self::SuspendResponseFut;
35}
36#[derive(Debug)]
37#[cfg(target_os = "fuchsia")]
38pub struct SuspenderSynchronousProxy {
39    client: fidl::client::sync::Client,
40}
41
42#[cfg(target_os = "fuchsia")]
43impl fidl::endpoints::SynchronousProxy for SuspenderSynchronousProxy {
44    type Proxy = SuspenderProxy;
45    type Protocol = SuspenderMarker;
46
47    fn from_channel(inner: fidl::Channel) -> Self {
48        Self::new(inner)
49    }
50
51    fn into_channel(self) -> fidl::Channel {
52        self.client.into_channel()
53    }
54
55    fn as_channel(&self) -> &fidl::Channel {
56        self.client.as_channel()
57    }
58}
59
60#[cfg(target_os = "fuchsia")]
61impl SuspenderSynchronousProxy {
62    pub fn new(channel: fidl::Channel) -> Self {
63        let protocol_name = <SuspenderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
64        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
65    }
66
67    pub fn into_channel(self) -> fidl::Channel {
68        self.client.into_channel()
69    }
70
71    /// Waits until an event arrives and returns it. It is safe for other
72    /// threads to make concurrent requests while waiting for an event.
73    pub fn wait_for_event(
74        &self,
75        deadline: zx::MonotonicInstant,
76    ) -> Result<SuspenderEvent, fidl::Error> {
77        SuspenderEvent::decode(self.client.wait_for_event(deadline)?)
78    }
79
80    /// Returns a list of [`fuchsia.hardware.suspend/SuspendState`] supported.
81    /// by the system. The system must return at least 1 suspend state which
82    /// corresponds to the "suspend-to-idle" state but may return up to
83    /// [`fuchsia.hardware.suspend/MAX_SUSPEND_STATES`] states.
84    /// The suspend states must be ordered in order of decreasing
85    /// `resume_latency` (and thereby increasing power consumption).
86    /// A particular build of the system must always return the same set of
87    /// suspend states.
88    pub fn r#get_suspend_states(
89        &self,
90        ___deadline: zx::MonotonicInstant,
91    ) -> Result<SuspenderGetSuspendStatesResult, fidl::Error> {
92        let _response = self.client.send_query::<
93            fidl::encoding::EmptyPayload,
94            fidl::encoding::FlexibleResultType<SuspenderGetSuspendStatesResponse, i32>,
95        >(
96            (),
97            0x13651a60bd368170,
98            fidl::encoding::DynamicFlags::FLEXIBLE,
99            ___deadline,
100        )?
101        .into_result::<SuspenderMarker>("get_suspend_states")?;
102        Ok(_response.map(|x| x))
103    }
104
105    /// Instruct the system to suspend.
106    /// This call may return a ZX_ERR_* if the system was unable to suspend.
107    /// If the call succeeds, it will not return until the system has resumed.
108    /// Being interrupted while suspending and resuming before fully suspending
109    /// is not an error however `suspend_duration` must be None if the suspend
110    /// was interrupted.
111    pub fn r#suspend(
112        &self,
113        mut payload: &SuspenderSuspendRequest,
114        ___deadline: zx::MonotonicInstant,
115    ) -> Result<SuspenderSuspendResult, fidl::Error> {
116        let _response = self.client.send_query::<
117            SuspenderSuspendRequest,
118            fidl::encoding::FlexibleResultType<SuspenderSuspendResponse, i32>,
119        >(
120            payload,
121            0x657d4d76beacad40,
122            fidl::encoding::DynamicFlags::FLEXIBLE,
123            ___deadline,
124        )?
125        .into_result::<SuspenderMarker>("suspend")?;
126        Ok(_response.map(|x| x))
127    }
128}
129
130#[derive(Debug, Clone)]
131pub struct SuspenderProxy {
132    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
133}
134
135impl fidl::endpoints::Proxy for SuspenderProxy {
136    type Protocol = SuspenderMarker;
137
138    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
139        Self::new(inner)
140    }
141
142    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
143        self.client.into_channel().map_err(|client| Self { client })
144    }
145
146    fn as_channel(&self) -> &::fidl::AsyncChannel {
147        self.client.as_channel()
148    }
149}
150
151impl SuspenderProxy {
152    /// Create a new Proxy for fuchsia.hardware.suspend/Suspender.
153    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
154        let protocol_name = <SuspenderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
155        Self { client: fidl::client::Client::new(channel, protocol_name) }
156    }
157
158    /// Get a Stream of events from the remote end of the protocol.
159    ///
160    /// # Panics
161    ///
162    /// Panics if the event stream was already taken.
163    pub fn take_event_stream(&self) -> SuspenderEventStream {
164        SuspenderEventStream { event_receiver: self.client.take_event_receiver() }
165    }
166
167    /// Returns a list of [`fuchsia.hardware.suspend/SuspendState`] supported.
168    /// by the system. The system must return at least 1 suspend state which
169    /// corresponds to the "suspend-to-idle" state but may return up to
170    /// [`fuchsia.hardware.suspend/MAX_SUSPEND_STATES`] states.
171    /// The suspend states must be ordered in order of decreasing
172    /// `resume_latency` (and thereby increasing power consumption).
173    /// A particular build of the system must always return the same set of
174    /// suspend states.
175    pub fn r#get_suspend_states(
176        &self,
177    ) -> fidl::client::QueryResponseFut<
178        SuspenderGetSuspendStatesResult,
179        fidl::encoding::DefaultFuchsiaResourceDialect,
180    > {
181        SuspenderProxyInterface::r#get_suspend_states(self)
182    }
183
184    /// Instruct the system to suspend.
185    /// This call may return a ZX_ERR_* if the system was unable to suspend.
186    /// If the call succeeds, it will not return until the system has resumed.
187    /// Being interrupted while suspending and resuming before fully suspending
188    /// is not an error however `suspend_duration` must be None if the suspend
189    /// was interrupted.
190    pub fn r#suspend(
191        &self,
192        mut payload: &SuspenderSuspendRequest,
193    ) -> fidl::client::QueryResponseFut<
194        SuspenderSuspendResult,
195        fidl::encoding::DefaultFuchsiaResourceDialect,
196    > {
197        SuspenderProxyInterface::r#suspend(self, payload)
198    }
199}
200
201impl SuspenderProxyInterface for SuspenderProxy {
202    type GetSuspendStatesResponseFut = fidl::client::QueryResponseFut<
203        SuspenderGetSuspendStatesResult,
204        fidl::encoding::DefaultFuchsiaResourceDialect,
205    >;
206    fn r#get_suspend_states(&self) -> Self::GetSuspendStatesResponseFut {
207        fn _decode(
208            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
209        ) -> Result<SuspenderGetSuspendStatesResult, fidl::Error> {
210            let _response = fidl::client::decode_transaction_body::<
211                fidl::encoding::FlexibleResultType<SuspenderGetSuspendStatesResponse, i32>,
212                fidl::encoding::DefaultFuchsiaResourceDialect,
213                0x13651a60bd368170,
214            >(_buf?)?
215            .into_result::<SuspenderMarker>("get_suspend_states")?;
216            Ok(_response.map(|x| x))
217        }
218        self.client
219            .send_query_and_decode::<fidl::encoding::EmptyPayload, SuspenderGetSuspendStatesResult>(
220                (),
221                0x13651a60bd368170,
222                fidl::encoding::DynamicFlags::FLEXIBLE,
223                _decode,
224            )
225    }
226
227    type SuspendResponseFut = fidl::client::QueryResponseFut<
228        SuspenderSuspendResult,
229        fidl::encoding::DefaultFuchsiaResourceDialect,
230    >;
231    fn r#suspend(&self, mut payload: &SuspenderSuspendRequest) -> Self::SuspendResponseFut {
232        fn _decode(
233            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
234        ) -> Result<SuspenderSuspendResult, fidl::Error> {
235            let _response = fidl::client::decode_transaction_body::<
236                fidl::encoding::FlexibleResultType<SuspenderSuspendResponse, i32>,
237                fidl::encoding::DefaultFuchsiaResourceDialect,
238                0x657d4d76beacad40,
239            >(_buf?)?
240            .into_result::<SuspenderMarker>("suspend")?;
241            Ok(_response.map(|x| x))
242        }
243        self.client.send_query_and_decode::<SuspenderSuspendRequest, SuspenderSuspendResult>(
244            payload,
245            0x657d4d76beacad40,
246            fidl::encoding::DynamicFlags::FLEXIBLE,
247            _decode,
248        )
249    }
250}
251
252pub struct SuspenderEventStream {
253    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
254}
255
256impl std::marker::Unpin for SuspenderEventStream {}
257
258impl futures::stream::FusedStream for SuspenderEventStream {
259    fn is_terminated(&self) -> bool {
260        self.event_receiver.is_terminated()
261    }
262}
263
264impl futures::Stream for SuspenderEventStream {
265    type Item = Result<SuspenderEvent, fidl::Error>;
266
267    fn poll_next(
268        mut self: std::pin::Pin<&mut Self>,
269        cx: &mut std::task::Context<'_>,
270    ) -> std::task::Poll<Option<Self::Item>> {
271        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
272            &mut self.event_receiver,
273            cx
274        )?) {
275            Some(buf) => std::task::Poll::Ready(Some(SuspenderEvent::decode(buf))),
276            None => std::task::Poll::Ready(None),
277        }
278    }
279}
280
281#[derive(Debug)]
282pub enum SuspenderEvent {
283    #[non_exhaustive]
284    _UnknownEvent {
285        /// Ordinal of the event that was sent.
286        ordinal: u64,
287    },
288}
289
290impl SuspenderEvent {
291    /// Decodes a message buffer as a [`SuspenderEvent`].
292    fn decode(
293        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
294    ) -> Result<SuspenderEvent, fidl::Error> {
295        let (bytes, _handles) = buf.split_mut();
296        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
297        debug_assert_eq!(tx_header.tx_id, 0);
298        match tx_header.ordinal {
299            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
300                Ok(SuspenderEvent::_UnknownEvent { ordinal: tx_header.ordinal })
301            }
302            _ => Err(fidl::Error::UnknownOrdinal {
303                ordinal: tx_header.ordinal,
304                protocol_name: <SuspenderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
305            }),
306        }
307    }
308}
309
310/// A Stream of incoming requests for fuchsia.hardware.suspend/Suspender.
311pub struct SuspenderRequestStream {
312    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
313    is_terminated: bool,
314}
315
316impl std::marker::Unpin for SuspenderRequestStream {}
317
318impl futures::stream::FusedStream for SuspenderRequestStream {
319    fn is_terminated(&self) -> bool {
320        self.is_terminated
321    }
322}
323
324impl fidl::endpoints::RequestStream for SuspenderRequestStream {
325    type Protocol = SuspenderMarker;
326    type ControlHandle = SuspenderControlHandle;
327
328    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
329        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
330    }
331
332    fn control_handle(&self) -> Self::ControlHandle {
333        SuspenderControlHandle { inner: self.inner.clone() }
334    }
335
336    fn into_inner(
337        self,
338    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
339    {
340        (self.inner, self.is_terminated)
341    }
342
343    fn from_inner(
344        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
345        is_terminated: bool,
346    ) -> Self {
347        Self { inner, is_terminated }
348    }
349}
350
351impl futures::Stream for SuspenderRequestStream {
352    type Item = Result<SuspenderRequest, fidl::Error>;
353
354    fn poll_next(
355        mut self: std::pin::Pin<&mut Self>,
356        cx: &mut std::task::Context<'_>,
357    ) -> std::task::Poll<Option<Self::Item>> {
358        let this = &mut *self;
359        if this.inner.check_shutdown(cx) {
360            this.is_terminated = true;
361            return std::task::Poll::Ready(None);
362        }
363        if this.is_terminated {
364            panic!("polled SuspenderRequestStream after completion");
365        }
366        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
367            |bytes, handles| {
368                match this.inner.channel().read_etc(cx, bytes, handles) {
369                    std::task::Poll::Ready(Ok(())) => {}
370                    std::task::Poll::Pending => return std::task::Poll::Pending,
371                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
372                        this.is_terminated = true;
373                        return std::task::Poll::Ready(None);
374                    }
375                    std::task::Poll::Ready(Err(e)) => {
376                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
377                            e.into(),
378                        ))))
379                    }
380                }
381
382                // A message has been received from the channel
383                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
384
385                std::task::Poll::Ready(Some(match header.ordinal {
386                    0x13651a60bd368170 => {
387                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
388                        let mut req = fidl::new_empty!(
389                            fidl::encoding::EmptyPayload,
390                            fidl::encoding::DefaultFuchsiaResourceDialect
391                        );
392                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
393                        let control_handle = SuspenderControlHandle { inner: this.inner.clone() };
394                        Ok(SuspenderRequest::GetSuspendStates {
395                            responder: SuspenderGetSuspendStatesResponder {
396                                control_handle: std::mem::ManuallyDrop::new(control_handle),
397                                tx_id: header.tx_id,
398                            },
399                        })
400                    }
401                    0x657d4d76beacad40 => {
402                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
403                        let mut req = fidl::new_empty!(
404                            SuspenderSuspendRequest,
405                            fidl::encoding::DefaultFuchsiaResourceDialect
406                        );
407                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SuspenderSuspendRequest>(&header, _body_bytes, handles, &mut req)?;
408                        let control_handle = SuspenderControlHandle { inner: this.inner.clone() };
409                        Ok(SuspenderRequest::Suspend {
410                            payload: req,
411                            responder: SuspenderSuspendResponder {
412                                control_handle: std::mem::ManuallyDrop::new(control_handle),
413                                tx_id: header.tx_id,
414                            },
415                        })
416                    }
417                    _ if header.tx_id == 0
418                        && header
419                            .dynamic_flags()
420                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
421                    {
422                        Ok(SuspenderRequest::_UnknownMethod {
423                            ordinal: header.ordinal,
424                            control_handle: SuspenderControlHandle { inner: this.inner.clone() },
425                            method_type: fidl::MethodType::OneWay,
426                        })
427                    }
428                    _ if header
429                        .dynamic_flags()
430                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
431                    {
432                        this.inner.send_framework_err(
433                            fidl::encoding::FrameworkErr::UnknownMethod,
434                            header.tx_id,
435                            header.ordinal,
436                            header.dynamic_flags(),
437                            (bytes, handles),
438                        )?;
439                        Ok(SuspenderRequest::_UnknownMethod {
440                            ordinal: header.ordinal,
441                            control_handle: SuspenderControlHandle { inner: this.inner.clone() },
442                            method_type: fidl::MethodType::TwoWay,
443                        })
444                    }
445                    _ => Err(fidl::Error::UnknownOrdinal {
446                        ordinal: header.ordinal,
447                        protocol_name:
448                            <SuspenderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
449                    }),
450                }))
451            },
452        )
453    }
454}
455
456#[derive(Debug)]
457pub enum SuspenderRequest {
458    /// Returns a list of [`fuchsia.hardware.suspend/SuspendState`] supported.
459    /// by the system. The system must return at least 1 suspend state which
460    /// corresponds to the "suspend-to-idle" state but may return up to
461    /// [`fuchsia.hardware.suspend/MAX_SUSPEND_STATES`] states.
462    /// The suspend states must be ordered in order of decreasing
463    /// `resume_latency` (and thereby increasing power consumption).
464    /// A particular build of the system must always return the same set of
465    /// suspend states.
466    GetSuspendStates { responder: SuspenderGetSuspendStatesResponder },
467    /// Instruct the system to suspend.
468    /// This call may return a ZX_ERR_* if the system was unable to suspend.
469    /// If the call succeeds, it will not return until the system has resumed.
470    /// Being interrupted while suspending and resuming before fully suspending
471    /// is not an error however `suspend_duration` must be None if the suspend
472    /// was interrupted.
473    Suspend { payload: SuspenderSuspendRequest, responder: SuspenderSuspendResponder },
474    /// An interaction was received which does not match any known method.
475    #[non_exhaustive]
476    _UnknownMethod {
477        /// Ordinal of the method that was called.
478        ordinal: u64,
479        control_handle: SuspenderControlHandle,
480        method_type: fidl::MethodType,
481    },
482}
483
484impl SuspenderRequest {
485    #[allow(irrefutable_let_patterns)]
486    pub fn into_get_suspend_states(self) -> Option<(SuspenderGetSuspendStatesResponder)> {
487        if let SuspenderRequest::GetSuspendStates { responder } = self {
488            Some((responder))
489        } else {
490            None
491        }
492    }
493
494    #[allow(irrefutable_let_patterns)]
495    pub fn into_suspend(self) -> Option<(SuspenderSuspendRequest, SuspenderSuspendResponder)> {
496        if let SuspenderRequest::Suspend { payload, responder } = self {
497            Some((payload, responder))
498        } else {
499            None
500        }
501    }
502
503    /// Name of the method defined in FIDL
504    pub fn method_name(&self) -> &'static str {
505        match *self {
506            SuspenderRequest::GetSuspendStates { .. } => "get_suspend_states",
507            SuspenderRequest::Suspend { .. } => "suspend",
508            SuspenderRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
509                "unknown one-way method"
510            }
511            SuspenderRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
512                "unknown two-way method"
513            }
514        }
515    }
516}
517
518#[derive(Debug, Clone)]
519pub struct SuspenderControlHandle {
520    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
521}
522
523impl fidl::endpoints::ControlHandle for SuspenderControlHandle {
524    fn shutdown(&self) {
525        self.inner.shutdown()
526    }
527    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
528        self.inner.shutdown_with_epitaph(status)
529    }
530
531    fn is_closed(&self) -> bool {
532        self.inner.channel().is_closed()
533    }
534    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
535        self.inner.channel().on_closed()
536    }
537
538    #[cfg(target_os = "fuchsia")]
539    fn signal_peer(
540        &self,
541        clear_mask: zx::Signals,
542        set_mask: zx::Signals,
543    ) -> Result<(), zx_status::Status> {
544        use fidl::Peered;
545        self.inner.channel().signal_peer(clear_mask, set_mask)
546    }
547}
548
549impl SuspenderControlHandle {}
550
551#[must_use = "FIDL methods require a response to be sent"]
552#[derive(Debug)]
553pub struct SuspenderGetSuspendStatesResponder {
554    control_handle: std::mem::ManuallyDrop<SuspenderControlHandle>,
555    tx_id: u32,
556}
557
558/// Set the the channel to be shutdown (see [`SuspenderControlHandle::shutdown`])
559/// if the responder is dropped without sending a response, so that the client
560/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
561impl std::ops::Drop for SuspenderGetSuspendStatesResponder {
562    fn drop(&mut self) {
563        self.control_handle.shutdown();
564        // Safety: drops once, never accessed again
565        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
566    }
567}
568
569impl fidl::endpoints::Responder for SuspenderGetSuspendStatesResponder {
570    type ControlHandle = SuspenderControlHandle;
571
572    fn control_handle(&self) -> &SuspenderControlHandle {
573        &self.control_handle
574    }
575
576    fn drop_without_shutdown(mut self) {
577        // Safety: drops once, never accessed again due to mem::forget
578        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
579        // Prevent Drop from running (which would shut down the channel)
580        std::mem::forget(self);
581    }
582}
583
584impl SuspenderGetSuspendStatesResponder {
585    /// Sends a response to the FIDL transaction.
586    ///
587    /// Sets the channel to shutdown if an error occurs.
588    pub fn send(
589        self,
590        mut result: Result<&SuspenderGetSuspendStatesResponse, i32>,
591    ) -> Result<(), fidl::Error> {
592        let _result = self.send_raw(result);
593        if _result.is_err() {
594            self.control_handle.shutdown();
595        }
596        self.drop_without_shutdown();
597        _result
598    }
599
600    /// Similar to "send" but does not shutdown the channel if an error occurs.
601    pub fn send_no_shutdown_on_err(
602        self,
603        mut result: Result<&SuspenderGetSuspendStatesResponse, i32>,
604    ) -> Result<(), fidl::Error> {
605        let _result = self.send_raw(result);
606        self.drop_without_shutdown();
607        _result
608    }
609
610    fn send_raw(
611        &self,
612        mut result: Result<&SuspenderGetSuspendStatesResponse, i32>,
613    ) -> Result<(), fidl::Error> {
614        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
615            SuspenderGetSuspendStatesResponse,
616            i32,
617        >>(
618            fidl::encoding::FlexibleResult::new(result),
619            self.tx_id,
620            0x13651a60bd368170,
621            fidl::encoding::DynamicFlags::FLEXIBLE,
622        )
623    }
624}
625
626#[must_use = "FIDL methods require a response to be sent"]
627#[derive(Debug)]
628pub struct SuspenderSuspendResponder {
629    control_handle: std::mem::ManuallyDrop<SuspenderControlHandle>,
630    tx_id: u32,
631}
632
633/// Set the the channel to be shutdown (see [`SuspenderControlHandle::shutdown`])
634/// if the responder is dropped without sending a response, so that the client
635/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
636impl std::ops::Drop for SuspenderSuspendResponder {
637    fn drop(&mut self) {
638        self.control_handle.shutdown();
639        // Safety: drops once, never accessed again
640        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
641    }
642}
643
644impl fidl::endpoints::Responder for SuspenderSuspendResponder {
645    type ControlHandle = SuspenderControlHandle;
646
647    fn control_handle(&self) -> &SuspenderControlHandle {
648        &self.control_handle
649    }
650
651    fn drop_without_shutdown(mut self) {
652        // Safety: drops once, never accessed again due to mem::forget
653        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
654        // Prevent Drop from running (which would shut down the channel)
655        std::mem::forget(self);
656    }
657}
658
659impl SuspenderSuspendResponder {
660    /// Sends a response to the FIDL transaction.
661    ///
662    /// Sets the channel to shutdown if an error occurs.
663    pub fn send(
664        self,
665        mut result: Result<&SuspenderSuspendResponse, i32>,
666    ) -> Result<(), fidl::Error> {
667        let _result = self.send_raw(result);
668        if _result.is_err() {
669            self.control_handle.shutdown();
670        }
671        self.drop_without_shutdown();
672        _result
673    }
674
675    /// Similar to "send" but does not shutdown the channel if an error occurs.
676    pub fn send_no_shutdown_on_err(
677        self,
678        mut result: Result<&SuspenderSuspendResponse, i32>,
679    ) -> Result<(), fidl::Error> {
680        let _result = self.send_raw(result);
681        self.drop_without_shutdown();
682        _result
683    }
684
685    fn send_raw(
686        &self,
687        mut result: Result<&SuspenderSuspendResponse, i32>,
688    ) -> Result<(), fidl::Error> {
689        self.control_handle
690            .inner
691            .send::<fidl::encoding::FlexibleResultType<SuspenderSuspendResponse, i32>>(
692                fidl::encoding::FlexibleResult::new(result),
693                self.tx_id,
694                0x657d4d76beacad40,
695                fidl::encoding::DynamicFlags::FLEXIBLE,
696            )
697    }
698}
699
700#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
701pub struct SuspendServiceMarker;
702
703#[cfg(target_os = "fuchsia")]
704impl fidl::endpoints::ServiceMarker for SuspendServiceMarker {
705    type Proxy = SuspendServiceProxy;
706    type Request = SuspendServiceRequest;
707    const SERVICE_NAME: &'static str = "fuchsia.hardware.suspend.SuspendService";
708}
709
710/// A request for one of the member protocols of SuspendService.
711///
712#[cfg(target_os = "fuchsia")]
713pub enum SuspendServiceRequest {
714    Suspender(SuspenderRequestStream),
715}
716
717#[cfg(target_os = "fuchsia")]
718impl fidl::endpoints::ServiceRequest for SuspendServiceRequest {
719    type Service = SuspendServiceMarker;
720
721    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
722        match name {
723            "suspender" => Self::Suspender(
724                <SuspenderRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
725            ),
726            _ => panic!("no such member protocol name for service SuspendService"),
727        }
728    }
729
730    fn member_names() -> &'static [&'static str] {
731        &["suspender"]
732    }
733}
734#[cfg(target_os = "fuchsia")]
735pub struct SuspendServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);
736
737#[cfg(target_os = "fuchsia")]
738impl fidl::endpoints::ServiceProxy for SuspendServiceProxy {
739    type Service = SuspendServiceMarker;
740
741    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
742        Self(opener)
743    }
744}
745
746#[cfg(target_os = "fuchsia")]
747impl SuspendServiceProxy {
748    pub fn connect_to_suspender(&self) -> Result<SuspenderProxy, fidl::Error> {
749        let (proxy, server_end) = fidl::endpoints::create_proxy::<SuspenderMarker>();
750        self.connect_channel_to_suspender(server_end)?;
751        Ok(proxy)
752    }
753
754    /// Like `connect_to_suspender`, but returns a sync proxy.
755    /// See [`Self::connect_to_suspender`] for more details.
756    pub fn connect_to_suspender_sync(&self) -> Result<SuspenderSynchronousProxy, fidl::Error> {
757        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<SuspenderMarker>();
758        self.connect_channel_to_suspender(server_end)?;
759        Ok(proxy)
760    }
761
762    /// Like `connect_to_suspender`, but accepts a server end.
763    /// See [`Self::connect_to_suspender`] for more details.
764    pub fn connect_channel_to_suspender(
765        &self,
766        server_end: fidl::endpoints::ServerEnd<SuspenderMarker>,
767    ) -> Result<(), fidl::Error> {
768        self.0.open_member("suspender", server_end.into_channel())
769    }
770
771    pub fn instance_name(&self) -> &str {
772        self.0.instance_name()
773    }
774}
775
776mod internal {
777    use super::*;
778}
fidl_fuchsia_hardware_suspend/fidl_fuchsia_hardware_suspend.rs

fidl_fuchsia_hardware_suspend/
fidl_fuchsia_hardware_suspend.rs
