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::NullableHandle {
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
492    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
493        self.inner.shutdown_with_epitaph(status)
494    }
495
496    fn is_closed(&self) -> bool {
497        self.inner.channel().is_closed()
498    }
499    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
500        self.inner.channel().on_closed()
501    }
502
503    #[cfg(target_os = "fuchsia")]
504    fn signal_peer(
505        &self,
506        clear_mask: zx::Signals,
507        set_mask: zx::Signals,
508    ) -> Result<(), zx_status::Status> {
509        use fidl::Peered;
510        self.inner.channel().signal_peer(clear_mask, set_mask)
511    }
512}
513
514impl PacketObserverControlHandle {}
515
516#[must_use = "FIDL methods require a response to be sent"]
517#[derive(Debug)]
518pub struct PacketObserverObserveResponder {
519    control_handle: std::mem::ManuallyDrop<PacketObserverControlHandle>,
520    tx_id: u32,
521}
522
523/// Set the the channel to be shutdown (see [`PacketObserverControlHandle::shutdown`])
524/// if the responder is dropped without sending a response, so that the client
525/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
526impl std::ops::Drop for PacketObserverObserveResponder {
527    fn drop(&mut self) {
528        self.control_handle.shutdown();
529        // Safety: drops once, never accessed again
530        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
531    }
532}
533
534impl fidl::endpoints::Responder for PacketObserverObserveResponder {
535    type ControlHandle = PacketObserverControlHandle;
536
537    fn control_handle(&self) -> &PacketObserverControlHandle {
538        &self.control_handle
539    }
540
541    fn drop_without_shutdown(mut self) {
542        // Safety: drops once, never accessed again due to mem::forget
543        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
544        // Prevent Drop from running (which would shut down the channel)
545        std::mem::forget(self);
546    }
547}
548
549impl PacketObserverObserveResponder {
550    /// Sends a response to the FIDL transaction.
551    ///
552    /// Sets the channel to shutdown if an error occurs.
553    pub fn send(self) -> Result<(), fidl::Error> {
554        let _result = self.send_raw();
555        if _result.is_err() {
556            self.control_handle.shutdown();
557        }
558        self.drop_without_shutdown();
559        _result
560    }
561
562    /// Similar to "send" but does not shutdown the channel if an error occurs.
563    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
564        let _result = self.send_raw();
565        self.drop_without_shutdown();
566        _result
567    }
568
569    fn send_raw(&self) -> Result<(), fidl::Error> {
570        self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
571            fidl::encoding::Flexible::new(()),
572            self.tx_id,
573            0x2a82a5a9a18b79c9,
574            fidl::encoding::DynamicFlags::FLEXIBLE,
575        )
576    }
577}
578
579#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
580pub struct SnoopMarker;
581
582impl fidl::endpoints::ProtocolMarker for SnoopMarker {
583    type Proxy = SnoopProxy;
584    type RequestStream = SnoopRequestStream;
585    #[cfg(target_os = "fuchsia")]
586    type SynchronousProxy = SnoopSynchronousProxy;
587
588    const DEBUG_NAME: &'static str = "fuchsia.bluetooth.snoop.Snoop";
589}
590impl fidl::endpoints::DiscoverableProtocolMarker for SnoopMarker {}
591
592pub trait SnoopProxyInterface: Send + Sync {
593    fn r#start(&self, payload: SnoopStartRequest) -> Result<(), fidl::Error>;
594}
595#[derive(Debug)]
596#[cfg(target_os = "fuchsia")]
597pub struct SnoopSynchronousProxy {
598    client: fidl::client::sync::Client,
599}
600
601#[cfg(target_os = "fuchsia")]
602impl fidl::endpoints::SynchronousProxy for SnoopSynchronousProxy {
603    type Proxy = SnoopProxy;
604    type Protocol = SnoopMarker;
605
606    fn from_channel(inner: fidl::Channel) -> Self {
607        Self::new(inner)
608    }
609
610    fn into_channel(self) -> fidl::Channel {
611        self.client.into_channel()
612    }
613
614    fn as_channel(&self) -> &fidl::Channel {
615        self.client.as_channel()
616    }
617}
618
619#[cfg(target_os = "fuchsia")]
620impl SnoopSynchronousProxy {
621    pub fn new(channel: fidl::Channel) -> Self {
622        let protocol_name = <SnoopMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
623        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
624    }
625
626    pub fn into_channel(self) -> fidl::Channel {
627        self.client.into_channel()
628    }
629
630    /// Waits until an event arrives and returns it. It is safe for other
631    /// threads to make concurrent requests while waiting for an event.
632    pub fn wait_for_event(
633        &self,
634        deadline: zx::MonotonicInstant,
635    ) -> Result<SnoopEvent, fidl::Error> {
636        SnoopEvent::decode(self.client.wait_for_event(deadline)?)
637    }
638
639    /// Subscribe to receive packets from the server. Packets that have been recorded are sent
640    /// first.
641    ///
642    /// If `follow` is true, the protocol stays open and packets are returned to the client as
643    /// the snoop server receives them. If `follow` is missing or false, the client is closed
644    /// when all currently recorded packets have been sent.
645    ///
646    /// A `host_device` name may be provided; if so, only events from that host are sent.
647    /// If `host_device` is absent, packets from all host devices are sent.
648    ///
649    /// Errors are reported through the client.
650    pub fn r#start(&self, mut payload: SnoopStartRequest) -> Result<(), fidl::Error> {
651        self.client.send::<SnoopStartRequest>(
652            &mut payload,
653            0xa520491a4a82f24,
654            fidl::encoding::DynamicFlags::FLEXIBLE,
655        )
656    }
657}
658
659#[cfg(target_os = "fuchsia")]
660impl From<SnoopSynchronousProxy> for zx::NullableHandle {
661    fn from(value: SnoopSynchronousProxy) -> Self {
662        value.into_channel().into()
663    }
664}
665
666#[cfg(target_os = "fuchsia")]
667impl From<fidl::Channel> for SnoopSynchronousProxy {
668    fn from(value: fidl::Channel) -> Self {
669        Self::new(value)
670    }
671}
672
673#[cfg(target_os = "fuchsia")]
674impl fidl::endpoints::FromClient for SnoopSynchronousProxy {
675    type Protocol = SnoopMarker;
676
677    fn from_client(value: fidl::endpoints::ClientEnd<SnoopMarker>) -> Self {
678        Self::new(value.into_channel())
679    }
680}
681
682#[derive(Debug, Clone)]
683pub struct SnoopProxy {
684    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
685}
686
687impl fidl::endpoints::Proxy for SnoopProxy {
688    type Protocol = SnoopMarker;
689
690    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
691        Self::new(inner)
692    }
693
694    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
695        self.client.into_channel().map_err(|client| Self { client })
696    }
697
698    fn as_channel(&self) -> &::fidl::AsyncChannel {
699        self.client.as_channel()
700    }
701}
702
703impl SnoopProxy {
704    /// Create a new Proxy for fuchsia.bluetooth.snoop/Snoop.
705    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
706        let protocol_name = <SnoopMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
707        Self { client: fidl::client::Client::new(channel, protocol_name) }
708    }
709
710    /// Get a Stream of events from the remote end of the protocol.
711    ///
712    /// # Panics
713    ///
714    /// Panics if the event stream was already taken.
715    pub fn take_event_stream(&self) -> SnoopEventStream {
716        SnoopEventStream { event_receiver: self.client.take_event_receiver() }
717    }
718
719    /// Subscribe to receive packets from the server. Packets that have been recorded are sent
720    /// first.
721    ///
722    /// If `follow` is true, the protocol stays open and packets are returned to the client as
723    /// the snoop server receives them. If `follow` is missing or false, the client is closed
724    /// when all currently recorded packets have been sent.
725    ///
726    /// A `host_device` name may be provided; if so, only events from that host are sent.
727    /// If `host_device` is absent, packets from all host devices are sent.
728    ///
729    /// Errors are reported through the client.
730    pub fn r#start(&self, mut payload: SnoopStartRequest) -> Result<(), fidl::Error> {
731        SnoopProxyInterface::r#start(self, payload)
732    }
733}
734
735impl SnoopProxyInterface for SnoopProxy {
736    fn r#start(&self, mut payload: SnoopStartRequest) -> Result<(), fidl::Error> {
737        self.client.send::<SnoopStartRequest>(
738            &mut payload,
739            0xa520491a4a82f24,
740            fidl::encoding::DynamicFlags::FLEXIBLE,
741        )
742    }
743}
744
745pub struct SnoopEventStream {
746    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
747}
748
749impl std::marker::Unpin for SnoopEventStream {}
750
751impl futures::stream::FusedStream for SnoopEventStream {
752    fn is_terminated(&self) -> bool {
753        self.event_receiver.is_terminated()
754    }
755}
756
757impl futures::Stream for SnoopEventStream {
758    type Item = Result<SnoopEvent, fidl::Error>;
759
760    fn poll_next(
761        mut self: std::pin::Pin<&mut Self>,
762        cx: &mut std::task::Context<'_>,
763    ) -> std::task::Poll<Option<Self::Item>> {
764        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
765            &mut self.event_receiver,
766            cx
767        )?) {
768            Some(buf) => std::task::Poll::Ready(Some(SnoopEvent::decode(buf))),
769            None => std::task::Poll::Ready(None),
770        }
771    }
772}
773
774#[derive(Debug)]
775pub enum SnoopEvent {
776    #[non_exhaustive]
777    _UnknownEvent {
778        /// Ordinal of the event that was sent.
779        ordinal: u64,
780    },
781}
782
783impl SnoopEvent {
784    /// Decodes a message buffer as a [`SnoopEvent`].
785    fn decode(
786        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
787    ) -> Result<SnoopEvent, fidl::Error> {
788        let (bytes, _handles) = buf.split_mut();
789        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
790        debug_assert_eq!(tx_header.tx_id, 0);
791        match tx_header.ordinal {
792            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
793                Ok(SnoopEvent::_UnknownEvent { ordinal: tx_header.ordinal })
794            }
795            _ => Err(fidl::Error::UnknownOrdinal {
796                ordinal: tx_header.ordinal,
797                protocol_name: <SnoopMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
798            }),
799        }
800    }
801}
802
803/// A Stream of incoming requests for fuchsia.bluetooth.snoop/Snoop.
804pub struct SnoopRequestStream {
805    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
806    is_terminated: bool,
807}
808
809impl std::marker::Unpin for SnoopRequestStream {}
810
811impl futures::stream::FusedStream for SnoopRequestStream {
812    fn is_terminated(&self) -> bool {
813        self.is_terminated
814    }
815}
816
817impl fidl::endpoints::RequestStream for SnoopRequestStream {
818    type Protocol = SnoopMarker;
819    type ControlHandle = SnoopControlHandle;
820
821    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
822        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
823    }
824
825    fn control_handle(&self) -> Self::ControlHandle {
826        SnoopControlHandle { inner: self.inner.clone() }
827    }
828
829    fn into_inner(
830        self,
831    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
832    {
833        (self.inner, self.is_terminated)
834    }
835
836    fn from_inner(
837        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
838        is_terminated: bool,
839    ) -> Self {
840        Self { inner, is_terminated }
841    }
842}
843
844impl futures::Stream for SnoopRequestStream {
845    type Item = Result<SnoopRequest, fidl::Error>;
846
847    fn poll_next(
848        mut self: std::pin::Pin<&mut Self>,
849        cx: &mut std::task::Context<'_>,
850    ) -> std::task::Poll<Option<Self::Item>> {
851        let this = &mut *self;
852        if this.inner.check_shutdown(cx) {
853            this.is_terminated = true;
854            return std::task::Poll::Ready(None);
855        }
856        if this.is_terminated {
857            panic!("polled SnoopRequestStream after completion");
858        }
859        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
860            |bytes, handles| {
861                match this.inner.channel().read_etc(cx, bytes, handles) {
862                    std::task::Poll::Ready(Ok(())) => {}
863                    std::task::Poll::Pending => return std::task::Poll::Pending,
864                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
865                        this.is_terminated = true;
866                        return std::task::Poll::Ready(None);
867                    }
868                    std::task::Poll::Ready(Err(e)) => {
869                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
870                            e.into(),
871                        ))));
872                    }
873                }
874
875                // A message has been received from the channel
876                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
877
878                std::task::Poll::Ready(Some(match header.ordinal {
879                    0xa520491a4a82f24 => {
880                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
881                        let mut req = fidl::new_empty!(
882                            SnoopStartRequest,
883                            fidl::encoding::DefaultFuchsiaResourceDialect
884                        );
885                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SnoopStartRequest>(&header, _body_bytes, handles, &mut req)?;
886                        let control_handle = SnoopControlHandle { inner: this.inner.clone() };
887                        Ok(SnoopRequest::Start { payload: req, control_handle })
888                    }
889                    _ if header.tx_id == 0
890                        && header
891                            .dynamic_flags()
892                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
893                    {
894                        Ok(SnoopRequest::_UnknownMethod {
895                            ordinal: header.ordinal,
896                            control_handle: SnoopControlHandle { inner: this.inner.clone() },
897                            method_type: fidl::MethodType::OneWay,
898                        })
899                    }
900                    _ if header
901                        .dynamic_flags()
902                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
903                    {
904                        this.inner.send_framework_err(
905                            fidl::encoding::FrameworkErr::UnknownMethod,
906                            header.tx_id,
907                            header.ordinal,
908                            header.dynamic_flags(),
909                            (bytes, handles),
910                        )?;
911                        Ok(SnoopRequest::_UnknownMethod {
912                            ordinal: header.ordinal,
913                            control_handle: SnoopControlHandle { inner: this.inner.clone() },
914                            method_type: fidl::MethodType::TwoWay,
915                        })
916                    }
917                    _ => Err(fidl::Error::UnknownOrdinal {
918                        ordinal: header.ordinal,
919                        protocol_name: <SnoopMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
920                    }),
921                }))
922            },
923        )
924    }
925}
926
927/// Interface to receive packets recorded as received or transmitted for a Bluetooth host.
928#[derive(Debug)]
929pub enum SnoopRequest {
930    /// Subscribe to receive packets from the server. Packets that have been recorded are sent
931    /// first.
932    ///
933    /// If `follow` is true, the protocol stays open and packets are returned to the client as
934    /// the snoop server receives them. If `follow` is missing or false, the client is closed
935    /// when all currently recorded packets have been sent.
936    ///
937    /// A `host_device` name may be provided; if so, only events from that host are sent.
938    /// If `host_device` is absent, packets from all host devices are sent.
939    ///
940    /// Errors are reported through the client.
941    Start { payload: SnoopStartRequest, control_handle: SnoopControlHandle },
942    /// An interaction was received which does not match any known method.
943    #[non_exhaustive]
944    _UnknownMethod {
945        /// Ordinal of the method that was called.
946        ordinal: u64,
947        control_handle: SnoopControlHandle,
948        method_type: fidl::MethodType,
949    },
950}
951
952impl SnoopRequest {
953    #[allow(irrefutable_let_patterns)]
954    pub fn into_start(self) -> Option<(SnoopStartRequest, SnoopControlHandle)> {
955        if let SnoopRequest::Start { payload, control_handle } = self {
956            Some((payload, control_handle))
957        } else {
958            None
959        }
960    }
961
962    /// Name of the method defined in FIDL
963    pub fn method_name(&self) -> &'static str {
964        match *self {
965            SnoopRequest::Start { .. } => "start",
966            SnoopRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
967                "unknown one-way method"
968            }
969            SnoopRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
970                "unknown two-way method"
971            }
972        }
973    }
974}
975
976#[derive(Debug, Clone)]
977pub struct SnoopControlHandle {
978    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
979}
980
981impl fidl::endpoints::ControlHandle for SnoopControlHandle {
982    fn shutdown(&self) {
983        self.inner.shutdown()
984    }
985
986    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
987        self.inner.shutdown_with_epitaph(status)
988    }
989
990    fn is_closed(&self) -> bool {
991        self.inner.channel().is_closed()
992    }
993    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
994        self.inner.channel().on_closed()
995    }
996
997    #[cfg(target_os = "fuchsia")]
998    fn signal_peer(
999        &self,
1000        clear_mask: zx::Signals,
1001        set_mask: zx::Signals,
1002    ) -> Result<(), zx_status::Status> {
1003        use fidl::Peered;
1004        self.inner.channel().signal_peer(clear_mask, set_mask)
1005    }
1006}
1007
1008impl SnoopControlHandle {}
1009
1010mod internal {
1011    use super::*;
1012
1013    impl SnoopStartRequest {
1014        #[inline(always)]
1015        fn max_ordinal_present(&self) -> u64 {
1016            if let Some(_) = self.client {
1017                return 3;
1018            }
1019            if let Some(_) = self.host_device {
1020                return 2;
1021            }
1022            if let Some(_) = self.follow {
1023                return 1;
1024            }
1025            0
1026        }
1027    }
1028
1029    impl fidl::encoding::ResourceTypeMarker for SnoopStartRequest {
1030        type Borrowed<'a> = &'a mut Self;
1031        fn take_or_borrow<'a>(
1032            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1033        ) -> Self::Borrowed<'a> {
1034            value
1035        }
1036    }
1037
1038    unsafe impl fidl::encoding::TypeMarker for SnoopStartRequest {
1039        type Owned = Self;
1040
1041        #[inline(always)]
1042        fn inline_align(_context: fidl::encoding::Context) -> usize {
1043            8
1044        }
1045
1046        #[inline(always)]
1047        fn inline_size(_context: fidl::encoding::Context) -> usize {
1048            16
1049        }
1050    }
1051
1052    unsafe impl
1053        fidl::encoding::Encode<SnoopStartRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
1054        for &mut SnoopStartRequest
1055    {
1056        unsafe fn encode(
1057            self,
1058            encoder: &mut fidl::encoding::Encoder<
1059                '_,
1060                fidl::encoding::DefaultFuchsiaResourceDialect,
1061            >,
1062            offset: usize,
1063            mut depth: fidl::encoding::Depth,
1064        ) -> fidl::Result<()> {
1065            encoder.debug_check_bounds::<SnoopStartRequest>(offset);
1066            // Vector header
1067            let max_ordinal: u64 = self.max_ordinal_present();
1068            encoder.write_num(max_ordinal, offset);
1069            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1070            // Calling encoder.out_of_line_offset(0) is not allowed.
1071            if max_ordinal == 0 {
1072                return Ok(());
1073            }
1074            depth.increment()?;
1075            let envelope_size = 8;
1076            let bytes_len = max_ordinal as usize * envelope_size;
1077            #[allow(unused_variables)]
1078            let offset = encoder.out_of_line_offset(bytes_len);
1079            let mut _prev_end_offset: usize = 0;
1080            if 1 > max_ordinal {
1081                return Ok(());
1082            }
1083
1084            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1085            // are envelope_size bytes.
1086            let cur_offset: usize = (1 - 1) * envelope_size;
1087
1088            // Zero reserved fields.
1089            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1090
1091            // Safety:
1092            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1093            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1094            //   envelope_size bytes, there is always sufficient room.
1095            fidl::encoding::encode_in_envelope_optional::<
1096                bool,
1097                fidl::encoding::DefaultFuchsiaResourceDialect,
1098            >(
1099                self.follow.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1100                encoder,
1101                offset + cur_offset,
1102                depth,
1103            )?;
1104
1105            _prev_end_offset = cur_offset + envelope_size;
1106            if 2 > max_ordinal {
1107                return Ok(());
1108            }
1109
1110            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1111            // are envelope_size bytes.
1112            let cur_offset: usize = (2 - 1) * envelope_size;
1113
1114            // Zero reserved fields.
1115            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1116
1117            // Safety:
1118            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1119            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1120            //   envelope_size bytes, there is always sufficient room.
1121            fidl::encoding::encode_in_envelope_optional::<
1122                fidl::encoding::BoundedString<255>,
1123                fidl::encoding::DefaultFuchsiaResourceDialect,
1124            >(
1125                self.host_device.as_ref().map(
1126                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1127                ),
1128                encoder,
1129                offset + cur_offset,
1130                depth,
1131            )?;
1132
1133            _prev_end_offset = cur_offset + envelope_size;
1134            if 3 > max_ordinal {
1135                return Ok(());
1136            }
1137
1138            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1139            // are envelope_size bytes.
1140            let cur_offset: usize = (3 - 1) * envelope_size;
1141
1142            // Zero reserved fields.
1143            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1144
1145            // Safety:
1146            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1147            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1148            //   envelope_size bytes, there is always sufficient room.
1149            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PacketObserverMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
1150            self.client.as_mut().map(<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PacketObserverMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
1151            encoder, offset + cur_offset, depth
1152        )?;
1153
1154            _prev_end_offset = cur_offset + envelope_size;
1155
1156            Ok(())
1157        }
1158    }
1159
1160    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1161        for SnoopStartRequest
1162    {
1163        #[inline(always)]
1164        fn new_empty() -> Self {
1165            Self::default()
1166        }
1167
1168        unsafe fn decode(
1169            &mut self,
1170            decoder: &mut fidl::encoding::Decoder<
1171                '_,
1172                fidl::encoding::DefaultFuchsiaResourceDialect,
1173            >,
1174            offset: usize,
1175            mut depth: fidl::encoding::Depth,
1176        ) -> fidl::Result<()> {
1177            decoder.debug_check_bounds::<Self>(offset);
1178            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1179                None => return Err(fidl::Error::NotNullable),
1180                Some(len) => len,
1181            };
1182            // Calling decoder.out_of_line_offset(0) is not allowed.
1183            if len == 0 {
1184                return Ok(());
1185            };
1186            depth.increment()?;
1187            let envelope_size = 8;
1188            let bytes_len = len * envelope_size;
1189            let offset = decoder.out_of_line_offset(bytes_len)?;
1190            // Decode the envelope for each type.
1191            let mut _next_ordinal_to_read = 0;
1192            let mut next_offset = offset;
1193            let end_offset = offset + bytes_len;
1194            _next_ordinal_to_read += 1;
1195            if next_offset >= end_offset {
1196                return Ok(());
1197            }
1198
1199            // Decode unknown envelopes for gaps in ordinals.
1200            while _next_ordinal_to_read < 1 {
1201                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1202                _next_ordinal_to_read += 1;
1203                next_offset += envelope_size;
1204            }
1205
1206            let next_out_of_line = decoder.next_out_of_line();
1207            let handles_before = decoder.remaining_handles();
1208            if let Some((inlined, num_bytes, num_handles)) =
1209                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1210            {
1211                let member_inline_size =
1212                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1213                if inlined != (member_inline_size <= 4) {
1214                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1215                }
1216                let inner_offset;
1217                let mut inner_depth = depth.clone();
1218                if inlined {
1219                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1220                    inner_offset = next_offset;
1221                } else {
1222                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1223                    inner_depth.increment()?;
1224                }
1225                let val_ref = self.follow.get_or_insert_with(|| {
1226                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
1227                });
1228                fidl::decode!(
1229                    bool,
1230                    fidl::encoding::DefaultFuchsiaResourceDialect,
1231                    val_ref,
1232                    decoder,
1233                    inner_offset,
1234                    inner_depth
1235                )?;
1236                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1237                {
1238                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1239                }
1240                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1241                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1242                }
1243            }
1244
1245            next_offset += envelope_size;
1246            _next_ordinal_to_read += 1;
1247            if next_offset >= end_offset {
1248                return Ok(());
1249            }
1250
1251            // Decode unknown envelopes for gaps in ordinals.
1252            while _next_ordinal_to_read < 2 {
1253                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1254                _next_ordinal_to_read += 1;
1255                next_offset += envelope_size;
1256            }
1257
1258            let next_out_of_line = decoder.next_out_of_line();
1259            let handles_before = decoder.remaining_handles();
1260            if let Some((inlined, num_bytes, num_handles)) =
1261                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1262            {
1263                let member_inline_size =
1264                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
1265                        decoder.context,
1266                    );
1267                if inlined != (member_inline_size <= 4) {
1268                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1269                }
1270                let inner_offset;
1271                let mut inner_depth = depth.clone();
1272                if inlined {
1273                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1274                    inner_offset = next_offset;
1275                } else {
1276                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1277                    inner_depth.increment()?;
1278                }
1279                let val_ref = self.host_device.get_or_insert_with(|| {
1280                    fidl::new_empty!(
1281                        fidl::encoding::BoundedString<255>,
1282                        fidl::encoding::DefaultFuchsiaResourceDialect
1283                    )
1284                });
1285                fidl::decode!(
1286                    fidl::encoding::BoundedString<255>,
1287                    fidl::encoding::DefaultFuchsiaResourceDialect,
1288                    val_ref,
1289                    decoder,
1290                    inner_offset,
1291                    inner_depth
1292                )?;
1293                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1294                {
1295                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1296                }
1297                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1298                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1299                }
1300            }
1301
1302            next_offset += envelope_size;
1303            _next_ordinal_to_read += 1;
1304            if next_offset >= end_offset {
1305                return Ok(());
1306            }
1307
1308            // Decode unknown envelopes for gaps in ordinals.
1309            while _next_ordinal_to_read < 3 {
1310                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1311                _next_ordinal_to_read += 1;
1312                next_offset += envelope_size;
1313            }
1314
1315            let next_out_of_line = decoder.next_out_of_line();
1316            let handles_before = decoder.remaining_handles();
1317            if let Some((inlined, num_bytes, num_handles)) =
1318                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1319            {
1320                let member_inline_size = <fidl::encoding::Endpoint<
1321                    fidl::endpoints::ClientEnd<PacketObserverMarker>,
1322                > as fidl::encoding::TypeMarker>::inline_size(
1323                    decoder.context
1324                );
1325                if inlined != (member_inline_size <= 4) {
1326                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1327                }
1328                let inner_offset;
1329                let mut inner_depth = depth.clone();
1330                if inlined {
1331                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1332                    inner_offset = next_offset;
1333                } else {
1334                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1335                    inner_depth.increment()?;
1336                }
1337                let val_ref = self.client.get_or_insert_with(|| {
1338                    fidl::new_empty!(
1339                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PacketObserverMarker>>,
1340                        fidl::encoding::DefaultFuchsiaResourceDialect
1341                    )
1342                });
1343                fidl::decode!(
1344                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PacketObserverMarker>>,
1345                    fidl::encoding::DefaultFuchsiaResourceDialect,
1346                    val_ref,
1347                    decoder,
1348                    inner_offset,
1349                    inner_depth
1350                )?;
1351                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1352                {
1353                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1354                }
1355                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1356                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1357                }
1358            }
1359
1360            next_offset += envelope_size;
1361
1362            // Decode the remaining unknown envelopes.
1363            while next_offset < end_offset {
1364                _next_ordinal_to_read += 1;
1365                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1366                next_offset += envelope_size;
1367            }
1368
1369            Ok(())
1370        }
1371    }
1372}
fidl_fuchsia_bluetooth_snoop/fidl_fuchsia_bluetooth_snoop.rs

fidl_fuchsia_bluetooth_snoop/
fidl_fuchsia_bluetooth_snoop.rs
