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

fidl_fuchsia_power_clientlevel/
fidl_fuchsia_power_clientlevel.rs
