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

fidl_fuchsia_hardware_power_suspend/
fidl_fuchsia_hardware_power_suspend.rs
