fidl_fuchsia_hardware_power_suspend/
fidl_fuchsia_hardware_power_suspend.rs

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

fidl_fuchsia_hardware_power_suspend/
fidl_fuchsia_hardware_power_suspend.rs
