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 SuspenderControlHandle {
653    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
654        self.inner.shutdown_with_epitaph(status.into())
655    }
656}
657
658impl fidl::endpoints::ControlHandle for SuspenderControlHandle {
659    fn shutdown(&self) {
660        self.inner.shutdown()
661    }
662
663    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
664        self.inner.shutdown_with_epitaph(status)
665    }
666
667    fn is_closed(&self) -> bool {
668        self.inner.channel().is_closed()
669    }
670    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
671        self.inner.channel().on_closed()
672    }
673
674    #[cfg(target_os = "fuchsia")]
675    fn signal_peer(
676        &self,
677        clear_mask: zx::Signals,
678        set_mask: zx::Signals,
679    ) -> Result<(), zx_status::Status> {
680        use fidl::Peered;
681        self.inner.channel().signal_peer(clear_mask, set_mask)
682    }
683}
684
685impl SuspenderControlHandle {}
686
687#[must_use = "FIDL methods require a response to be sent"]
688#[derive(Debug)]
689pub struct SuspenderGetSuspendStatesResponder {
690    control_handle: std::mem::ManuallyDrop<SuspenderControlHandle>,
691    tx_id: u32,
692}
693
694/// Set the the channel to be shutdown (see [`SuspenderControlHandle::shutdown`])
695/// if the responder is dropped without sending a response, so that the client
696/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
697impl std::ops::Drop for SuspenderGetSuspendStatesResponder {
698    fn drop(&mut self) {
699        self.control_handle.shutdown();
700        // Safety: drops once, never accessed again
701        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
702    }
703}
704
705impl fidl::endpoints::Responder for SuspenderGetSuspendStatesResponder {
706    type ControlHandle = SuspenderControlHandle;
707
708    fn control_handle(&self) -> &SuspenderControlHandle {
709        &self.control_handle
710    }
711
712    fn drop_without_shutdown(mut self) {
713        // Safety: drops once, never accessed again due to mem::forget
714        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
715        // Prevent Drop from running (which would shut down the channel)
716        std::mem::forget(self);
717    }
718}
719
720impl SuspenderGetSuspendStatesResponder {
721    /// Sends a response to the FIDL transaction.
722    ///
723    /// Sets the channel to shutdown if an error occurs.
724    pub fn send(
725        self,
726        mut result: Result<&SuspenderGetSuspendStatesResponse, i32>,
727    ) -> Result<(), fidl::Error> {
728        let _result = self.send_raw(result);
729        if _result.is_err() {
730            self.control_handle.shutdown();
731        }
732        self.drop_without_shutdown();
733        _result
734    }
735
736    /// Similar to "send" but does not shutdown the channel if an error occurs.
737    pub fn send_no_shutdown_on_err(
738        self,
739        mut result: Result<&SuspenderGetSuspendStatesResponse, i32>,
740    ) -> Result<(), fidl::Error> {
741        let _result = self.send_raw(result);
742        self.drop_without_shutdown();
743        _result
744    }
745
746    fn send_raw(
747        &self,
748        mut result: Result<&SuspenderGetSuspendStatesResponse, i32>,
749    ) -> Result<(), fidl::Error> {
750        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
751            SuspenderGetSuspendStatesResponse,
752            i32,
753        >>(
754            fidl::encoding::FlexibleResult::new(result),
755            self.tx_id,
756            0xa3fc4a1101bcbe1,
757            fidl::encoding::DynamicFlags::FLEXIBLE,
758        )
759    }
760}
761
762#[must_use = "FIDL methods require a response to be sent"]
763#[derive(Debug)]
764pub struct SuspenderSuspendResponder {
765    control_handle: std::mem::ManuallyDrop<SuspenderControlHandle>,
766    tx_id: u32,
767}
768
769/// Set the the channel to be shutdown (see [`SuspenderControlHandle::shutdown`])
770/// if the responder is dropped without sending a response, so that the client
771/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
772impl std::ops::Drop for SuspenderSuspendResponder {
773    fn drop(&mut self) {
774        self.control_handle.shutdown();
775        // Safety: drops once, never accessed again
776        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
777    }
778}
779
780impl fidl::endpoints::Responder for SuspenderSuspendResponder {
781    type ControlHandle = SuspenderControlHandle;
782
783    fn control_handle(&self) -> &SuspenderControlHandle {
784        &self.control_handle
785    }
786
787    fn drop_without_shutdown(mut self) {
788        // Safety: drops once, never accessed again due to mem::forget
789        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
790        // Prevent Drop from running (which would shut down the channel)
791        std::mem::forget(self);
792    }
793}
794
795impl SuspenderSuspendResponder {
796    /// Sends a response to the FIDL transaction.
797    ///
798    /// Sets the channel to shutdown if an error occurs.
799    pub fn send(
800        self,
801        mut result: Result<&SuspenderSuspendResponse, i32>,
802    ) -> Result<(), fidl::Error> {
803        let _result = self.send_raw(result);
804        if _result.is_err() {
805            self.control_handle.shutdown();
806        }
807        self.drop_without_shutdown();
808        _result
809    }
810
811    /// Similar to "send" but does not shutdown the channel if an error occurs.
812    pub fn send_no_shutdown_on_err(
813        self,
814        mut result: Result<&SuspenderSuspendResponse, i32>,
815    ) -> Result<(), fidl::Error> {
816        let _result = self.send_raw(result);
817        self.drop_without_shutdown();
818        _result
819    }
820
821    fn send_raw(
822        &self,
823        mut result: Result<&SuspenderSuspendResponse, i32>,
824    ) -> Result<(), fidl::Error> {
825        self.control_handle
826            .inner
827            .send::<fidl::encoding::FlexibleResultType<SuspenderSuspendResponse, i32>>(
828                fidl::encoding::FlexibleResult::new(result),
829                self.tx_id,
830                0x5d8bb5e292987c8a,
831                fidl::encoding::DynamicFlags::FLEXIBLE,
832            )
833    }
834}
835
836#[must_use = "FIDL methods require a response to be sent"]
837#[derive(Debug)]
838pub struct SuspenderForceLowestPowerModeResponder {
839    control_handle: std::mem::ManuallyDrop<SuspenderControlHandle>,
840    tx_id: u32,
841}
842
843/// Set the the channel to be shutdown (see [`SuspenderControlHandle::shutdown`])
844/// if the responder is dropped without sending a response, so that the client
845/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
846impl std::ops::Drop for SuspenderForceLowestPowerModeResponder {
847    fn drop(&mut self) {
848        self.control_handle.shutdown();
849        // Safety: drops once, never accessed again
850        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
851    }
852}
853
854impl fidl::endpoints::Responder for SuspenderForceLowestPowerModeResponder {
855    type ControlHandle = SuspenderControlHandle;
856
857    fn control_handle(&self) -> &SuspenderControlHandle {
858        &self.control_handle
859    }
860
861    fn drop_without_shutdown(mut self) {
862        // Safety: drops once, never accessed again due to mem::forget
863        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
864        // Prevent Drop from running (which would shut down the channel)
865        std::mem::forget(self);
866    }
867}
868
869impl SuspenderForceLowestPowerModeResponder {
870    /// Sends a response to the FIDL transaction.
871    ///
872    /// Sets the channel to shutdown if an error occurs.
873    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
874        let _result = self.send_raw(result);
875        if _result.is_err() {
876            self.control_handle.shutdown();
877        }
878        self.drop_without_shutdown();
879        _result
880    }
881
882    /// Similar to "send" but does not shutdown the channel if an error occurs.
883    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
884        let _result = self.send_raw(result);
885        self.drop_without_shutdown();
886        _result
887    }
888
889    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
890        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
891            fidl::encoding::EmptyStruct,
892            i32,
893        >>(
894            fidl::encoding::FlexibleResult::new(result),
895            self.tx_id,
896            0x740518cfae1b7cdb,
897            fidl::encoding::DynamicFlags::FLEXIBLE,
898        )
899    }
900}
901
902#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
903pub struct SuspendServiceMarker;
904
905#[cfg(target_os = "fuchsia")]
906impl fidl::endpoints::ServiceMarker for SuspendServiceMarker {
907    type Proxy = SuspendServiceProxy;
908    type Request = SuspendServiceRequest;
909    const SERVICE_NAME: &'static str = "fuchsia.hardware.power.suspend.SuspendService";
910}
911
912/// A request for one of the member protocols of SuspendService.
913///
914#[cfg(target_os = "fuchsia")]
915pub enum SuspendServiceRequest {
916    Suspender(SuspenderRequestStream),
917}
918
919#[cfg(target_os = "fuchsia")]
920impl fidl::endpoints::ServiceRequest for SuspendServiceRequest {
921    type Service = SuspendServiceMarker;
922
923    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
924        match name {
925            "suspender" => Self::Suspender(
926                <SuspenderRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
927            ),
928            _ => panic!("no such member protocol name for service SuspendService"),
929        }
930    }
931
932    fn member_names() -> &'static [&'static str] {
933        &["suspender"]
934    }
935}
936#[cfg(target_os = "fuchsia")]
937pub struct SuspendServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);
938
939#[cfg(target_os = "fuchsia")]
940impl fidl::endpoints::ServiceProxy for SuspendServiceProxy {
941    type Service = SuspendServiceMarker;
942
943    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
944        Self(opener)
945    }
946}
947
948#[cfg(target_os = "fuchsia")]
949impl SuspendServiceProxy {
950    pub fn connect_to_suspender(&self) -> Result<SuspenderProxy, fidl::Error> {
951        let (proxy, server_end) = fidl::endpoints::create_proxy::<SuspenderMarker>();
952        self.connect_channel_to_suspender(server_end)?;
953        Ok(proxy)
954    }
955
956    /// Like `connect_to_suspender`, but returns a sync proxy.
957    /// See [`Self::connect_to_suspender`] for more details.
958    pub fn connect_to_suspender_sync(&self) -> Result<SuspenderSynchronousProxy, fidl::Error> {
959        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<SuspenderMarker>();
960        self.connect_channel_to_suspender(server_end)?;
961        Ok(proxy)
962    }
963
964    /// Like `connect_to_suspender`, but accepts a server end.
965    /// See [`Self::connect_to_suspender`] for more details.
966    pub fn connect_channel_to_suspender(
967        &self,
968        server_end: fidl::endpoints::ServerEnd<SuspenderMarker>,
969    ) -> Result<(), fidl::Error> {
970        self.0.open_member("suspender", server_end.into_channel())
971    }
972
973    pub fn instance_name(&self) -> &str {
974        self.0.instance_name()
975    }
976}
977
978mod internal {
979    use super::*;
980}
fidl_fuchsia_hardware_power_suspend/fidl_fuchsia_hardware_power_suspend.rs

fidl_fuchsia_hardware_power_suspend/
fidl_fuchsia_hardware_power_suspend.rs
