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

fidl_fuchsia_bluetooth_snoop/
fidl_fuchsia_bluetooth_snoop.rs
