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

fidl_fuchsia_hardware_power_suspend/
fidl_fuchsia_hardware_power_suspend.rs
