fidl_fuchsia_power_clientlevel/
fidl_fuchsia_power_clientlevel.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_power_clientlevel__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
15pub struct ConnectorConnectRequest {
16    pub client_type: ClientType,
17    pub watcher: fidl::endpoints::ServerEnd<WatcherMarker>,
18}
19
20impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ConnectorConnectRequest {}
21
22#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
23pub struct ConnectorMarker;
24
25impl fidl::endpoints::ProtocolMarker for ConnectorMarker {
26    type Proxy = ConnectorProxy;
27    type RequestStream = ConnectorRequestStream;
28    #[cfg(target_os = "fuchsia")]
29    type SynchronousProxy = ConnectorSynchronousProxy;
30
31    const DEBUG_NAME: &'static str = "fuchsia.power.clientlevel.Connector";
32}
33impl fidl::endpoints::DiscoverableProtocolMarker for ConnectorMarker {}
34
35pub trait ConnectorProxyInterface: Send + Sync {
36    fn r#connect(
37        &self,
38        client_type: ClientType,
39        watcher: fidl::endpoints::ServerEnd<WatcherMarker>,
40    ) -> Result<(), fidl::Error>;
41}
42#[derive(Debug)]
43#[cfg(target_os = "fuchsia")]
44pub struct ConnectorSynchronousProxy {
45    client: fidl::client::sync::Client,
46}
47
48#[cfg(target_os = "fuchsia")]
49impl fidl::endpoints::SynchronousProxy for ConnectorSynchronousProxy {
50    type Proxy = ConnectorProxy;
51    type Protocol = ConnectorMarker;
52
53    fn from_channel(inner: fidl::Channel) -> Self {
54        Self::new(inner)
55    }
56
57    fn into_channel(self) -> fidl::Channel {
58        self.client.into_channel()
59    }
60
61    fn as_channel(&self) -> &fidl::Channel {
62        self.client.as_channel()
63    }
64}
65
66#[cfg(target_os = "fuchsia")]
67impl ConnectorSynchronousProxy {
68    pub fn new(channel: fidl::Channel) -> Self {
69        let protocol_name = <ConnectorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
70        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
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<ConnectorEvent, fidl::Error> {
83        ConnectorEvent::decode(self.client.wait_for_event(deadline)?)
84    }
85
86    /// Connects a [`Watcher`] to the power level of the specified
87    /// [`ClientType`].
88    ///
89    /// A client may call this method and begin using the [`Watcher`] client
90    /// endpoint immediately.
91    ///
92    /// If a power configuration does not exist for the provided `client_type`,
93    /// then the request will fail. On failure, both the `watcher` server
94    /// endpoint as well as the current `Connector` connection will be
95    /// terminated.
96    ///
97    /// + `client_type` specifies to which [`ClientType`] power level that
98    /// `watcher` should be connected. The value is valid iff a power
99    /// configuration exists for the provided `client_type`.
100    ///
101    /// + `watcher` is the server endpoint of a [`Watcher`] channel that will be
102    /// connected to the [`ClientType`] power level.
103    pub fn r#connect(
104        &self,
105        mut client_type: ClientType,
106        mut watcher: fidl::endpoints::ServerEnd<WatcherMarker>,
107    ) -> Result<(), fidl::Error> {
108        self.client.send::<ConnectorConnectRequest>(
109            (client_type, watcher),
110            0x29e603fe743fd08a,
111            fidl::encoding::DynamicFlags::empty(),
112        )
113    }
114}
115
116#[cfg(target_os = "fuchsia")]
117impl From<ConnectorSynchronousProxy> for zx::Handle {
118    fn from(value: ConnectorSynchronousProxy) -> Self {
119        value.into_channel().into()
120    }
121}
122
123#[cfg(target_os = "fuchsia")]
124impl From<fidl::Channel> for ConnectorSynchronousProxy {
125    fn from(value: fidl::Channel) -> Self {
126        Self::new(value)
127    }
128}
129
130#[cfg(target_os = "fuchsia")]
131impl fidl::endpoints::FromClient for ConnectorSynchronousProxy {
132    type Protocol = ConnectorMarker;
133
134    fn from_client(value: fidl::endpoints::ClientEnd<ConnectorMarker>) -> Self {
135        Self::new(value.into_channel())
136    }
137}
138
139#[derive(Debug, Clone)]
140pub struct ConnectorProxy {
141    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
142}
143
144impl fidl::endpoints::Proxy for ConnectorProxy {
145    type Protocol = ConnectorMarker;
146
147    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
148        Self::new(inner)
149    }
150
151    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
152        self.client.into_channel().map_err(|client| Self { client })
153    }
154
155    fn as_channel(&self) -> &::fidl::AsyncChannel {
156        self.client.as_channel()
157    }
158}
159
160impl ConnectorProxy {
161    /// Create a new Proxy for fuchsia.power.clientlevel/Connector.
162    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
163        let protocol_name = <ConnectorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
164        Self { client: fidl::client::Client::new(channel, protocol_name) }
165    }
166
167    /// Get a Stream of events from the remote end of the protocol.
168    ///
169    /// # Panics
170    ///
171    /// Panics if the event stream was already taken.
172    pub fn take_event_stream(&self) -> ConnectorEventStream {
173        ConnectorEventStream { event_receiver: self.client.take_event_receiver() }
174    }
175
176    /// Connects a [`Watcher`] to the power level of the specified
177    /// [`ClientType`].
178    ///
179    /// A client may call this method and begin using the [`Watcher`] client
180    /// endpoint immediately.
181    ///
182    /// If a power configuration does not exist for the provided `client_type`,
183    /// then the request will fail. On failure, both the `watcher` server
184    /// endpoint as well as the current `Connector` connection will be
185    /// terminated.
186    ///
187    /// + `client_type` specifies to which [`ClientType`] power level that
188    /// `watcher` should be connected. The value is valid iff a power
189    /// configuration exists for the provided `client_type`.
190    ///
191    /// + `watcher` is the server endpoint of a [`Watcher`] channel that will be
192    /// connected to the [`ClientType`] power level.
193    pub fn r#connect(
194        &self,
195        mut client_type: ClientType,
196        mut watcher: fidl::endpoints::ServerEnd<WatcherMarker>,
197    ) -> Result<(), fidl::Error> {
198        ConnectorProxyInterface::r#connect(self, client_type, watcher)
199    }
200}
201
202impl ConnectorProxyInterface for ConnectorProxy {
203    fn r#connect(
204        &self,
205        mut client_type: ClientType,
206        mut watcher: fidl::endpoints::ServerEnd<WatcherMarker>,
207    ) -> Result<(), fidl::Error> {
208        self.client.send::<ConnectorConnectRequest>(
209            (client_type, watcher),
210            0x29e603fe743fd08a,
211            fidl::encoding::DynamicFlags::empty(),
212        )
213    }
214}
215
216pub struct ConnectorEventStream {
217    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
218}
219
220impl std::marker::Unpin for ConnectorEventStream {}
221
222impl futures::stream::FusedStream for ConnectorEventStream {
223    fn is_terminated(&self) -> bool {
224        self.event_receiver.is_terminated()
225    }
226}
227
228impl futures::Stream for ConnectorEventStream {
229    type Item = Result<ConnectorEvent, fidl::Error>;
230
231    fn poll_next(
232        mut self: std::pin::Pin<&mut Self>,
233        cx: &mut std::task::Context<'_>,
234    ) -> std::task::Poll<Option<Self::Item>> {
235        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
236            &mut self.event_receiver,
237            cx
238        )?) {
239            Some(buf) => std::task::Poll::Ready(Some(ConnectorEvent::decode(buf))),
240            None => std::task::Poll::Ready(None),
241        }
242    }
243}
244
245#[derive(Debug)]
246pub enum ConnectorEvent {}
247
248impl ConnectorEvent {
249    /// Decodes a message buffer as a [`ConnectorEvent`].
250    fn decode(
251        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
252    ) -> Result<ConnectorEvent, fidl::Error> {
253        let (bytes, _handles) = buf.split_mut();
254        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
255        debug_assert_eq!(tx_header.tx_id, 0);
256        match tx_header.ordinal {
257            _ => Err(fidl::Error::UnknownOrdinal {
258                ordinal: tx_header.ordinal,
259                protocol_name: <ConnectorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
260            }),
261        }
262    }
263}
264
265/// A Stream of incoming requests for fuchsia.power.clientlevel/Connector.
266pub struct ConnectorRequestStream {
267    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
268    is_terminated: bool,
269}
270
271impl std::marker::Unpin for ConnectorRequestStream {}
272
273impl futures::stream::FusedStream for ConnectorRequestStream {
274    fn is_terminated(&self) -> bool {
275        self.is_terminated
276    }
277}
278
279impl fidl::endpoints::RequestStream for ConnectorRequestStream {
280    type Protocol = ConnectorMarker;
281    type ControlHandle = ConnectorControlHandle;
282
283    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
284        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
285    }
286
287    fn control_handle(&self) -> Self::ControlHandle {
288        ConnectorControlHandle { inner: self.inner.clone() }
289    }
290
291    fn into_inner(
292        self,
293    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
294    {
295        (self.inner, self.is_terminated)
296    }
297
298    fn from_inner(
299        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
300        is_terminated: bool,
301    ) -> Self {
302        Self { inner, is_terminated }
303    }
304}
305
306impl futures::Stream for ConnectorRequestStream {
307    type Item = Result<ConnectorRequest, fidl::Error>;
308
309    fn poll_next(
310        mut self: std::pin::Pin<&mut Self>,
311        cx: &mut std::task::Context<'_>,
312    ) -> std::task::Poll<Option<Self::Item>> {
313        let this = &mut *self;
314        if this.inner.check_shutdown(cx) {
315            this.is_terminated = true;
316            return std::task::Poll::Ready(None);
317        }
318        if this.is_terminated {
319            panic!("polled ConnectorRequestStream after completion");
320        }
321        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
322            |bytes, handles| {
323                match this.inner.channel().read_etc(cx, bytes, handles) {
324                    std::task::Poll::Ready(Ok(())) => {}
325                    std::task::Poll::Pending => return std::task::Poll::Pending,
326                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
327                        this.is_terminated = true;
328                        return std::task::Poll::Ready(None);
329                    }
330                    std::task::Poll::Ready(Err(e)) => {
331                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
332                            e.into(),
333                        ))));
334                    }
335                }
336
337                // A message has been received from the channel
338                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
339
340                std::task::Poll::Ready(Some(match header.ordinal {
341                    0x29e603fe743fd08a => {
342                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
343                        let mut req = fidl::new_empty!(
344                            ConnectorConnectRequest,
345                            fidl::encoding::DefaultFuchsiaResourceDialect
346                        );
347                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ConnectorConnectRequest>(&header, _body_bytes, handles, &mut req)?;
348                        let control_handle = ConnectorControlHandle { inner: this.inner.clone() };
349                        Ok(ConnectorRequest::Connect {
350                            client_type: req.client_type,
351                            watcher: req.watcher,
352
353                            control_handle,
354                        })
355                    }
356                    _ => Err(fidl::Error::UnknownOrdinal {
357                        ordinal: header.ordinal,
358                        protocol_name:
359                            <ConnectorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
360                    }),
361                }))
362            },
363        )
364    }
365}
366
367/// Allows a client to connect a [`Watcher`] to the power level of a given
368/// [`ClientType`].
369#[derive(Debug)]
370pub enum ConnectorRequest {
371    /// Connects a [`Watcher`] to the power level of the specified
372    /// [`ClientType`].
373    ///
374    /// A client may call this method and begin using the [`Watcher`] client
375    /// endpoint immediately.
376    ///
377    /// If a power configuration does not exist for the provided `client_type`,
378    /// then the request will fail. On failure, both the `watcher` server
379    /// endpoint as well as the current `Connector` connection will be
380    /// terminated.
381    ///
382    /// + `client_type` specifies to which [`ClientType`] power level that
383    /// `watcher` should be connected. The value is valid iff a power
384    /// configuration exists for the provided `client_type`.
385    ///
386    /// + `watcher` is the server endpoint of a [`Watcher`] channel that will be
387    /// connected to the [`ClientType`] power level.
388    Connect {
389        client_type: ClientType,
390        watcher: fidl::endpoints::ServerEnd<WatcherMarker>,
391        control_handle: ConnectorControlHandle,
392    },
393}
394
395impl ConnectorRequest {
396    #[allow(irrefutable_let_patterns)]
397    pub fn into_connect(
398        self,
399    ) -> Option<(ClientType, fidl::endpoints::ServerEnd<WatcherMarker>, ConnectorControlHandle)>
400    {
401        if let ConnectorRequest::Connect { client_type, watcher, control_handle } = self {
402            Some((client_type, watcher, control_handle))
403        } else {
404            None
405        }
406    }
407
408    /// Name of the method defined in FIDL
409    pub fn method_name(&self) -> &'static str {
410        match *self {
411            ConnectorRequest::Connect { .. } => "connect",
412        }
413    }
414}
415
416#[derive(Debug, Clone)]
417pub struct ConnectorControlHandle {
418    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
419}
420
421impl fidl::endpoints::ControlHandle for ConnectorControlHandle {
422    fn shutdown(&self) {
423        self.inner.shutdown()
424    }
425    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
426        self.inner.shutdown_with_epitaph(status)
427    }
428
429    fn is_closed(&self) -> bool {
430        self.inner.channel().is_closed()
431    }
432    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
433        self.inner.channel().on_closed()
434    }
435
436    #[cfg(target_os = "fuchsia")]
437    fn signal_peer(
438        &self,
439        clear_mask: zx::Signals,
440        set_mask: zx::Signals,
441    ) -> Result<(), zx_status::Status> {
442        use fidl::Peered;
443        self.inner.channel().signal_peer(clear_mask, set_mask)
444    }
445}
446
447impl ConnectorControlHandle {}
448
449#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
450pub struct WatcherMarker;
451
452impl fidl::endpoints::ProtocolMarker for WatcherMarker {
453    type Proxy = WatcherProxy;
454    type RequestStream = WatcherRequestStream;
455    #[cfg(target_os = "fuchsia")]
456    type SynchronousProxy = WatcherSynchronousProxy;
457
458    const DEBUG_NAME: &'static str = "(anonymous) Watcher";
459}
460
461pub trait WatcherProxyInterface: Send + Sync {
462    type WatchResponseFut: std::future::Future<Output = Result<u64, fidl::Error>> + Send;
463    fn r#watch(&self) -> Self::WatchResponseFut;
464}
465#[derive(Debug)]
466#[cfg(target_os = "fuchsia")]
467pub struct WatcherSynchronousProxy {
468    client: fidl::client::sync::Client,
469}
470
471#[cfg(target_os = "fuchsia")]
472impl fidl::endpoints::SynchronousProxy for WatcherSynchronousProxy {
473    type Proxy = WatcherProxy;
474    type Protocol = WatcherMarker;
475
476    fn from_channel(inner: fidl::Channel) -> Self {
477        Self::new(inner)
478    }
479
480    fn into_channel(self) -> fidl::Channel {
481        self.client.into_channel()
482    }
483
484    fn as_channel(&self) -> &fidl::Channel {
485        self.client.as_channel()
486    }
487}
488
489#[cfg(target_os = "fuchsia")]
490impl WatcherSynchronousProxy {
491    pub fn new(channel: fidl::Channel) -> Self {
492        let protocol_name = <WatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
493        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
494    }
495
496    pub fn into_channel(self) -> fidl::Channel {
497        self.client.into_channel()
498    }
499
500    /// Waits until an event arrives and returns it. It is safe for other
501    /// threads to make concurrent requests while waiting for an event.
502    pub fn wait_for_event(
503        &self,
504        deadline: zx::MonotonicInstant,
505    ) -> Result<WatcherEvent, fidl::Error> {
506        WatcherEvent::decode(self.client.wait_for_event(deadline)?)
507    }
508
509    /// Watches for changes to the power level of the connected [`ClientType`].
510    ///
511    /// The power level for a given [`ClientType`] is determined according to
512    /// the power configuration for that [`ClientType`]. See the
513    /// [README.md](/src/power/power-manager/system_power_mode_config/README.md)
514    /// for more details.
515    ///
516    /// On a given connection, the first call will return immediately with the
517    /// current power level for the connected [`ClientType`]. Subsequent `Watch`
518    /// requests will only return a new `level` if the power level of the
519    /// connected [`ClientType`] has changed. This follows the [hanging
520    /// get](https://fuchsia.dev/fuchsia-src/concepts/api/fidl#hanging-get)
521    /// pattern.
522    ///
523    /// - `level` is an unsigned integer representing the power level of the
524    /// connected [`ClientType`].
525    pub fn r#watch(&self, ___deadline: zx::MonotonicInstant) -> Result<u64, fidl::Error> {
526        let _response =
527            self.client.send_query::<fidl::encoding::EmptyPayload, WatcherWatchResponse>(
528                (),
529                0x29592d2e62f4101a,
530                fidl::encoding::DynamicFlags::empty(),
531                ___deadline,
532            )?;
533        Ok(_response.level)
534    }
535}
536
537#[cfg(target_os = "fuchsia")]
538impl From<WatcherSynchronousProxy> for zx::Handle {
539    fn from(value: WatcherSynchronousProxy) -> Self {
540        value.into_channel().into()
541    }
542}
543
544#[cfg(target_os = "fuchsia")]
545impl From<fidl::Channel> for WatcherSynchronousProxy {
546    fn from(value: fidl::Channel) -> Self {
547        Self::new(value)
548    }
549}
550
551#[cfg(target_os = "fuchsia")]
552impl fidl::endpoints::FromClient for WatcherSynchronousProxy {
553    type Protocol = WatcherMarker;
554
555    fn from_client(value: fidl::endpoints::ClientEnd<WatcherMarker>) -> Self {
556        Self::new(value.into_channel())
557    }
558}
559
560#[derive(Debug, Clone)]
561pub struct WatcherProxy {
562    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
563}
564
565impl fidl::endpoints::Proxy for WatcherProxy {
566    type Protocol = WatcherMarker;
567
568    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
569        Self::new(inner)
570    }
571
572    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
573        self.client.into_channel().map_err(|client| Self { client })
574    }
575
576    fn as_channel(&self) -> &::fidl::AsyncChannel {
577        self.client.as_channel()
578    }
579}
580
581impl WatcherProxy {
582    /// Create a new Proxy for fuchsia.power.clientlevel/Watcher.
583    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
584        let protocol_name = <WatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
585        Self { client: fidl::client::Client::new(channel, protocol_name) }
586    }
587
588    /// Get a Stream of events from the remote end of the protocol.
589    ///
590    /// # Panics
591    ///
592    /// Panics if the event stream was already taken.
593    pub fn take_event_stream(&self) -> WatcherEventStream {
594        WatcherEventStream { event_receiver: self.client.take_event_receiver() }
595    }
596
597    /// Watches for changes to the power level of the connected [`ClientType`].
598    ///
599    /// The power level for a given [`ClientType`] is determined according to
600    /// the power configuration for that [`ClientType`]. See the
601    /// [README.md](/src/power/power-manager/system_power_mode_config/README.md)
602    /// for more details.
603    ///
604    /// On a given connection, the first call will return immediately with the
605    /// current power level for the connected [`ClientType`]. Subsequent `Watch`
606    /// requests will only return a new `level` if the power level of the
607    /// connected [`ClientType`] has changed. This follows the [hanging
608    /// get](https://fuchsia.dev/fuchsia-src/concepts/api/fidl#hanging-get)
609    /// pattern.
610    ///
611    /// - `level` is an unsigned integer representing the power level of the
612    /// connected [`ClientType`].
613    pub fn r#watch(
614        &self,
615    ) -> fidl::client::QueryResponseFut<u64, fidl::encoding::DefaultFuchsiaResourceDialect> {
616        WatcherProxyInterface::r#watch(self)
617    }
618}
619
620impl WatcherProxyInterface for WatcherProxy {
621    type WatchResponseFut =
622        fidl::client::QueryResponseFut<u64, fidl::encoding::DefaultFuchsiaResourceDialect>;
623    fn r#watch(&self) -> Self::WatchResponseFut {
624        fn _decode(
625            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
626        ) -> Result<u64, fidl::Error> {
627            let _response = fidl::client::decode_transaction_body::<
628                WatcherWatchResponse,
629                fidl::encoding::DefaultFuchsiaResourceDialect,
630                0x29592d2e62f4101a,
631            >(_buf?)?;
632            Ok(_response.level)
633        }
634        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, u64>(
635            (),
636            0x29592d2e62f4101a,
637            fidl::encoding::DynamicFlags::empty(),
638            _decode,
639        )
640    }
641}
642
643pub struct WatcherEventStream {
644    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
645}
646
647impl std::marker::Unpin for WatcherEventStream {}
648
649impl futures::stream::FusedStream for WatcherEventStream {
650    fn is_terminated(&self) -> bool {
651        self.event_receiver.is_terminated()
652    }
653}
654
655impl futures::Stream for WatcherEventStream {
656    type Item = Result<WatcherEvent, fidl::Error>;
657
658    fn poll_next(
659        mut self: std::pin::Pin<&mut Self>,
660        cx: &mut std::task::Context<'_>,
661    ) -> std::task::Poll<Option<Self::Item>> {
662        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
663            &mut self.event_receiver,
664            cx
665        )?) {
666            Some(buf) => std::task::Poll::Ready(Some(WatcherEvent::decode(buf))),
667            None => std::task::Poll::Ready(None),
668        }
669    }
670}
671
672#[derive(Debug)]
673pub enum WatcherEvent {}
674
675impl WatcherEvent {
676    /// Decodes a message buffer as a [`WatcherEvent`].
677    fn decode(
678        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
679    ) -> Result<WatcherEvent, fidl::Error> {
680        let (bytes, _handles) = buf.split_mut();
681        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
682        debug_assert_eq!(tx_header.tx_id, 0);
683        match tx_header.ordinal {
684            _ => Err(fidl::Error::UnknownOrdinal {
685                ordinal: tx_header.ordinal,
686                protocol_name: <WatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
687            }),
688        }
689    }
690}
691
692/// A Stream of incoming requests for fuchsia.power.clientlevel/Watcher.
693pub struct WatcherRequestStream {
694    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
695    is_terminated: bool,
696}
697
698impl std::marker::Unpin for WatcherRequestStream {}
699
700impl futures::stream::FusedStream for WatcherRequestStream {
701    fn is_terminated(&self) -> bool {
702        self.is_terminated
703    }
704}
705
706impl fidl::endpoints::RequestStream for WatcherRequestStream {
707    type Protocol = WatcherMarker;
708    type ControlHandle = WatcherControlHandle;
709
710    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
711        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
712    }
713
714    fn control_handle(&self) -> Self::ControlHandle {
715        WatcherControlHandle { inner: self.inner.clone() }
716    }
717
718    fn into_inner(
719        self,
720    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
721    {
722        (self.inner, self.is_terminated)
723    }
724
725    fn from_inner(
726        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
727        is_terminated: bool,
728    ) -> Self {
729        Self { inner, is_terminated }
730    }
731}
732
733impl futures::Stream for WatcherRequestStream {
734    type Item = Result<WatcherRequest, fidl::Error>;
735
736    fn poll_next(
737        mut self: std::pin::Pin<&mut Self>,
738        cx: &mut std::task::Context<'_>,
739    ) -> std::task::Poll<Option<Self::Item>> {
740        let this = &mut *self;
741        if this.inner.check_shutdown(cx) {
742            this.is_terminated = true;
743            return std::task::Poll::Ready(None);
744        }
745        if this.is_terminated {
746            panic!("polled WatcherRequestStream after completion");
747        }
748        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
749            |bytes, handles| {
750                match this.inner.channel().read_etc(cx, bytes, handles) {
751                    std::task::Poll::Ready(Ok(())) => {}
752                    std::task::Poll::Pending => return std::task::Poll::Pending,
753                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
754                        this.is_terminated = true;
755                        return std::task::Poll::Ready(None);
756                    }
757                    std::task::Poll::Ready(Err(e)) => {
758                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
759                            e.into(),
760                        ))));
761                    }
762                }
763
764                // A message has been received from the channel
765                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
766
767                std::task::Poll::Ready(Some(match header.ordinal {
768                    0x29592d2e62f4101a => {
769                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
770                        let mut req = fidl::new_empty!(
771                            fidl::encoding::EmptyPayload,
772                            fidl::encoding::DefaultFuchsiaResourceDialect
773                        );
774                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
775                        let control_handle = WatcherControlHandle { inner: this.inner.clone() };
776                        Ok(WatcherRequest::Watch {
777                            responder: WatcherWatchResponder {
778                                control_handle: std::mem::ManuallyDrop::new(control_handle),
779                                tx_id: header.tx_id,
780                            },
781                        })
782                    }
783                    _ => Err(fidl::Error::UnknownOrdinal {
784                        ordinal: header.ordinal,
785                        protocol_name:
786                            <WatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
787                    }),
788                }))
789            },
790        )
791    }
792}
793
794/// Allows a client to watch for changes to the power level of a given
795/// [`ClientType`].
796///
797/// This protocol cannot be connected to the service directly. Instead, the
798/// server endpoint of a `Watcher` channel must first be connected to the power
799/// level of the desired [`ClientType`] using the [`Connector.Connect`] method.
800/// The client endpoint of a `Watcher` channel is only useful after it has been
801/// connected in this way.
802#[derive(Debug)]
803pub enum WatcherRequest {
804    /// Watches for changes to the power level of the connected [`ClientType`].
805    ///
806    /// The power level for a given [`ClientType`] is determined according to
807    /// the power configuration for that [`ClientType`]. See the
808    /// [README.md](/src/power/power-manager/system_power_mode_config/README.md)
809    /// for more details.
810    ///
811    /// On a given connection, the first call will return immediately with the
812    /// current power level for the connected [`ClientType`]. Subsequent `Watch`
813    /// requests will only return a new `level` if the power level of the
814    /// connected [`ClientType`] has changed. This follows the [hanging
815    /// get](https://fuchsia.dev/fuchsia-src/concepts/api/fidl#hanging-get)
816    /// pattern.
817    ///
818    /// - `level` is an unsigned integer representing the power level of the
819    /// connected [`ClientType`].
820    Watch { responder: WatcherWatchResponder },
821}
822
823impl WatcherRequest {
824    #[allow(irrefutable_let_patterns)]
825    pub fn into_watch(self) -> Option<(WatcherWatchResponder)> {
826        if let WatcherRequest::Watch { responder } = self { Some((responder)) } else { None }
827    }
828
829    /// Name of the method defined in FIDL
830    pub fn method_name(&self) -> &'static str {
831        match *self {
832            WatcherRequest::Watch { .. } => "watch",
833        }
834    }
835}
836
837#[derive(Debug, Clone)]
838pub struct WatcherControlHandle {
839    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
840}
841
842impl fidl::endpoints::ControlHandle for WatcherControlHandle {
843    fn shutdown(&self) {
844        self.inner.shutdown()
845    }
846    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
847        self.inner.shutdown_with_epitaph(status)
848    }
849
850    fn is_closed(&self) -> bool {
851        self.inner.channel().is_closed()
852    }
853    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
854        self.inner.channel().on_closed()
855    }
856
857    #[cfg(target_os = "fuchsia")]
858    fn signal_peer(
859        &self,
860        clear_mask: zx::Signals,
861        set_mask: zx::Signals,
862    ) -> Result<(), zx_status::Status> {
863        use fidl::Peered;
864        self.inner.channel().signal_peer(clear_mask, set_mask)
865    }
866}
867
868impl WatcherControlHandle {}
869
870#[must_use = "FIDL methods require a response to be sent"]
871#[derive(Debug)]
872pub struct WatcherWatchResponder {
873    control_handle: std::mem::ManuallyDrop<WatcherControlHandle>,
874    tx_id: u32,
875}
876
877/// Set the the channel to be shutdown (see [`WatcherControlHandle::shutdown`])
878/// if the responder is dropped without sending a response, so that the client
879/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
880impl std::ops::Drop for WatcherWatchResponder {
881    fn drop(&mut self) {
882        self.control_handle.shutdown();
883        // Safety: drops once, never accessed again
884        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
885    }
886}
887
888impl fidl::endpoints::Responder for WatcherWatchResponder {
889    type ControlHandle = WatcherControlHandle;
890
891    fn control_handle(&self) -> &WatcherControlHandle {
892        &self.control_handle
893    }
894
895    fn drop_without_shutdown(mut self) {
896        // Safety: drops once, never accessed again due to mem::forget
897        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
898        // Prevent Drop from running (which would shut down the channel)
899        std::mem::forget(self);
900    }
901}
902
903impl WatcherWatchResponder {
904    /// Sends a response to the FIDL transaction.
905    ///
906    /// Sets the channel to shutdown if an error occurs.
907    pub fn send(self, mut level: u64) -> Result<(), fidl::Error> {
908        let _result = self.send_raw(level);
909        if _result.is_err() {
910            self.control_handle.shutdown();
911        }
912        self.drop_without_shutdown();
913        _result
914    }
915
916    /// Similar to "send" but does not shutdown the channel if an error occurs.
917    pub fn send_no_shutdown_on_err(self, mut level: u64) -> Result<(), fidl::Error> {
918        let _result = self.send_raw(level);
919        self.drop_without_shutdown();
920        _result
921    }
922
923    fn send_raw(&self, mut level: u64) -> Result<(), fidl::Error> {
924        self.control_handle.inner.send::<WatcherWatchResponse>(
925            (level,),
926            self.tx_id,
927            0x29592d2e62f4101a,
928            fidl::encoding::DynamicFlags::empty(),
929        )
930    }
931}
932
933mod internal {
934    use super::*;
935
936    impl fidl::encoding::ResourceTypeMarker for ConnectorConnectRequest {
937        type Borrowed<'a> = &'a mut Self;
938        fn take_or_borrow<'a>(
939            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
940        ) -> Self::Borrowed<'a> {
941            value
942        }
943    }
944
945    unsafe impl fidl::encoding::TypeMarker for ConnectorConnectRequest {
946        type Owned = Self;
947
948        #[inline(always)]
949        fn inline_align(_context: fidl::encoding::Context) -> usize {
950            4
951        }
952
953        #[inline(always)]
954        fn inline_size(_context: fidl::encoding::Context) -> usize {
955            8
956        }
957    }
958
959    unsafe impl
960        fidl::encoding::Encode<
961            ConnectorConnectRequest,
962            fidl::encoding::DefaultFuchsiaResourceDialect,
963        > for &mut ConnectorConnectRequest
964    {
965        #[inline]
966        unsafe fn encode(
967            self,
968            encoder: &mut fidl::encoding::Encoder<
969                '_,
970                fidl::encoding::DefaultFuchsiaResourceDialect,
971            >,
972            offset: usize,
973            _depth: fidl::encoding::Depth,
974        ) -> fidl::Result<()> {
975            encoder.debug_check_bounds::<ConnectorConnectRequest>(offset);
976            // Delegate to tuple encoding.
977            fidl::encoding::Encode::<ConnectorConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
978                (
979                    <ClientType as fidl::encoding::ValueTypeMarker>::borrow(&self.client_type),
980                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<WatcherMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.watcher),
981                ),
982                encoder, offset, _depth
983            )
984        }
985    }
986    unsafe impl<
987        T0: fidl::encoding::Encode<ClientType, fidl::encoding::DefaultFuchsiaResourceDialect>,
988        T1: fidl::encoding::Encode<
989                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<WatcherMarker>>,
990                fidl::encoding::DefaultFuchsiaResourceDialect,
991            >,
992    >
993        fidl::encoding::Encode<
994            ConnectorConnectRequest,
995            fidl::encoding::DefaultFuchsiaResourceDialect,
996        > for (T0, T1)
997    {
998        #[inline]
999        unsafe fn encode(
1000            self,
1001            encoder: &mut fidl::encoding::Encoder<
1002                '_,
1003                fidl::encoding::DefaultFuchsiaResourceDialect,
1004            >,
1005            offset: usize,
1006            depth: fidl::encoding::Depth,
1007        ) -> fidl::Result<()> {
1008            encoder.debug_check_bounds::<ConnectorConnectRequest>(offset);
1009            // Zero out padding regions. There's no need to apply masks
1010            // because the unmasked parts will be overwritten by fields.
1011            // Write the fields.
1012            self.0.encode(encoder, offset + 0, depth)?;
1013            self.1.encode(encoder, offset + 4, depth)?;
1014            Ok(())
1015        }
1016    }
1017
1018    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1019        for ConnectorConnectRequest
1020    {
1021        #[inline(always)]
1022        fn new_empty() -> Self {
1023            Self {
1024                client_type: fidl::new_empty!(
1025                    ClientType,
1026                    fidl::encoding::DefaultFuchsiaResourceDialect
1027                ),
1028                watcher: fidl::new_empty!(
1029                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<WatcherMarker>>,
1030                    fidl::encoding::DefaultFuchsiaResourceDialect
1031                ),
1032            }
1033        }
1034
1035        #[inline]
1036        unsafe fn decode(
1037            &mut self,
1038            decoder: &mut fidl::encoding::Decoder<
1039                '_,
1040                fidl::encoding::DefaultFuchsiaResourceDialect,
1041            >,
1042            offset: usize,
1043            _depth: fidl::encoding::Depth,
1044        ) -> fidl::Result<()> {
1045            decoder.debug_check_bounds::<Self>(offset);
1046            // Verify that padding bytes are zero.
1047            fidl::decode!(
1048                ClientType,
1049                fidl::encoding::DefaultFuchsiaResourceDialect,
1050                &mut self.client_type,
1051                decoder,
1052                offset + 0,
1053                _depth
1054            )?;
1055            fidl::decode!(
1056                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<WatcherMarker>>,
1057                fidl::encoding::DefaultFuchsiaResourceDialect,
1058                &mut self.watcher,
1059                decoder,
1060                offset + 4,
1061                _depth
1062            )?;
1063            Ok(())
1064        }
1065    }
1066}
fidl_fuchsia_power_clientlevel/fidl_fuchsia_power_clientlevel.rs

fidl_fuchsia_power_clientlevel/
fidl_fuchsia_power_clientlevel.rs
