fidl_fuchsia_net_reachability/
fidl_fuchsia_net_reachability.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_net_reachability_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
15pub struct MonitorMarker;
16
17impl fidl::endpoints::ProtocolMarker for MonitorMarker {
18    type Proxy = MonitorProxy;
19    type RequestStream = MonitorRequestStream;
20    #[cfg(target_os = "fuchsia")]
21    type SynchronousProxy = MonitorSynchronousProxy;
22
23    const DEBUG_NAME: &'static str = "fuchsia.net.reachability.Monitor";
24}
25impl fidl::endpoints::DiscoverableProtocolMarker for MonitorMarker {}
26
27pub trait MonitorProxyInterface: Send + Sync {
28    fn r#set_options(&self, payload: &MonitorOptions) -> Result<(), fidl::Error>;
29    type WatchResponseFut: std::future::Future<Output = Result<Snapshot, fidl::Error>> + Send;
30    fn r#watch(&self) -> Self::WatchResponseFut;
31}
32#[derive(Debug)]
33#[cfg(target_os = "fuchsia")]
34pub struct MonitorSynchronousProxy {
35    client: fidl::client::sync::Client,
36}
37
38#[cfg(target_os = "fuchsia")]
39impl fidl::endpoints::SynchronousProxy for MonitorSynchronousProxy {
40    type Proxy = MonitorProxy;
41    type Protocol = MonitorMarker;
42
43    fn from_channel(inner: fidl::Channel) -> Self {
44        Self::new(inner)
45    }
46
47    fn into_channel(self) -> fidl::Channel {
48        self.client.into_channel()
49    }
50
51    fn as_channel(&self) -> &fidl::Channel {
52        self.client.as_channel()
53    }
54}
55
56#[cfg(target_os = "fuchsia")]
57impl MonitorSynchronousProxy {
58    pub fn new(channel: fidl::Channel) -> Self {
59        let protocol_name = <MonitorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
60        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
61    }
62
63    pub fn into_channel(self) -> fidl::Channel {
64        self.client.into_channel()
65    }
66
67    /// Waits until an event arrives and returns it. It is safe for other
68    /// threads to make concurrent requests while waiting for an event.
69    pub fn wait_for_event(
70        &self,
71        deadline: zx::MonotonicInstant,
72    ) -> Result<MonitorEvent, fidl::Error> {
73        MonitorEvent::decode(self.client.wait_for_event(deadline)?)
74    }
75
76    /// Controls verbosity of results returned from calls to [`Watch`]. If
77    /// options are set via this method, it must be in the first call made
78    /// over the channel.
79    ///
80    /// Calling this method after either it or [`Watch`] have already been
81    /// invoked will result in closing the channel. If this method is not
82    /// called before calling [`Watch`], [`Snapshot`] responses will not be
83    /// modified.
84    pub fn r#set_options(&self, mut payload: &MonitorOptions) -> Result<(), fidl::Error> {
85        self.client.send::<MonitorOptions>(
86            payload,
87            0x2e4e66abc4374253,
88            fidl::encoding::DynamicFlags::empty(),
89        )
90    }
91
92    /// Hanging-get API for changes in network reachability state.
93    ///
94    /// `Watch` returns a snapshot of the system's most recent reachability
95    /// state information. The first call returns a current snapshot.
96    /// Subsequent calls to `Watch` block until the previously-observed state
97    /// changes.
98    ///
99    /// While this API guarantees that any state returned was a valid network
100    /// state at some point, it does not guarantee observation of every
101    /// intermediate state.
102    ///
103    /// It is not valid to call `Watch` concurrently. Calling `Watch` while
104    /// another call over the same server end is in flight will result in the
105    /// closing the channel.
106    ///
107    /// - response a snapshot of current system reachability state.
108    pub fn r#watch(&self, ___deadline: zx::MonotonicInstant) -> Result<Snapshot, fidl::Error> {
109        let _response = self.client.send_query::<fidl::encoding::EmptyPayload, Snapshot>(
110            (),
111            0x381ea392fef3667f,
112            fidl::encoding::DynamicFlags::empty(),
113            ___deadline,
114        )?;
115        Ok(_response)
116    }
117}
118
119#[cfg(target_os = "fuchsia")]
120impl From<MonitorSynchronousProxy> for zx::Handle {
121    fn from(value: MonitorSynchronousProxy) -> Self {
122        value.into_channel().into()
123    }
124}
125
126#[cfg(target_os = "fuchsia")]
127impl From<fidl::Channel> for MonitorSynchronousProxy {
128    fn from(value: fidl::Channel) -> Self {
129        Self::new(value)
130    }
131}
132
133#[derive(Debug, Clone)]
134pub struct MonitorProxy {
135    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
136}
137
138impl fidl::endpoints::Proxy for MonitorProxy {
139    type Protocol = MonitorMarker;
140
141    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
142        Self::new(inner)
143    }
144
145    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
146        self.client.into_channel().map_err(|client| Self { client })
147    }
148
149    fn as_channel(&self) -> &::fidl::AsyncChannel {
150        self.client.as_channel()
151    }
152}
153
154impl MonitorProxy {
155    /// Create a new Proxy for fuchsia.net.reachability/Monitor.
156    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
157        let protocol_name = <MonitorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
158        Self { client: fidl::client::Client::new(channel, protocol_name) }
159    }
160
161    /// Get a Stream of events from the remote end of the protocol.
162    ///
163    /// # Panics
164    ///
165    /// Panics if the event stream was already taken.
166    pub fn take_event_stream(&self) -> MonitorEventStream {
167        MonitorEventStream { event_receiver: self.client.take_event_receiver() }
168    }
169
170    /// Controls verbosity of results returned from calls to [`Watch`]. If
171    /// options are set via this method, it must be in the first call made
172    /// over the channel.
173    ///
174    /// Calling this method after either it or [`Watch`] have already been
175    /// invoked will result in closing the channel. If this method is not
176    /// called before calling [`Watch`], [`Snapshot`] responses will not be
177    /// modified.
178    pub fn r#set_options(&self, mut payload: &MonitorOptions) -> Result<(), fidl::Error> {
179        MonitorProxyInterface::r#set_options(self, payload)
180    }
181
182    /// Hanging-get API for changes in network reachability state.
183    ///
184    /// `Watch` returns a snapshot of the system's most recent reachability
185    /// state information. The first call returns a current snapshot.
186    /// Subsequent calls to `Watch` block until the previously-observed state
187    /// changes.
188    ///
189    /// While this API guarantees that any state returned was a valid network
190    /// state at some point, it does not guarantee observation of every
191    /// intermediate state.
192    ///
193    /// It is not valid to call `Watch` concurrently. Calling `Watch` while
194    /// another call over the same server end is in flight will result in the
195    /// closing the channel.
196    ///
197    /// - response a snapshot of current system reachability state.
198    pub fn r#watch(
199        &self,
200    ) -> fidl::client::QueryResponseFut<Snapshot, fidl::encoding::DefaultFuchsiaResourceDialect>
201    {
202        MonitorProxyInterface::r#watch(self)
203    }
204}
205
206impl MonitorProxyInterface for MonitorProxy {
207    fn r#set_options(&self, mut payload: &MonitorOptions) -> Result<(), fidl::Error> {
208        self.client.send::<MonitorOptions>(
209            payload,
210            0x2e4e66abc4374253,
211            fidl::encoding::DynamicFlags::empty(),
212        )
213    }
214
215    type WatchResponseFut =
216        fidl::client::QueryResponseFut<Snapshot, fidl::encoding::DefaultFuchsiaResourceDialect>;
217    fn r#watch(&self) -> Self::WatchResponseFut {
218        fn _decode(
219            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
220        ) -> Result<Snapshot, fidl::Error> {
221            let _response = fidl::client::decode_transaction_body::<
222                Snapshot,
223                fidl::encoding::DefaultFuchsiaResourceDialect,
224                0x381ea392fef3667f,
225            >(_buf?)?;
226            Ok(_response)
227        }
228        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Snapshot>(
229            (),
230            0x381ea392fef3667f,
231            fidl::encoding::DynamicFlags::empty(),
232            _decode,
233        )
234    }
235}
236
237pub struct MonitorEventStream {
238    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
239}
240
241impl std::marker::Unpin for MonitorEventStream {}
242
243impl futures::stream::FusedStream for MonitorEventStream {
244    fn is_terminated(&self) -> bool {
245        self.event_receiver.is_terminated()
246    }
247}
248
249impl futures::Stream for MonitorEventStream {
250    type Item = Result<MonitorEvent, fidl::Error>;
251
252    fn poll_next(
253        mut self: std::pin::Pin<&mut Self>,
254        cx: &mut std::task::Context<'_>,
255    ) -> std::task::Poll<Option<Self::Item>> {
256        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
257            &mut self.event_receiver,
258            cx
259        )?) {
260            Some(buf) => std::task::Poll::Ready(Some(MonitorEvent::decode(buf))),
261            None => std::task::Poll::Ready(None),
262        }
263    }
264}
265
266#[derive(Debug)]
267pub enum MonitorEvent {}
268
269impl MonitorEvent {
270    /// Decodes a message buffer as a [`MonitorEvent`].
271    fn decode(
272        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
273    ) -> Result<MonitorEvent, fidl::Error> {
274        let (bytes, _handles) = buf.split_mut();
275        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
276        debug_assert_eq!(tx_header.tx_id, 0);
277        match tx_header.ordinal {
278            _ => Err(fidl::Error::UnknownOrdinal {
279                ordinal: tx_header.ordinal,
280                protocol_name: <MonitorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
281            }),
282        }
283    }
284}
285
286/// A Stream of incoming requests for fuchsia.net.reachability/Monitor.
287pub struct MonitorRequestStream {
288    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
289    is_terminated: bool,
290}
291
292impl std::marker::Unpin for MonitorRequestStream {}
293
294impl futures::stream::FusedStream for MonitorRequestStream {
295    fn is_terminated(&self) -> bool {
296        self.is_terminated
297    }
298}
299
300impl fidl::endpoints::RequestStream for MonitorRequestStream {
301    type Protocol = MonitorMarker;
302    type ControlHandle = MonitorControlHandle;
303
304    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
305        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
306    }
307
308    fn control_handle(&self) -> Self::ControlHandle {
309        MonitorControlHandle { inner: self.inner.clone() }
310    }
311
312    fn into_inner(
313        self,
314    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
315    {
316        (self.inner, self.is_terminated)
317    }
318
319    fn from_inner(
320        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
321        is_terminated: bool,
322    ) -> Self {
323        Self { inner, is_terminated }
324    }
325}
326
327impl futures::Stream for MonitorRequestStream {
328    type Item = Result<MonitorRequest, fidl::Error>;
329
330    fn poll_next(
331        mut self: std::pin::Pin<&mut Self>,
332        cx: &mut std::task::Context<'_>,
333    ) -> std::task::Poll<Option<Self::Item>> {
334        let this = &mut *self;
335        if this.inner.check_shutdown(cx) {
336            this.is_terminated = true;
337            return std::task::Poll::Ready(None);
338        }
339        if this.is_terminated {
340            panic!("polled MonitorRequestStream after completion");
341        }
342        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
343            |bytes, handles| {
344                match this.inner.channel().read_etc(cx, bytes, handles) {
345                    std::task::Poll::Ready(Ok(())) => {}
346                    std::task::Poll::Pending => return std::task::Poll::Pending,
347                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
348                        this.is_terminated = true;
349                        return std::task::Poll::Ready(None);
350                    }
351                    std::task::Poll::Ready(Err(e)) => {
352                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
353                            e.into(),
354                        ))))
355                    }
356                }
357
358                // A message has been received from the channel
359                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
360
361                std::task::Poll::Ready(Some(match header.ordinal {
362                    0x2e4e66abc4374253 => {
363                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
364                        let mut req = fidl::new_empty!(
365                            MonitorOptions,
366                            fidl::encoding::DefaultFuchsiaResourceDialect
367                        );
368                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MonitorOptions>(&header, _body_bytes, handles, &mut req)?;
369                        let control_handle = MonitorControlHandle { inner: this.inner.clone() };
370                        Ok(MonitorRequest::SetOptions { payload: req, control_handle })
371                    }
372                    0x381ea392fef3667f => {
373                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
374                        let mut req = fidl::new_empty!(
375                            fidl::encoding::EmptyPayload,
376                            fidl::encoding::DefaultFuchsiaResourceDialect
377                        );
378                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
379                        let control_handle = MonitorControlHandle { inner: this.inner.clone() };
380                        Ok(MonitorRequest::Watch {
381                            responder: MonitorWatchResponder {
382                                control_handle: std::mem::ManuallyDrop::new(control_handle),
383                                tx_id: header.tx_id,
384                            },
385                        })
386                    }
387                    _ => Err(fidl::Error::UnknownOrdinal {
388                        ordinal: header.ordinal,
389                        protocol_name:
390                            <MonitorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
391                    }),
392                }))
393            },
394        )
395    }
396}
397
398/// Provides snapshots of reachability state.
399#[derive(Debug)]
400pub enum MonitorRequest {
401    /// Controls verbosity of results returned from calls to [`Watch`]. If
402    /// options are set via this method, it must be in the first call made
403    /// over the channel.
404    ///
405    /// Calling this method after either it or [`Watch`] have already been
406    /// invoked will result in closing the channel. If this method is not
407    /// called before calling [`Watch`], [`Snapshot`] responses will not be
408    /// modified.
409    SetOptions { payload: MonitorOptions, control_handle: MonitorControlHandle },
410    /// Hanging-get API for changes in network reachability state.
411    ///
412    /// `Watch` returns a snapshot of the system's most recent reachability
413    /// state information. The first call returns a current snapshot.
414    /// Subsequent calls to `Watch` block until the previously-observed state
415    /// changes.
416    ///
417    /// While this API guarantees that any state returned was a valid network
418    /// state at some point, it does not guarantee observation of every
419    /// intermediate state.
420    ///
421    /// It is not valid to call `Watch` concurrently. Calling `Watch` while
422    /// another call over the same server end is in flight will result in the
423    /// closing the channel.
424    ///
425    /// - response a snapshot of current system reachability state.
426    Watch { responder: MonitorWatchResponder },
427}
428
429impl MonitorRequest {
430    #[allow(irrefutable_let_patterns)]
431    pub fn into_set_options(self) -> Option<(MonitorOptions, MonitorControlHandle)> {
432        if let MonitorRequest::SetOptions { payload, control_handle } = self {
433            Some((payload, control_handle))
434        } else {
435            None
436        }
437    }
438
439    #[allow(irrefutable_let_patterns)]
440    pub fn into_watch(self) -> Option<(MonitorWatchResponder)> {
441        if let MonitorRequest::Watch { responder } = self {
442            Some((responder))
443        } else {
444            None
445        }
446    }
447
448    /// Name of the method defined in FIDL
449    pub fn method_name(&self) -> &'static str {
450        match *self {
451            MonitorRequest::SetOptions { .. } => "set_options",
452            MonitorRequest::Watch { .. } => "watch",
453        }
454    }
455}
456
457#[derive(Debug, Clone)]
458pub struct MonitorControlHandle {
459    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
460}
461
462impl fidl::endpoints::ControlHandle for MonitorControlHandle {
463    fn shutdown(&self) {
464        self.inner.shutdown()
465    }
466    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
467        self.inner.shutdown_with_epitaph(status)
468    }
469
470    fn is_closed(&self) -> bool {
471        self.inner.channel().is_closed()
472    }
473    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
474        self.inner.channel().on_closed()
475    }
476
477    #[cfg(target_os = "fuchsia")]
478    fn signal_peer(
479        &self,
480        clear_mask: zx::Signals,
481        set_mask: zx::Signals,
482    ) -> Result<(), zx_status::Status> {
483        use fidl::Peered;
484        self.inner.channel().signal_peer(clear_mask, set_mask)
485    }
486}
487
488impl MonitorControlHandle {}
489
490#[must_use = "FIDL methods require a response to be sent"]
491#[derive(Debug)]
492pub struct MonitorWatchResponder {
493    control_handle: std::mem::ManuallyDrop<MonitorControlHandle>,
494    tx_id: u32,
495}
496
497/// Set the the channel to be shutdown (see [`MonitorControlHandle::shutdown`])
498/// if the responder is dropped without sending a response, so that the client
499/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
500impl std::ops::Drop for MonitorWatchResponder {
501    fn drop(&mut self) {
502        self.control_handle.shutdown();
503        // Safety: drops once, never accessed again
504        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
505    }
506}
507
508impl fidl::endpoints::Responder for MonitorWatchResponder {
509    type ControlHandle = MonitorControlHandle;
510
511    fn control_handle(&self) -> &MonitorControlHandle {
512        &self.control_handle
513    }
514
515    fn drop_without_shutdown(mut self) {
516        // Safety: drops once, never accessed again due to mem::forget
517        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
518        // Prevent Drop from running (which would shut down the channel)
519        std::mem::forget(self);
520    }
521}
522
523impl MonitorWatchResponder {
524    /// Sends a response to the FIDL transaction.
525    ///
526    /// Sets the channel to shutdown if an error occurs.
527    pub fn send(self, mut payload: &Snapshot) -> Result<(), fidl::Error> {
528        let _result = self.send_raw(payload);
529        if _result.is_err() {
530            self.control_handle.shutdown();
531        }
532        self.drop_without_shutdown();
533        _result
534    }
535
536    /// Similar to "send" but does not shutdown the channel if an error occurs.
537    pub fn send_no_shutdown_on_err(self, mut payload: &Snapshot) -> Result<(), fidl::Error> {
538        let _result = self.send_raw(payload);
539        self.drop_without_shutdown();
540        _result
541    }
542
543    fn send_raw(&self, mut payload: &Snapshot) -> Result<(), fidl::Error> {
544        self.control_handle.inner.send::<Snapshot>(
545            payload,
546            self.tx_id,
547            0x381ea392fef3667f,
548            fidl::encoding::DynamicFlags::empty(),
549        )
550    }
551}
552
553mod internal {
554    use super::*;
555}
fidl_fuchsia_net_reachability/fidl_fuchsia_net_reachability.rs

fidl_fuchsia_net_reachability/
fidl_fuchsia_net_reachability.rs
