fidl_fuchsia_bluetooth_snoop/
fidl_fuchsia_bluetooth_snoop.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_bluetooth_snoop__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Default, PartialEq)]
15pub struct SnoopStartRequest {
16    pub follow: Option<bool>,
17    pub host_device: Option<String>,
18    pub client: Option<fidl::endpoints::ClientEnd<PacketObserverMarker>>,
19    #[doc(hidden)]
20    pub __source_breaking: fidl::marker::SourceBreaking,
21}
22
23impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for SnoopStartRequest {}
24
25#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
26pub struct PacketObserverMarker;
27
28impl fidl::endpoints::ProtocolMarker for PacketObserverMarker {
29    type Proxy = PacketObserverProxy;
30    type RequestStream = PacketObserverRequestStream;
31    #[cfg(target_os = "fuchsia")]
32    type SynchronousProxy = PacketObserverSynchronousProxy;
33
34    const DEBUG_NAME: &'static str = "(anonymous) PacketObserver";
35}
36
37pub trait PacketObserverProxyInterface: Send + Sync {
38    type ObserveResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
39    fn r#observe(&self, payload: &DevicePackets) -> Self::ObserveResponseFut;
40    fn r#error(&self, payload: &CaptureError) -> Result<(), fidl::Error>;
41}
42#[derive(Debug)]
43#[cfg(target_os = "fuchsia")]
44pub struct PacketObserverSynchronousProxy {
45    client: fidl::client::sync::Client,
46}
47
48#[cfg(target_os = "fuchsia")]
49impl fidl::endpoints::SynchronousProxy for PacketObserverSynchronousProxy {
50    type Proxy = PacketObserverProxy;
51    type Protocol = PacketObserverMarker;
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 PacketObserverSynchronousProxy {
68    pub fn new(channel: fidl::Channel) -> Self {
69        let protocol_name = <PacketObserverMarker 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<PacketObserverEvent, fidl::Error> {
83        PacketObserverEvent::decode(self.client.wait_for_event(deadline)?)
84    }
85
86    /// Observe some packets which have been transmitted over HCI.
87    /// Return ack is used for flow control.
88    pub fn r#observe(
89        &self,
90        mut payload: &DevicePackets,
91        ___deadline: zx::MonotonicInstant,
92    ) -> Result<(), fidl::Error> {
93        let _response = self
94            .client
95            .send_query::<DevicePackets, fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
96                payload,
97                0x2a82a5a9a18b79c9,
98                fidl::encoding::DynamicFlags::FLEXIBLE,
99                ___deadline,
100            )?
101            .into_result::<PacketObserverMarker>("observe")?;
102        Ok(_response)
103    }
104
105    /// Called when an error occurs either during capture or while starting
106    /// capture.  The protocol will be closed after this is sent.
107    pub fn r#error(&self, mut payload: &CaptureError) -> Result<(), fidl::Error> {
108        self.client.send::<CaptureError>(
109            payload,
110            0x6596e43f4f0761e4,
111            fidl::encoding::DynamicFlags::FLEXIBLE,
112        )
113    }
114}
115
116#[cfg(target_os = "fuchsia")]
117impl From<PacketObserverSynchronousProxy> for zx::Handle {
118    fn from(value: PacketObserverSynchronousProxy) -> Self {
119        value.into_channel().into()
120    }
121}
122
123#[cfg(target_os = "fuchsia")]
124impl From<fidl::Channel> for PacketObserverSynchronousProxy {
125    fn from(value: fidl::Channel) -> Self {
126        Self::new(value)
127    }
128}
129
130#[cfg(target_os = "fuchsia")]
131impl fidl::endpoints::FromClient for PacketObserverSynchronousProxy {
132    type Protocol = PacketObserverMarker;
133
134    fn from_client(value: fidl::endpoints::ClientEnd<PacketObserverMarker>) -> Self {
135        Self::new(value.into_channel())
136    }
137}
138
139#[derive(Debug, Clone)]
140pub struct PacketObserverProxy {
141    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
142}
143
144impl fidl::endpoints::Proxy for PacketObserverProxy {
145    type Protocol = PacketObserverMarker;
146
147    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
148        Self::new(inner)
149    }
150
151    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
152        self.client.into_channel().map_err(|client| Self { client })
153    }
154
155    fn as_channel(&self) -> &::fidl::AsyncChannel {
156        self.client.as_channel()
157    }
158}
159
160impl PacketObserverProxy {
161    /// Create a new Proxy for fuchsia.bluetooth.snoop/PacketObserver.
162    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
163        let protocol_name = <PacketObserverMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
164        Self { client: fidl::client::Client::new(channel, protocol_name) }
165    }
166
167    /// Get a Stream of events from the remote end of the protocol.
168    ///
169    /// # Panics
170    ///
171    /// Panics if the event stream was already taken.
172    pub fn take_event_stream(&self) -> PacketObserverEventStream {
173        PacketObserverEventStream { event_receiver: self.client.take_event_receiver() }
174    }
175
176    /// Observe some packets which have been transmitted over HCI.
177    /// Return ack is used for flow control.
178    pub fn r#observe(
179        &self,
180        mut payload: &DevicePackets,
181    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
182        PacketObserverProxyInterface::r#observe(self, payload)
183    }
184
185    /// Called when an error occurs either during capture or while starting
186    /// capture.  The protocol will be closed after this is sent.
187    pub fn r#error(&self, mut payload: &CaptureError) -> Result<(), fidl::Error> {
188        PacketObserverProxyInterface::r#error(self, payload)
189    }
190}
191
192impl PacketObserverProxyInterface for PacketObserverProxy {
193    type ObserveResponseFut =
194        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
195    fn r#observe(&self, mut payload: &DevicePackets) -> Self::ObserveResponseFut {
196        fn _decode(
197            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
198        ) -> Result<(), fidl::Error> {
199            let _response = fidl::client::decode_transaction_body::<
200                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
201                fidl::encoding::DefaultFuchsiaResourceDialect,
202                0x2a82a5a9a18b79c9,
203            >(_buf?)?
204            .into_result::<PacketObserverMarker>("observe")?;
205            Ok(_response)
206        }
207        self.client.send_query_and_decode::<DevicePackets, ()>(
208            payload,
209            0x2a82a5a9a18b79c9,
210            fidl::encoding::DynamicFlags::FLEXIBLE,
211            _decode,
212        )
213    }
214
215    fn r#error(&self, mut payload: &CaptureError) -> Result<(), fidl::Error> {
216        self.client.send::<CaptureError>(
217            payload,
218            0x6596e43f4f0761e4,
219            fidl::encoding::DynamicFlags::FLEXIBLE,
220        )
221    }
222}
223
224pub struct PacketObserverEventStream {
225    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
226}
227
228impl std::marker::Unpin for PacketObserverEventStream {}
229
230impl futures::stream::FusedStream for PacketObserverEventStream {
231    fn is_terminated(&self) -> bool {
232        self.event_receiver.is_terminated()
233    }
234}
235
236impl futures::Stream for PacketObserverEventStream {
237    type Item = Result<PacketObserverEvent, fidl::Error>;
238
239    fn poll_next(
240        mut self: std::pin::Pin<&mut Self>,
241        cx: &mut std::task::Context<'_>,
242    ) -> std::task::Poll<Option<Self::Item>> {
243        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
244            &mut self.event_receiver,
245            cx
246        )?) {
247            Some(buf) => std::task::Poll::Ready(Some(PacketObserverEvent::decode(buf))),
248            None => std::task::Poll::Ready(None),
249        }
250    }
251}
252
253#[derive(Debug)]
254pub enum PacketObserverEvent {
255    #[non_exhaustive]
256    _UnknownEvent {
257        /// Ordinal of the event that was sent.
258        ordinal: u64,
259    },
260}
261
262impl PacketObserverEvent {
263    /// Decodes a message buffer as a [`PacketObserverEvent`].
264    fn decode(
265        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
266    ) -> Result<PacketObserverEvent, fidl::Error> {
267        let (bytes, _handles) = buf.split_mut();
268        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
269        debug_assert_eq!(tx_header.tx_id, 0);
270        match tx_header.ordinal {
271            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
272                Ok(PacketObserverEvent::_UnknownEvent { ordinal: tx_header.ordinal })
273            }
274            _ => Err(fidl::Error::UnknownOrdinal {
275                ordinal: tx_header.ordinal,
276                protocol_name:
277                    <PacketObserverMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
278            }),
279        }
280    }
281}
282
283/// A Stream of incoming requests for fuchsia.bluetooth.snoop/PacketObserver.
284pub struct PacketObserverRequestStream {
285    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
286    is_terminated: bool,
287}
288
289impl std::marker::Unpin for PacketObserverRequestStream {}
290
291impl futures::stream::FusedStream for PacketObserverRequestStream {
292    fn is_terminated(&self) -> bool {
293        self.is_terminated
294    }
295}
296
297impl fidl::endpoints::RequestStream for PacketObserverRequestStream {
298    type Protocol = PacketObserverMarker;
299    type ControlHandle = PacketObserverControlHandle;
300
301    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
302        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
303    }
304
305    fn control_handle(&self) -> Self::ControlHandle {
306        PacketObserverControlHandle { inner: self.inner.clone() }
307    }
308
309    fn into_inner(
310        self,
311    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
312    {
313        (self.inner, self.is_terminated)
314    }
315
316    fn from_inner(
317        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
318        is_terminated: bool,
319    ) -> Self {
320        Self { inner, is_terminated }
321    }
322}
323
324impl futures::Stream for PacketObserverRequestStream {
325    type Item = Result<PacketObserverRequest, fidl::Error>;
326
327    fn poll_next(
328        mut self: std::pin::Pin<&mut Self>,
329        cx: &mut std::task::Context<'_>,
330    ) -> std::task::Poll<Option<Self::Item>> {
331        let this = &mut *self;
332        if this.inner.check_shutdown(cx) {
333            this.is_terminated = true;
334            return std::task::Poll::Ready(None);
335        }
336        if this.is_terminated {
337            panic!("polled PacketObserverRequestStream after completion");
338        }
339        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
340            |bytes, handles| {
341                match this.inner.channel().read_etc(cx, bytes, handles) {
342                    std::task::Poll::Ready(Ok(())) => {}
343                    std::task::Poll::Pending => return std::task::Poll::Pending,
344                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
345                        this.is_terminated = true;
346                        return std::task::Poll::Ready(None);
347                    }
348                    std::task::Poll::Ready(Err(e)) => {
349                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
350                            e.into(),
351                        ))))
352                    }
353                }
354
355                // A message has been received from the channel
356                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
357
358                std::task::Poll::Ready(Some(match header.ordinal {
359                    0x2a82a5a9a18b79c9 => {
360                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
361                        let mut req = fidl::new_empty!(
362                            DevicePackets,
363                            fidl::encoding::DefaultFuchsiaResourceDialect
364                        );
365                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DevicePackets>(&header, _body_bytes, handles, &mut req)?;
366                        let control_handle =
367                            PacketObserverControlHandle { inner: this.inner.clone() };
368                        Ok(PacketObserverRequest::Observe {
369                            payload: req,
370                            responder: PacketObserverObserveResponder {
371                                control_handle: std::mem::ManuallyDrop::new(control_handle),
372                                tx_id: header.tx_id,
373                            },
374                        })
375                    }
376                    0x6596e43f4f0761e4 => {
377                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
378                        let mut req = fidl::new_empty!(
379                            CaptureError,
380                            fidl::encoding::DefaultFuchsiaResourceDialect
381                        );
382                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CaptureError>(&header, _body_bytes, handles, &mut req)?;
383                        let control_handle =
384                            PacketObserverControlHandle { inner: this.inner.clone() };
385                        Ok(PacketObserverRequest::Error { payload: req, control_handle })
386                    }
387                    _ if header.tx_id == 0
388                        && header
389                            .dynamic_flags()
390                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
391                    {
392                        Ok(PacketObserverRequest::_UnknownMethod {
393                            ordinal: header.ordinal,
394                            control_handle: PacketObserverControlHandle {
395                                inner: this.inner.clone(),
396                            },
397                            method_type: fidl::MethodType::OneWay,
398                        })
399                    }
400                    _ if header
401                        .dynamic_flags()
402                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
403                    {
404                        this.inner.send_framework_err(
405                            fidl::encoding::FrameworkErr::UnknownMethod,
406                            header.tx_id,
407                            header.ordinal,
408                            header.dynamic_flags(),
409                            (bytes, handles),
410                        )?;
411                        Ok(PacketObserverRequest::_UnknownMethod {
412                            ordinal: header.ordinal,
413                            control_handle: PacketObserverControlHandle {
414                                inner: this.inner.clone(),
415                            },
416                            method_type: fidl::MethodType::TwoWay,
417                        })
418                    }
419                    _ => Err(fidl::Error::UnknownOrdinal {
420                        ordinal: header.ordinal,
421                        protocol_name:
422                            <PacketObserverMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
423                    }),
424                }))
425            },
426        )
427    }
428}
429
430#[derive(Debug)]
431pub enum PacketObserverRequest {
432    /// Observe some packets which have been transmitted over HCI.
433    /// Return ack is used for flow control.
434    Observe { payload: DevicePackets, responder: PacketObserverObserveResponder },
435    /// Called when an error occurs either during capture or while starting
436    /// capture.  The protocol will be closed after this is sent.
437    Error { payload: CaptureError, control_handle: PacketObserverControlHandle },
438    /// An interaction was received which does not match any known method.
439    #[non_exhaustive]
440    _UnknownMethod {
441        /// Ordinal of the method that was called.
442        ordinal: u64,
443        control_handle: PacketObserverControlHandle,
444        method_type: fidl::MethodType,
445    },
446}
447
448impl PacketObserverRequest {
449    #[allow(irrefutable_let_patterns)]
450    pub fn into_observe(self) -> Option<(DevicePackets, PacketObserverObserveResponder)> {
451        if let PacketObserverRequest::Observe { payload, responder } = self {
452            Some((payload, responder))
453        } else {
454            None
455        }
456    }
457
458    #[allow(irrefutable_let_patterns)]
459    pub fn into_error(self) -> Option<(CaptureError, PacketObserverControlHandle)> {
460        if let PacketObserverRequest::Error { payload, control_handle } = self {
461            Some((payload, control_handle))
462        } else {
463            None
464        }
465    }
466
467    /// Name of the method defined in FIDL
468    pub fn method_name(&self) -> &'static str {
469        match *self {
470            PacketObserverRequest::Observe { .. } => "observe",
471            PacketObserverRequest::Error { .. } => "error",
472            PacketObserverRequest::_UnknownMethod {
473                method_type: fidl::MethodType::OneWay, ..
474            } => "unknown one-way method",
475            PacketObserverRequest::_UnknownMethod {
476                method_type: fidl::MethodType::TwoWay, ..
477            } => "unknown two-way method",
478        }
479    }
480}
481
482#[derive(Debug, Clone)]
483pub struct PacketObserverControlHandle {
484    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
485}
486
487impl fidl::endpoints::ControlHandle for PacketObserverControlHandle {
488    fn shutdown(&self) {
489        self.inner.shutdown()
490    }
491    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
492        self.inner.shutdown_with_epitaph(status)
493    }
494
495    fn is_closed(&self) -> bool {
496        self.inner.channel().is_closed()
497    }
498    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
499        self.inner.channel().on_closed()
500    }
501
502    #[cfg(target_os = "fuchsia")]
503    fn signal_peer(
504        &self,
505        clear_mask: zx::Signals,
506        set_mask: zx::Signals,
507    ) -> Result<(), zx_status::Status> {
508        use fidl::Peered;
509        self.inner.channel().signal_peer(clear_mask, set_mask)
510    }
511}
512
513impl PacketObserverControlHandle {}
514
515#[must_use = "FIDL methods require a response to be sent"]
516#[derive(Debug)]
517pub struct PacketObserverObserveResponder {
518    control_handle: std::mem::ManuallyDrop<PacketObserverControlHandle>,
519    tx_id: u32,
520}
521
522/// Set the the channel to be shutdown (see [`PacketObserverControlHandle::shutdown`])
523/// if the responder is dropped without sending a response, so that the client
524/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
525impl std::ops::Drop for PacketObserverObserveResponder {
526    fn drop(&mut self) {
527        self.control_handle.shutdown();
528        // Safety: drops once, never accessed again
529        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
530    }
531}
532
533impl fidl::endpoints::Responder for PacketObserverObserveResponder {
534    type ControlHandle = PacketObserverControlHandle;
535
536    fn control_handle(&self) -> &PacketObserverControlHandle {
537        &self.control_handle
538    }
539
540    fn drop_without_shutdown(mut self) {
541        // Safety: drops once, never accessed again due to mem::forget
542        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
543        // Prevent Drop from running (which would shut down the channel)
544        std::mem::forget(self);
545    }
546}
547
548impl PacketObserverObserveResponder {
549    /// Sends a response to the FIDL transaction.
550    ///
551    /// Sets the channel to shutdown if an error occurs.
552    pub fn send(self) -> Result<(), fidl::Error> {
553        let _result = self.send_raw();
554        if _result.is_err() {
555            self.control_handle.shutdown();
556        }
557        self.drop_without_shutdown();
558        _result
559    }
560
561    /// Similar to "send" but does not shutdown the channel if an error occurs.
562    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
563        let _result = self.send_raw();
564        self.drop_without_shutdown();
565        _result
566    }
567
568    fn send_raw(&self) -> Result<(), fidl::Error> {
569        self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
570            fidl::encoding::Flexible::new(()),
571            self.tx_id,
572            0x2a82a5a9a18b79c9,
573            fidl::encoding::DynamicFlags::FLEXIBLE,
574        )
575    }
576}
577
578#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
579pub struct SnoopMarker;
580
581impl fidl::endpoints::ProtocolMarker for SnoopMarker {
582    type Proxy = SnoopProxy;
583    type RequestStream = SnoopRequestStream;
584    #[cfg(target_os = "fuchsia")]
585    type SynchronousProxy = SnoopSynchronousProxy;
586
587    const DEBUG_NAME: &'static str = "fuchsia.bluetooth.snoop.Snoop";
588}
589impl fidl::endpoints::DiscoverableProtocolMarker for SnoopMarker {}
590
591pub trait SnoopProxyInterface: Send + Sync {
592    fn r#start(&self, payload: SnoopStartRequest) -> Result<(), fidl::Error>;
593}
594#[derive(Debug)]
595#[cfg(target_os = "fuchsia")]
596pub struct SnoopSynchronousProxy {
597    client: fidl::client::sync::Client,
598}
599
600#[cfg(target_os = "fuchsia")]
601impl fidl::endpoints::SynchronousProxy for SnoopSynchronousProxy {
602    type Proxy = SnoopProxy;
603    type Protocol = SnoopMarker;
604
605    fn from_channel(inner: fidl::Channel) -> Self {
606        Self::new(inner)
607    }
608
609    fn into_channel(self) -> fidl::Channel {
610        self.client.into_channel()
611    }
612
613    fn as_channel(&self) -> &fidl::Channel {
614        self.client.as_channel()
615    }
616}
617
618#[cfg(target_os = "fuchsia")]
619impl SnoopSynchronousProxy {
620    pub fn new(channel: fidl::Channel) -> Self {
621        let protocol_name = <SnoopMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
622        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
623    }
624
625    pub fn into_channel(self) -> fidl::Channel {
626        self.client.into_channel()
627    }
628
629    /// Waits until an event arrives and returns it. It is safe for other
630    /// threads to make concurrent requests while waiting for an event.
631    pub fn wait_for_event(
632        &self,
633        deadline: zx::MonotonicInstant,
634    ) -> Result<SnoopEvent, fidl::Error> {
635        SnoopEvent::decode(self.client.wait_for_event(deadline)?)
636    }
637
638    /// Subscribe to receive packets from the server. Packets that have been recorded are sent
639    /// first.
640    ///
641    /// If `follow` is true, the protocol stays open and packets are returned to the client as
642    /// the snoop server receives them. If `follow` is missing or false, the client is closed
643    /// when all currently recorded packets have been sent.
644    ///
645    /// A `host_device` name may be provided; if so, only events from that host are sent.
646    /// If `host_device` is absent, packets from all host devices are sent.
647    ///
648    /// Errors are reported through the client.
649    pub fn r#start(&self, mut payload: SnoopStartRequest) -> Result<(), fidl::Error> {
650        self.client.send::<SnoopStartRequest>(
651            &mut payload,
652            0xa520491a4a82f24,
653            fidl::encoding::DynamicFlags::FLEXIBLE,
654        )
655    }
656}
657
658#[cfg(target_os = "fuchsia")]
659impl From<SnoopSynchronousProxy> for zx::Handle {
660    fn from(value: SnoopSynchronousProxy) -> Self {
661        value.into_channel().into()
662    }
663}
664
665#[cfg(target_os = "fuchsia")]
666impl From<fidl::Channel> for SnoopSynchronousProxy {
667    fn from(value: fidl::Channel) -> Self {
668        Self::new(value)
669    }
670}
671
672#[cfg(target_os = "fuchsia")]
673impl fidl::endpoints::FromClient for SnoopSynchronousProxy {
674    type Protocol = SnoopMarker;
675
676    fn from_client(value: fidl::endpoints::ClientEnd<SnoopMarker>) -> Self {
677        Self::new(value.into_channel())
678    }
679}
680
681#[derive(Debug, Clone)]
682pub struct SnoopProxy {
683    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
684}
685
686impl fidl::endpoints::Proxy for SnoopProxy {
687    type Protocol = SnoopMarker;
688
689    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
690        Self::new(inner)
691    }
692
693    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
694        self.client.into_channel().map_err(|client| Self { client })
695    }
696
697    fn as_channel(&self) -> &::fidl::AsyncChannel {
698        self.client.as_channel()
699    }
700}
701
702impl SnoopProxy {
703    /// Create a new Proxy for fuchsia.bluetooth.snoop/Snoop.
704    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
705        let protocol_name = <SnoopMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
706        Self { client: fidl::client::Client::new(channel, protocol_name) }
707    }
708
709    /// Get a Stream of events from the remote end of the protocol.
710    ///
711    /// # Panics
712    ///
713    /// Panics if the event stream was already taken.
714    pub fn take_event_stream(&self) -> SnoopEventStream {
715        SnoopEventStream { event_receiver: self.client.take_event_receiver() }
716    }
717
718    /// Subscribe to receive packets from the server. Packets that have been recorded are sent
719    /// first.
720    ///
721    /// If `follow` is true, the protocol stays open and packets are returned to the client as
722    /// the snoop server receives them. If `follow` is missing or false, the client is closed
723    /// when all currently recorded packets have been sent.
724    ///
725    /// A `host_device` name may be provided; if so, only events from that host are sent.
726    /// If `host_device` is absent, packets from all host devices are sent.
727    ///
728    /// Errors are reported through the client.
729    pub fn r#start(&self, mut payload: SnoopStartRequest) -> Result<(), fidl::Error> {
730        SnoopProxyInterface::r#start(self, payload)
731    }
732}
733
734impl SnoopProxyInterface for SnoopProxy {
735    fn r#start(&self, mut payload: SnoopStartRequest) -> Result<(), fidl::Error> {
736        self.client.send::<SnoopStartRequest>(
737            &mut payload,
738            0xa520491a4a82f24,
739            fidl::encoding::DynamicFlags::FLEXIBLE,
740        )
741    }
742}
743
744pub struct SnoopEventStream {
745    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
746}
747
748impl std::marker::Unpin for SnoopEventStream {}
749
750impl futures::stream::FusedStream for SnoopEventStream {
751    fn is_terminated(&self) -> bool {
752        self.event_receiver.is_terminated()
753    }
754}
755
756impl futures::Stream for SnoopEventStream {
757    type Item = Result<SnoopEvent, fidl::Error>;
758
759    fn poll_next(
760        mut self: std::pin::Pin<&mut Self>,
761        cx: &mut std::task::Context<'_>,
762    ) -> std::task::Poll<Option<Self::Item>> {
763        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
764            &mut self.event_receiver,
765            cx
766        )?) {
767            Some(buf) => std::task::Poll::Ready(Some(SnoopEvent::decode(buf))),
768            None => std::task::Poll::Ready(None),
769        }
770    }
771}
772
773#[derive(Debug)]
774pub enum SnoopEvent {
775    #[non_exhaustive]
776    _UnknownEvent {
777        /// Ordinal of the event that was sent.
778        ordinal: u64,
779    },
780}
781
782impl SnoopEvent {
783    /// Decodes a message buffer as a [`SnoopEvent`].
784    fn decode(
785        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
786    ) -> Result<SnoopEvent, fidl::Error> {
787        let (bytes, _handles) = buf.split_mut();
788        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
789        debug_assert_eq!(tx_header.tx_id, 0);
790        match tx_header.ordinal {
791            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
792                Ok(SnoopEvent::_UnknownEvent { ordinal: tx_header.ordinal })
793            }
794            _ => Err(fidl::Error::UnknownOrdinal {
795                ordinal: tx_header.ordinal,
796                protocol_name: <SnoopMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
797            }),
798        }
799    }
800}
801
802/// A Stream of incoming requests for fuchsia.bluetooth.snoop/Snoop.
803pub struct SnoopRequestStream {
804    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
805    is_terminated: bool,
806}
807
808impl std::marker::Unpin for SnoopRequestStream {}
809
810impl futures::stream::FusedStream for SnoopRequestStream {
811    fn is_terminated(&self) -> bool {
812        self.is_terminated
813    }
814}
815
816impl fidl::endpoints::RequestStream for SnoopRequestStream {
817    type Protocol = SnoopMarker;
818    type ControlHandle = SnoopControlHandle;
819
820    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
821        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
822    }
823
824    fn control_handle(&self) -> Self::ControlHandle {
825        SnoopControlHandle { inner: self.inner.clone() }
826    }
827
828    fn into_inner(
829        self,
830    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
831    {
832        (self.inner, self.is_terminated)
833    }
834
835    fn from_inner(
836        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
837        is_terminated: bool,
838    ) -> Self {
839        Self { inner, is_terminated }
840    }
841}
842
843impl futures::Stream for SnoopRequestStream {
844    type Item = Result<SnoopRequest, fidl::Error>;
845
846    fn poll_next(
847        mut self: std::pin::Pin<&mut Self>,
848        cx: &mut std::task::Context<'_>,
849    ) -> std::task::Poll<Option<Self::Item>> {
850        let this = &mut *self;
851        if this.inner.check_shutdown(cx) {
852            this.is_terminated = true;
853            return std::task::Poll::Ready(None);
854        }
855        if this.is_terminated {
856            panic!("polled SnoopRequestStream after completion");
857        }
858        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
859            |bytes, handles| {
860                match this.inner.channel().read_etc(cx, bytes, handles) {
861                    std::task::Poll::Ready(Ok(())) => {}
862                    std::task::Poll::Pending => return std::task::Poll::Pending,
863                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
864                        this.is_terminated = true;
865                        return std::task::Poll::Ready(None);
866                    }
867                    std::task::Poll::Ready(Err(e)) => {
868                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
869                            e.into(),
870                        ))))
871                    }
872                }
873
874                // A message has been received from the channel
875                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
876
877                std::task::Poll::Ready(Some(match header.ordinal {
878                    0xa520491a4a82f24 => {
879                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
880                        let mut req = fidl::new_empty!(
881                            SnoopStartRequest,
882                            fidl::encoding::DefaultFuchsiaResourceDialect
883                        );
884                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SnoopStartRequest>(&header, _body_bytes, handles, &mut req)?;
885                        let control_handle = SnoopControlHandle { inner: this.inner.clone() };
886                        Ok(SnoopRequest::Start { payload: req, control_handle })
887                    }
888                    _ if header.tx_id == 0
889                        && header
890                            .dynamic_flags()
891                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
892                    {
893                        Ok(SnoopRequest::_UnknownMethod {
894                            ordinal: header.ordinal,
895                            control_handle: SnoopControlHandle { inner: this.inner.clone() },
896                            method_type: fidl::MethodType::OneWay,
897                        })
898                    }
899                    _ if header
900                        .dynamic_flags()
901                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
902                    {
903                        this.inner.send_framework_err(
904                            fidl::encoding::FrameworkErr::UnknownMethod,
905                            header.tx_id,
906                            header.ordinal,
907                            header.dynamic_flags(),
908                            (bytes, handles),
909                        )?;
910                        Ok(SnoopRequest::_UnknownMethod {
911                            ordinal: header.ordinal,
912                            control_handle: SnoopControlHandle { inner: this.inner.clone() },
913                            method_type: fidl::MethodType::TwoWay,
914                        })
915                    }
916                    _ => Err(fidl::Error::UnknownOrdinal {
917                        ordinal: header.ordinal,
918                        protocol_name: <SnoopMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
919                    }),
920                }))
921            },
922        )
923    }
924}
925
926/// Interface to receive packets recorded as received or transmitted for a Bluetooth host.
927#[derive(Debug)]
928pub enum SnoopRequest {
929    /// Subscribe to receive packets from the server. Packets that have been recorded are sent
930    /// first.
931    ///
932    /// If `follow` is true, the protocol stays open and packets are returned to the client as
933    /// the snoop server receives them. If `follow` is missing or false, the client is closed
934    /// when all currently recorded packets have been sent.
935    ///
936    /// A `host_device` name may be provided; if so, only events from that host are sent.
937    /// If `host_device` is absent, packets from all host devices are sent.
938    ///
939    /// Errors are reported through the client.
940    Start { payload: SnoopStartRequest, control_handle: SnoopControlHandle },
941    /// An interaction was received which does not match any known method.
942    #[non_exhaustive]
943    _UnknownMethod {
944        /// Ordinal of the method that was called.
945        ordinal: u64,
946        control_handle: SnoopControlHandle,
947        method_type: fidl::MethodType,
948    },
949}
950
951impl SnoopRequest {
952    #[allow(irrefutable_let_patterns)]
953    pub fn into_start(self) -> Option<(SnoopStartRequest, SnoopControlHandle)> {
954        if let SnoopRequest::Start { payload, control_handle } = self {
955            Some((payload, control_handle))
956        } else {
957            None
958        }
959    }
960
961    /// Name of the method defined in FIDL
962    pub fn method_name(&self) -> &'static str {
963        match *self {
964            SnoopRequest::Start { .. } => "start",
965            SnoopRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
966                "unknown one-way method"
967            }
968            SnoopRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
969                "unknown two-way method"
970            }
971        }
972    }
973}
974
975#[derive(Debug, Clone)]
976pub struct SnoopControlHandle {
977    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
978}
979
980impl fidl::endpoints::ControlHandle for SnoopControlHandle {
981    fn shutdown(&self) {
982        self.inner.shutdown()
983    }
984    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
985        self.inner.shutdown_with_epitaph(status)
986    }
987
988    fn is_closed(&self) -> bool {
989        self.inner.channel().is_closed()
990    }
991    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
992        self.inner.channel().on_closed()
993    }
994
995    #[cfg(target_os = "fuchsia")]
996    fn signal_peer(
997        &self,
998        clear_mask: zx::Signals,
999        set_mask: zx::Signals,
1000    ) -> Result<(), zx_status::Status> {
1001        use fidl::Peered;
1002        self.inner.channel().signal_peer(clear_mask, set_mask)
1003    }
1004}
1005
1006impl SnoopControlHandle {}
1007
1008mod internal {
1009    use super::*;
1010
1011    impl SnoopStartRequest {
1012        #[inline(always)]
1013        fn max_ordinal_present(&self) -> u64 {
1014            if let Some(_) = self.client {
1015                return 3;
1016            }
1017            if let Some(_) = self.host_device {
1018                return 2;
1019            }
1020            if let Some(_) = self.follow {
1021                return 1;
1022            }
1023            0
1024        }
1025    }
1026
1027    impl fidl::encoding::ResourceTypeMarker for SnoopStartRequest {
1028        type Borrowed<'a> = &'a mut Self;
1029        fn take_or_borrow<'a>(
1030            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1031        ) -> Self::Borrowed<'a> {
1032            value
1033        }
1034    }
1035
1036    unsafe impl fidl::encoding::TypeMarker for SnoopStartRequest {
1037        type Owned = Self;
1038
1039        #[inline(always)]
1040        fn inline_align(_context: fidl::encoding::Context) -> usize {
1041            8
1042        }
1043
1044        #[inline(always)]
1045        fn inline_size(_context: fidl::encoding::Context) -> usize {
1046            16
1047        }
1048    }
1049
1050    unsafe impl
1051        fidl::encoding::Encode<SnoopStartRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
1052        for &mut SnoopStartRequest
1053    {
1054        unsafe fn encode(
1055            self,
1056            encoder: &mut fidl::encoding::Encoder<
1057                '_,
1058                fidl::encoding::DefaultFuchsiaResourceDialect,
1059            >,
1060            offset: usize,
1061            mut depth: fidl::encoding::Depth,
1062        ) -> fidl::Result<()> {
1063            encoder.debug_check_bounds::<SnoopStartRequest>(offset);
1064            // Vector header
1065            let max_ordinal: u64 = self.max_ordinal_present();
1066            encoder.write_num(max_ordinal, offset);
1067            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1068            // Calling encoder.out_of_line_offset(0) is not allowed.
1069            if max_ordinal == 0 {
1070                return Ok(());
1071            }
1072            depth.increment()?;
1073            let envelope_size = 8;
1074            let bytes_len = max_ordinal as usize * envelope_size;
1075            #[allow(unused_variables)]
1076            let offset = encoder.out_of_line_offset(bytes_len);
1077            let mut _prev_end_offset: usize = 0;
1078            if 1 > max_ordinal {
1079                return Ok(());
1080            }
1081
1082            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1083            // are envelope_size bytes.
1084            let cur_offset: usize = (1 - 1) * envelope_size;
1085
1086            // Zero reserved fields.
1087            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1088
1089            // Safety:
1090            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1091            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1092            //   envelope_size bytes, there is always sufficient room.
1093            fidl::encoding::encode_in_envelope_optional::<
1094                bool,
1095                fidl::encoding::DefaultFuchsiaResourceDialect,
1096            >(
1097                self.follow.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1098                encoder,
1099                offset + cur_offset,
1100                depth,
1101            )?;
1102
1103            _prev_end_offset = cur_offset + envelope_size;
1104            if 2 > max_ordinal {
1105                return Ok(());
1106            }
1107
1108            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1109            // are envelope_size bytes.
1110            let cur_offset: usize = (2 - 1) * envelope_size;
1111
1112            // Zero reserved fields.
1113            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1114
1115            // Safety:
1116            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1117            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1118            //   envelope_size bytes, there is always sufficient room.
1119            fidl::encoding::encode_in_envelope_optional::<
1120                fidl::encoding::BoundedString<255>,
1121                fidl::encoding::DefaultFuchsiaResourceDialect,
1122            >(
1123                self.host_device.as_ref().map(
1124                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1125                ),
1126                encoder,
1127                offset + cur_offset,
1128                depth,
1129            )?;
1130
1131            _prev_end_offset = cur_offset + envelope_size;
1132            if 3 > max_ordinal {
1133                return Ok(());
1134            }
1135
1136            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1137            // are envelope_size bytes.
1138            let cur_offset: usize = (3 - 1) * envelope_size;
1139
1140            // Zero reserved fields.
1141            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1142
1143            // Safety:
1144            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1145            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1146            //   envelope_size bytes, there is always sufficient room.
1147            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PacketObserverMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
1148            self.client.as_mut().map(<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PacketObserverMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
1149            encoder, offset + cur_offset, depth
1150        )?;
1151
1152            _prev_end_offset = cur_offset + envelope_size;
1153
1154            Ok(())
1155        }
1156    }
1157
1158    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1159        for SnoopStartRequest
1160    {
1161        #[inline(always)]
1162        fn new_empty() -> Self {
1163            Self::default()
1164        }
1165
1166        unsafe fn decode(
1167            &mut self,
1168            decoder: &mut fidl::encoding::Decoder<
1169                '_,
1170                fidl::encoding::DefaultFuchsiaResourceDialect,
1171            >,
1172            offset: usize,
1173            mut depth: fidl::encoding::Depth,
1174        ) -> fidl::Result<()> {
1175            decoder.debug_check_bounds::<Self>(offset);
1176            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1177                None => return Err(fidl::Error::NotNullable),
1178                Some(len) => len,
1179            };
1180            // Calling decoder.out_of_line_offset(0) is not allowed.
1181            if len == 0 {
1182                return Ok(());
1183            };
1184            depth.increment()?;
1185            let envelope_size = 8;
1186            let bytes_len = len * envelope_size;
1187            let offset = decoder.out_of_line_offset(bytes_len)?;
1188            // Decode the envelope for each type.
1189            let mut _next_ordinal_to_read = 0;
1190            let mut next_offset = offset;
1191            let end_offset = offset + bytes_len;
1192            _next_ordinal_to_read += 1;
1193            if next_offset >= end_offset {
1194                return Ok(());
1195            }
1196
1197            // Decode unknown envelopes for gaps in ordinals.
1198            while _next_ordinal_to_read < 1 {
1199                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1200                _next_ordinal_to_read += 1;
1201                next_offset += envelope_size;
1202            }
1203
1204            let next_out_of_line = decoder.next_out_of_line();
1205            let handles_before = decoder.remaining_handles();
1206            if let Some((inlined, num_bytes, num_handles)) =
1207                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1208            {
1209                let member_inline_size =
1210                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1211                if inlined != (member_inline_size <= 4) {
1212                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1213                }
1214                let inner_offset;
1215                let mut inner_depth = depth.clone();
1216                if inlined {
1217                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1218                    inner_offset = next_offset;
1219                } else {
1220                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1221                    inner_depth.increment()?;
1222                }
1223                let val_ref = self.follow.get_or_insert_with(|| {
1224                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
1225                });
1226                fidl::decode!(
1227                    bool,
1228                    fidl::encoding::DefaultFuchsiaResourceDialect,
1229                    val_ref,
1230                    decoder,
1231                    inner_offset,
1232                    inner_depth
1233                )?;
1234                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1235                {
1236                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1237                }
1238                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1239                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1240                }
1241            }
1242
1243            next_offset += envelope_size;
1244            _next_ordinal_to_read += 1;
1245            if next_offset >= end_offset {
1246                return Ok(());
1247            }
1248
1249            // Decode unknown envelopes for gaps in ordinals.
1250            while _next_ordinal_to_read < 2 {
1251                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1252                _next_ordinal_to_read += 1;
1253                next_offset += envelope_size;
1254            }
1255
1256            let next_out_of_line = decoder.next_out_of_line();
1257            let handles_before = decoder.remaining_handles();
1258            if let Some((inlined, num_bytes, num_handles)) =
1259                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1260            {
1261                let member_inline_size =
1262                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
1263                        decoder.context,
1264                    );
1265                if inlined != (member_inline_size <= 4) {
1266                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1267                }
1268                let inner_offset;
1269                let mut inner_depth = depth.clone();
1270                if inlined {
1271                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1272                    inner_offset = next_offset;
1273                } else {
1274                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1275                    inner_depth.increment()?;
1276                }
1277                let val_ref = self.host_device.get_or_insert_with(|| {
1278                    fidl::new_empty!(
1279                        fidl::encoding::BoundedString<255>,
1280                        fidl::encoding::DefaultFuchsiaResourceDialect
1281                    )
1282                });
1283                fidl::decode!(
1284                    fidl::encoding::BoundedString<255>,
1285                    fidl::encoding::DefaultFuchsiaResourceDialect,
1286                    val_ref,
1287                    decoder,
1288                    inner_offset,
1289                    inner_depth
1290                )?;
1291                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1292                {
1293                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1294                }
1295                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1296                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1297                }
1298            }
1299
1300            next_offset += envelope_size;
1301            _next_ordinal_to_read += 1;
1302            if next_offset >= end_offset {
1303                return Ok(());
1304            }
1305
1306            // Decode unknown envelopes for gaps in ordinals.
1307            while _next_ordinal_to_read < 3 {
1308                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1309                _next_ordinal_to_read += 1;
1310                next_offset += envelope_size;
1311            }
1312
1313            let next_out_of_line = decoder.next_out_of_line();
1314            let handles_before = decoder.remaining_handles();
1315            if let Some((inlined, num_bytes, num_handles)) =
1316                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1317            {
1318                let member_inline_size = <fidl::encoding::Endpoint<
1319                    fidl::endpoints::ClientEnd<PacketObserverMarker>,
1320                > as fidl::encoding::TypeMarker>::inline_size(
1321                    decoder.context
1322                );
1323                if inlined != (member_inline_size <= 4) {
1324                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1325                }
1326                let inner_offset;
1327                let mut inner_depth = depth.clone();
1328                if inlined {
1329                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1330                    inner_offset = next_offset;
1331                } else {
1332                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1333                    inner_depth.increment()?;
1334                }
1335                let val_ref = self.client.get_or_insert_with(|| {
1336                    fidl::new_empty!(
1337                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PacketObserverMarker>>,
1338                        fidl::encoding::DefaultFuchsiaResourceDialect
1339                    )
1340                });
1341                fidl::decode!(
1342                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PacketObserverMarker>>,
1343                    fidl::encoding::DefaultFuchsiaResourceDialect,
1344                    val_ref,
1345                    decoder,
1346                    inner_offset,
1347                    inner_depth
1348                )?;
1349                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1350                {
1351                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1352                }
1353                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1354                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1355                }
1356            }
1357
1358            next_offset += envelope_size;
1359
1360            // Decode the remaining unknown envelopes.
1361            while next_offset < end_offset {
1362                _next_ordinal_to_read += 1;
1363                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1364                next_offset += envelope_size;
1365            }
1366
1367            Ok(())
1368        }
1369    }
1370}
fidl_fuchsia_bluetooth_snoop/fidl_fuchsia_bluetooth_snoop.rs

fidl_fuchsia_bluetooth_snoop/
fidl_fuchsia_bluetooth_snoop.rs
