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

fidl_fuchsia_ui_activity/
fidl_fuchsia_ui_activity.rs
