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        Self { client: fidl::client::sync::Client::new(channel) }
70    }
71
72    pub fn into_channel(self) -> fidl::Channel {
73        self.client.into_channel()
74    }
75
76    /// Waits until an event arrives and returns it. It is safe for other
77    /// threads to make concurrent requests while waiting for an event.
78    pub fn wait_for_event(
79        &self,
80        deadline: zx::MonotonicInstant,
81    ) -> Result<PacketObserverEvent, fidl::Error> {
82        PacketObserverEvent::decode(self.client.wait_for_event::<PacketObserverMarker>(deadline)?)
83    }
84
85    /// Observe some packets which have been transmitted over HCI.
86    /// Return ack is used for flow control.
87    pub fn r#observe(
88        &self,
89        mut payload: &DevicePackets,
90        ___deadline: zx::MonotonicInstant,
91    ) -> Result<(), fidl::Error> {
92        let _response = self.client.send_query::<
93            DevicePackets,
94            fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
95            PacketObserverMarker,
96        >(
97            payload,
98            0x2a82a5a9a18b79c9,
99            fidl::encoding::DynamicFlags::FLEXIBLE,
100            ___deadline,
101        )?
102        .into_result::<PacketObserverMarker>("observe")?;
103        Ok(_response)
104    }
105
106    /// Called when an error occurs either during capture or while starting
107    /// capture.  The protocol will be closed after this is sent.
108    pub fn r#error(&self, mut payload: &CaptureError) -> Result<(), fidl::Error> {
109        self.client.send::<CaptureError>(
110            payload,
111            0x6596e43f4f0761e4,
112            fidl::encoding::DynamicFlags::FLEXIBLE,
113        )
114    }
115}
116
117#[cfg(target_os = "fuchsia")]
118impl From<PacketObserverSynchronousProxy> for zx::NullableHandle {
119    fn from(value: PacketObserverSynchronousProxy) -> Self {
120        value.into_channel().into()
121    }
122}
123
124#[cfg(target_os = "fuchsia")]
125impl From<fidl::Channel> for PacketObserverSynchronousProxy {
126    fn from(value: fidl::Channel) -> Self {
127        Self::new(value)
128    }
129}
130
131#[cfg(target_os = "fuchsia")]
132impl fidl::endpoints::FromClient for PacketObserverSynchronousProxy {
133    type Protocol = PacketObserverMarker;
134
135    fn from_client(value: fidl::endpoints::ClientEnd<PacketObserverMarker>) -> Self {
136        Self::new(value.into_channel())
137    }
138}
139
140#[derive(Debug, Clone)]
141pub struct PacketObserverProxy {
142    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
143}
144
145impl fidl::endpoints::Proxy for PacketObserverProxy {
146    type Protocol = PacketObserverMarker;
147
148    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
149        Self::new(inner)
150    }
151
152    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
153        self.client.into_channel().map_err(|client| Self { client })
154    }
155
156    fn as_channel(&self) -> &::fidl::AsyncChannel {
157        self.client.as_channel()
158    }
159}
160
161impl PacketObserverProxy {
162    /// Create a new Proxy for fuchsia.bluetooth.snoop/PacketObserver.
163    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
164        let protocol_name = <PacketObserverMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
165        Self { client: fidl::client::Client::new(channel, protocol_name) }
166    }
167
168    /// Get a Stream of events from the remote end of the protocol.
169    ///
170    /// # Panics
171    ///
172    /// Panics if the event stream was already taken.
173    pub fn take_event_stream(&self) -> PacketObserverEventStream {
174        PacketObserverEventStream { event_receiver: self.client.take_event_receiver() }
175    }
176
177    /// Observe some packets which have been transmitted over HCI.
178    /// Return ack is used for flow control.
179    pub fn r#observe(
180        &self,
181        mut payload: &DevicePackets,
182    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
183        PacketObserverProxyInterface::r#observe(self, payload)
184    }
185
186    /// Called when an error occurs either during capture or while starting
187    /// capture.  The protocol will be closed after this is sent.
188    pub fn r#error(&self, mut payload: &CaptureError) -> Result<(), fidl::Error> {
189        PacketObserverProxyInterface::r#error(self, payload)
190    }
191}
192
193impl PacketObserverProxyInterface for PacketObserverProxy {
194    type ObserveResponseFut =
195        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
196    fn r#observe(&self, mut payload: &DevicePackets) -> Self::ObserveResponseFut {
197        fn _decode(
198            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
199        ) -> Result<(), fidl::Error> {
200            let _response = fidl::client::decode_transaction_body::<
201                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
202                fidl::encoding::DefaultFuchsiaResourceDialect,
203                0x2a82a5a9a18b79c9,
204            >(_buf?)?
205            .into_result::<PacketObserverMarker>("observe")?;
206            Ok(_response)
207        }
208        self.client.send_query_and_decode::<DevicePackets, ()>(
209            payload,
210            0x2a82a5a9a18b79c9,
211            fidl::encoding::DynamicFlags::FLEXIBLE,
212            _decode,
213        )
214    }
215
216    fn r#error(&self, mut payload: &CaptureError) -> Result<(), fidl::Error> {
217        self.client.send::<CaptureError>(
218            payload,
219            0x6596e43f4f0761e4,
220            fidl::encoding::DynamicFlags::FLEXIBLE,
221        )
222    }
223}
224
225pub struct PacketObserverEventStream {
226    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
227}
228
229impl std::marker::Unpin for PacketObserverEventStream {}
230
231impl futures::stream::FusedStream for PacketObserverEventStream {
232    fn is_terminated(&self) -> bool {
233        self.event_receiver.is_terminated()
234    }
235}
236
237impl futures::Stream for PacketObserverEventStream {
238    type Item = Result<PacketObserverEvent, fidl::Error>;
239
240    fn poll_next(
241        mut self: std::pin::Pin<&mut Self>,
242        cx: &mut std::task::Context<'_>,
243    ) -> std::task::Poll<Option<Self::Item>> {
244        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
245            &mut self.event_receiver,
246            cx
247        )?) {
248            Some(buf) => std::task::Poll::Ready(Some(PacketObserverEvent::decode(buf))),
249            None => std::task::Poll::Ready(None),
250        }
251    }
252}
253
254#[derive(Debug)]
255pub enum PacketObserverEvent {
256    #[non_exhaustive]
257    _UnknownEvent {
258        /// Ordinal of the event that was sent.
259        ordinal: u64,
260    },
261}
262
263impl PacketObserverEvent {
264    /// Decodes a message buffer as a [`PacketObserverEvent`].
265    fn decode(
266        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
267    ) -> Result<PacketObserverEvent, fidl::Error> {
268        let (bytes, _handles) = buf.split_mut();
269        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
270        debug_assert_eq!(tx_header.tx_id, 0);
271        match tx_header.ordinal {
272            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
273                Ok(PacketObserverEvent::_UnknownEvent { ordinal: tx_header.ordinal })
274            }
275            _ => Err(fidl::Error::UnknownOrdinal {
276                ordinal: tx_header.ordinal,
277                protocol_name:
278                    <PacketObserverMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
279            }),
280        }
281    }
282}
283
284/// A Stream of incoming requests for fuchsia.bluetooth.snoop/PacketObserver.
285pub struct PacketObserverRequestStream {
286    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
287    is_terminated: bool,
288}
289
290impl std::marker::Unpin for PacketObserverRequestStream {}
291
292impl futures::stream::FusedStream for PacketObserverRequestStream {
293    fn is_terminated(&self) -> bool {
294        self.is_terminated
295    }
296}
297
298impl fidl::endpoints::RequestStream for PacketObserverRequestStream {
299    type Protocol = PacketObserverMarker;
300    type ControlHandle = PacketObserverControlHandle;
301
302    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
303        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
304    }
305
306    fn control_handle(&self) -> Self::ControlHandle {
307        PacketObserverControlHandle { inner: self.inner.clone() }
308    }
309
310    fn into_inner(
311        self,
312    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
313    {
314        (self.inner, self.is_terminated)
315    }
316
317    fn from_inner(
318        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
319        is_terminated: bool,
320    ) -> Self {
321        Self { inner, is_terminated }
322    }
323}
324
325impl futures::Stream for PacketObserverRequestStream {
326    type Item = Result<PacketObserverRequest, fidl::Error>;
327
328    fn poll_next(
329        mut self: std::pin::Pin<&mut Self>,
330        cx: &mut std::task::Context<'_>,
331    ) -> std::task::Poll<Option<Self::Item>> {
332        let this = &mut *self;
333        if this.inner.check_shutdown(cx) {
334            this.is_terminated = true;
335            return std::task::Poll::Ready(None);
336        }
337        if this.is_terminated {
338            panic!("polled PacketObserverRequestStream after completion");
339        }
340        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
341            |bytes, handles| {
342                match this.inner.channel().read_etc(cx, bytes, handles) {
343                    std::task::Poll::Ready(Ok(())) => {}
344                    std::task::Poll::Pending => return std::task::Poll::Pending,
345                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
346                        this.is_terminated = true;
347                        return std::task::Poll::Ready(None);
348                    }
349                    std::task::Poll::Ready(Err(e)) => {
350                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
351                            e.into(),
352                        ))));
353                    }
354                }
355
356                // A message has been received from the channel
357                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
358
359                std::task::Poll::Ready(Some(match header.ordinal {
360                    0x2a82a5a9a18b79c9 => {
361                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
362                        let mut req = fidl::new_empty!(
363                            DevicePackets,
364                            fidl::encoding::DefaultFuchsiaResourceDialect
365                        );
366                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DevicePackets>(&header, _body_bytes, handles, &mut req)?;
367                        let control_handle =
368                            PacketObserverControlHandle { inner: this.inner.clone() };
369                        Ok(PacketObserverRequest::Observe {
370                            payload: req,
371                            responder: PacketObserverObserveResponder {
372                                control_handle: std::mem::ManuallyDrop::new(control_handle),
373                                tx_id: header.tx_id,
374                            },
375                        })
376                    }
377                    0x6596e43f4f0761e4 => {
378                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
379                        let mut req = fidl::new_empty!(
380                            CaptureError,
381                            fidl::encoding::DefaultFuchsiaResourceDialect
382                        );
383                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CaptureError>(&header, _body_bytes, handles, &mut req)?;
384                        let control_handle =
385                            PacketObserverControlHandle { inner: this.inner.clone() };
386                        Ok(PacketObserverRequest::Error { payload: req, control_handle })
387                    }
388                    _ if header.tx_id == 0
389                        && header
390                            .dynamic_flags()
391                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
392                    {
393                        Ok(PacketObserverRequest::_UnknownMethod {
394                            ordinal: header.ordinal,
395                            control_handle: PacketObserverControlHandle {
396                                inner: this.inner.clone(),
397                            },
398                            method_type: fidl::MethodType::OneWay,
399                        })
400                    }
401                    _ if header
402                        .dynamic_flags()
403                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
404                    {
405                        this.inner.send_framework_err(
406                            fidl::encoding::FrameworkErr::UnknownMethod,
407                            header.tx_id,
408                            header.ordinal,
409                            header.dynamic_flags(),
410                            (bytes, handles),
411                        )?;
412                        Ok(PacketObserverRequest::_UnknownMethod {
413                            ordinal: header.ordinal,
414                            control_handle: PacketObserverControlHandle {
415                                inner: this.inner.clone(),
416                            },
417                            method_type: fidl::MethodType::TwoWay,
418                        })
419                    }
420                    _ => Err(fidl::Error::UnknownOrdinal {
421                        ordinal: header.ordinal,
422                        protocol_name:
423                            <PacketObserverMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
424                    }),
425                }))
426            },
427        )
428    }
429}
430
431#[derive(Debug)]
432pub enum PacketObserverRequest {
433    /// Observe some packets which have been transmitted over HCI.
434    /// Return ack is used for flow control.
435    Observe { payload: DevicePackets, responder: PacketObserverObserveResponder },
436    /// Called when an error occurs either during capture or while starting
437    /// capture.  The protocol will be closed after this is sent.
438    Error { payload: CaptureError, control_handle: PacketObserverControlHandle },
439    /// An interaction was received which does not match any known method.
440    #[non_exhaustive]
441    _UnknownMethod {
442        /// Ordinal of the method that was called.
443        ordinal: u64,
444        control_handle: PacketObserverControlHandle,
445        method_type: fidl::MethodType,
446    },
447}
448
449impl PacketObserverRequest {
450    #[allow(irrefutable_let_patterns)]
451    pub fn into_observe(self) -> Option<(DevicePackets, PacketObserverObserveResponder)> {
452        if let PacketObserverRequest::Observe { payload, responder } = self {
453            Some((payload, responder))
454        } else {
455            None
456        }
457    }
458
459    #[allow(irrefutable_let_patterns)]
460    pub fn into_error(self) -> Option<(CaptureError, PacketObserverControlHandle)> {
461        if let PacketObserverRequest::Error { payload, control_handle } = self {
462            Some((payload, control_handle))
463        } else {
464            None
465        }
466    }
467
468    /// Name of the method defined in FIDL
469    pub fn method_name(&self) -> &'static str {
470        match *self {
471            PacketObserverRequest::Observe { .. } => "observe",
472            PacketObserverRequest::Error { .. } => "error",
473            PacketObserverRequest::_UnknownMethod {
474                method_type: fidl::MethodType::OneWay, ..
475            } => "unknown one-way method",
476            PacketObserverRequest::_UnknownMethod {
477                method_type: fidl::MethodType::TwoWay, ..
478            } => "unknown two-way method",
479        }
480    }
481}
482
483#[derive(Debug, Clone)]
484pub struct PacketObserverControlHandle {
485    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
486}
487
488impl fidl::endpoints::ControlHandle for PacketObserverControlHandle {
489    fn shutdown(&self) {
490        self.inner.shutdown()
491    }
492
493    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
494        self.inner.shutdown_with_epitaph(status)
495    }
496
497    fn is_closed(&self) -> bool {
498        self.inner.channel().is_closed()
499    }
500    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
501        self.inner.channel().on_closed()
502    }
503
504    #[cfg(target_os = "fuchsia")]
505    fn signal_peer(
506        &self,
507        clear_mask: zx::Signals,
508        set_mask: zx::Signals,
509    ) -> Result<(), zx_status::Status> {
510        use fidl::Peered;
511        self.inner.channel().signal_peer(clear_mask, set_mask)
512    }
513}
514
515impl PacketObserverControlHandle {}
516
517#[must_use = "FIDL methods require a response to be sent"]
518#[derive(Debug)]
519pub struct PacketObserverObserveResponder {
520    control_handle: std::mem::ManuallyDrop<PacketObserverControlHandle>,
521    tx_id: u32,
522}
523
524/// Set the the channel to be shutdown (see [`PacketObserverControlHandle::shutdown`])
525/// if the responder is dropped without sending a response, so that the client
526/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
527impl std::ops::Drop for PacketObserverObserveResponder {
528    fn drop(&mut self) {
529        self.control_handle.shutdown();
530        // Safety: drops once, never accessed again
531        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
532    }
533}
534
535impl fidl::endpoints::Responder for PacketObserverObserveResponder {
536    type ControlHandle = PacketObserverControlHandle;
537
538    fn control_handle(&self) -> &PacketObserverControlHandle {
539        &self.control_handle
540    }
541
542    fn drop_without_shutdown(mut self) {
543        // Safety: drops once, never accessed again due to mem::forget
544        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
545        // Prevent Drop from running (which would shut down the channel)
546        std::mem::forget(self);
547    }
548}
549
550impl PacketObserverObserveResponder {
551    /// Sends a response to the FIDL transaction.
552    ///
553    /// Sets the channel to shutdown if an error occurs.
554    pub fn send(self) -> Result<(), fidl::Error> {
555        let _result = self.send_raw();
556        if _result.is_err() {
557            self.control_handle.shutdown();
558        }
559        self.drop_without_shutdown();
560        _result
561    }
562
563    /// Similar to "send" but does not shutdown the channel if an error occurs.
564    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
565        let _result = self.send_raw();
566        self.drop_without_shutdown();
567        _result
568    }
569
570    fn send_raw(&self) -> Result<(), fidl::Error> {
571        self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
572            fidl::encoding::Flexible::new(()),
573            self.tx_id,
574            0x2a82a5a9a18b79c9,
575            fidl::encoding::DynamicFlags::FLEXIBLE,
576        )
577    }
578}
579
580#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
581pub struct SnoopMarker;
582
583impl fidl::endpoints::ProtocolMarker for SnoopMarker {
584    type Proxy = SnoopProxy;
585    type RequestStream = SnoopRequestStream;
586    #[cfg(target_os = "fuchsia")]
587    type SynchronousProxy = SnoopSynchronousProxy;
588
589    const DEBUG_NAME: &'static str = "fuchsia.bluetooth.snoop.Snoop";
590}
591impl fidl::endpoints::DiscoverableProtocolMarker for SnoopMarker {}
592
593pub trait SnoopProxyInterface: Send + Sync {
594    fn r#start(&self, payload: SnoopStartRequest) -> Result<(), fidl::Error>;
595}
596#[derive(Debug)]
597#[cfg(target_os = "fuchsia")]
598pub struct SnoopSynchronousProxy {
599    client: fidl::client::sync::Client,
600}
601
602#[cfg(target_os = "fuchsia")]
603impl fidl::endpoints::SynchronousProxy for SnoopSynchronousProxy {
604    type Proxy = SnoopProxy;
605    type Protocol = SnoopMarker;
606
607    fn from_channel(inner: fidl::Channel) -> Self {
608        Self::new(inner)
609    }
610
611    fn into_channel(self) -> fidl::Channel {
612        self.client.into_channel()
613    }
614
615    fn as_channel(&self) -> &fidl::Channel {
616        self.client.as_channel()
617    }
618}
619
620#[cfg(target_os = "fuchsia")]
621impl SnoopSynchronousProxy {
622    pub fn new(channel: fidl::Channel) -> Self {
623        Self { client: fidl::client::sync::Client::new(channel) }
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::<SnoopMarker>(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
