fidl_fuchsia_developer_ffx_speedtest/
fidl_fuchsia_developer_ffx_speedtest.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_developer_ffx_speedtest__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, PartialEq)]
15pub struct SpeedtestSocketDownRequest {
16    pub socket: fidl::Socket,
17    pub params: TransferParams,
18}
19
20impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
21    for SpeedtestSocketDownRequest
22{
23}
24
25#[derive(Debug, PartialEq)]
26pub struct SpeedtestSocketUpRequest {
27    pub socket: fidl::Socket,
28    pub params: TransferParams,
29}
30
31impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for SpeedtestSocketUpRequest {}
32
33#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
34pub struct SpeedtestMarker;
35
36impl fidl::endpoints::ProtocolMarker for SpeedtestMarker {
37    type Proxy = SpeedtestProxy;
38    type RequestStream = SpeedtestRequestStream;
39    #[cfg(target_os = "fuchsia")]
40    type SynchronousProxy = SpeedtestSynchronousProxy;
41
42    const DEBUG_NAME: &'static str = "fuchsia.developer.ffx.speedtest.Speedtest";
43}
44impl fidl::endpoints::DiscoverableProtocolMarker for SpeedtestMarker {}
45
46pub trait SpeedtestProxyInterface: Send + Sync {
47    type PingResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
48    fn r#ping(&self) -> Self::PingResponseFut;
49    type SocketUpResponseFut: std::future::Future<Output = Result<TransferReport, fidl::Error>>
50        + Send;
51    fn r#socket_up(
52        &self,
53        socket: fidl::Socket,
54        params: &TransferParams,
55    ) -> Self::SocketUpResponseFut;
56    type SocketDownResponseFut: std::future::Future<Output = Result<TransferReport, fidl::Error>>
57        + Send;
58    fn r#socket_down(
59        &self,
60        socket: fidl::Socket,
61        params: &TransferParams,
62    ) -> Self::SocketDownResponseFut;
63}
64#[derive(Debug)]
65#[cfg(target_os = "fuchsia")]
66pub struct SpeedtestSynchronousProxy {
67    client: fidl::client::sync::Client,
68}
69
70#[cfg(target_os = "fuchsia")]
71impl fidl::endpoints::SynchronousProxy for SpeedtestSynchronousProxy {
72    type Proxy = SpeedtestProxy;
73    type Protocol = SpeedtestMarker;
74
75    fn from_channel(inner: fidl::Channel) -> Self {
76        Self::new(inner)
77    }
78
79    fn into_channel(self) -> fidl::Channel {
80        self.client.into_channel()
81    }
82
83    fn as_channel(&self) -> &fidl::Channel {
84        self.client.as_channel()
85    }
86}
87
88#[cfg(target_os = "fuchsia")]
89impl SpeedtestSynchronousProxy {
90    pub fn new(channel: fidl::Channel) -> Self {
91        let protocol_name = <SpeedtestMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
92        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
93    }
94
95    pub fn into_channel(self) -> fidl::Channel {
96        self.client.into_channel()
97    }
98
99    /// Waits until an event arrives and returns it. It is safe for other
100    /// threads to make concurrent requests while waiting for an event.
101    pub fn wait_for_event(
102        &self,
103        deadline: zx::MonotonicInstant,
104    ) -> Result<SpeedtestEvent, fidl::Error> {
105        SpeedtestEvent::decode(self.client.wait_for_event(deadline)?)
106    }
107
108    /// No-op, server responds immediately.
109    pub fn r#ping(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
110        let _response = self.client.send_query::<
111            fidl::encoding::EmptyPayload,
112            fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
113        >(
114            (),
115            0x1511ccb237874689,
116            fidl::encoding::DynamicFlags::FLEXIBLE,
117            ___deadline,
118        )?
119        .into_result::<SpeedtestMarker>("ping")?;
120        Ok(_response)
121    }
122
123    /// Server writes data into the provided zircon socket and reports stats.
124    pub fn r#socket_up(
125        &self,
126        mut socket: fidl::Socket,
127        mut params: &TransferParams,
128        ___deadline: zx::MonotonicInstant,
129    ) -> Result<TransferReport, fidl::Error> {
130        let _response = self
131            .client
132            .send_query::<SpeedtestSocketUpRequest, fidl::encoding::FlexibleType<TransferReport>>(
133                (socket, params),
134                0x7c530a369209ae87,
135                fidl::encoding::DynamicFlags::FLEXIBLE,
136                ___deadline,
137            )?
138            .into_result::<SpeedtestMarker>("socket_up")?;
139        Ok(_response)
140    }
141
142    /// Server reads data from the provided zircon socket and reports stats.
143    pub fn r#socket_down(
144        &self,
145        mut socket: fidl::Socket,
146        mut params: &TransferParams,
147        ___deadline: zx::MonotonicInstant,
148    ) -> Result<TransferReport, fidl::Error> {
149        let _response = self
150            .client
151            .send_query::<SpeedtestSocketDownRequest, fidl::encoding::FlexibleType<TransferReport>>(
152                (socket, params),
153                0x426e13de44070751,
154                fidl::encoding::DynamicFlags::FLEXIBLE,
155                ___deadline,
156            )?
157            .into_result::<SpeedtestMarker>("socket_down")?;
158        Ok(_response)
159    }
160}
161
162#[cfg(target_os = "fuchsia")]
163impl From<SpeedtestSynchronousProxy> for zx::Handle {
164    fn from(value: SpeedtestSynchronousProxy) -> Self {
165        value.into_channel().into()
166    }
167}
168
169#[cfg(target_os = "fuchsia")]
170impl From<fidl::Channel> for SpeedtestSynchronousProxy {
171    fn from(value: fidl::Channel) -> Self {
172        Self::new(value)
173    }
174}
175
176#[cfg(target_os = "fuchsia")]
177impl fidl::endpoints::FromClient for SpeedtestSynchronousProxy {
178    type Protocol = SpeedtestMarker;
179
180    fn from_client(value: fidl::endpoints::ClientEnd<SpeedtestMarker>) -> Self {
181        Self::new(value.into_channel())
182    }
183}
184
185#[derive(Debug, Clone)]
186pub struct SpeedtestProxy {
187    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
188}
189
190impl fidl::endpoints::Proxy for SpeedtestProxy {
191    type Protocol = SpeedtestMarker;
192
193    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
194        Self::new(inner)
195    }
196
197    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
198        self.client.into_channel().map_err(|client| Self { client })
199    }
200
201    fn as_channel(&self) -> &::fidl::AsyncChannel {
202        self.client.as_channel()
203    }
204}
205
206impl SpeedtestProxy {
207    /// Create a new Proxy for fuchsia.developer.ffx.speedtest/Speedtest.
208    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
209        let protocol_name = <SpeedtestMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
210        Self { client: fidl::client::Client::new(channel, protocol_name) }
211    }
212
213    /// Get a Stream of events from the remote end of the protocol.
214    ///
215    /// # Panics
216    ///
217    /// Panics if the event stream was already taken.
218    pub fn take_event_stream(&self) -> SpeedtestEventStream {
219        SpeedtestEventStream { event_receiver: self.client.take_event_receiver() }
220    }
221
222    /// No-op, server responds immediately.
223    pub fn r#ping(
224        &self,
225    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
226        SpeedtestProxyInterface::r#ping(self)
227    }
228
229    /// Server writes data into the provided zircon socket and reports stats.
230    pub fn r#socket_up(
231        &self,
232        mut socket: fidl::Socket,
233        mut params: &TransferParams,
234    ) -> fidl::client::QueryResponseFut<TransferReport, fidl::encoding::DefaultFuchsiaResourceDialect>
235    {
236        SpeedtestProxyInterface::r#socket_up(self, socket, params)
237    }
238
239    /// Server reads data from the provided zircon socket and reports stats.
240    pub fn r#socket_down(
241        &self,
242        mut socket: fidl::Socket,
243        mut params: &TransferParams,
244    ) -> fidl::client::QueryResponseFut<TransferReport, fidl::encoding::DefaultFuchsiaResourceDialect>
245    {
246        SpeedtestProxyInterface::r#socket_down(self, socket, params)
247    }
248}
249
250impl SpeedtestProxyInterface for SpeedtestProxy {
251    type PingResponseFut =
252        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
253    fn r#ping(&self) -> Self::PingResponseFut {
254        fn _decode(
255            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
256        ) -> Result<(), fidl::Error> {
257            let _response = fidl::client::decode_transaction_body::<
258                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
259                fidl::encoding::DefaultFuchsiaResourceDialect,
260                0x1511ccb237874689,
261            >(_buf?)?
262            .into_result::<SpeedtestMarker>("ping")?;
263            Ok(_response)
264        }
265        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
266            (),
267            0x1511ccb237874689,
268            fidl::encoding::DynamicFlags::FLEXIBLE,
269            _decode,
270        )
271    }
272
273    type SocketUpResponseFut = fidl::client::QueryResponseFut<
274        TransferReport,
275        fidl::encoding::DefaultFuchsiaResourceDialect,
276    >;
277    fn r#socket_up(
278        &self,
279        mut socket: fidl::Socket,
280        mut params: &TransferParams,
281    ) -> Self::SocketUpResponseFut {
282        fn _decode(
283            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
284        ) -> Result<TransferReport, fidl::Error> {
285            let _response = fidl::client::decode_transaction_body::<
286                fidl::encoding::FlexibleType<TransferReport>,
287                fidl::encoding::DefaultFuchsiaResourceDialect,
288                0x7c530a369209ae87,
289            >(_buf?)?
290            .into_result::<SpeedtestMarker>("socket_up")?;
291            Ok(_response)
292        }
293        self.client.send_query_and_decode::<SpeedtestSocketUpRequest, TransferReport>(
294            (socket, params),
295            0x7c530a369209ae87,
296            fidl::encoding::DynamicFlags::FLEXIBLE,
297            _decode,
298        )
299    }
300
301    type SocketDownResponseFut = fidl::client::QueryResponseFut<
302        TransferReport,
303        fidl::encoding::DefaultFuchsiaResourceDialect,
304    >;
305    fn r#socket_down(
306        &self,
307        mut socket: fidl::Socket,
308        mut params: &TransferParams,
309    ) -> Self::SocketDownResponseFut {
310        fn _decode(
311            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
312        ) -> Result<TransferReport, fidl::Error> {
313            let _response = fidl::client::decode_transaction_body::<
314                fidl::encoding::FlexibleType<TransferReport>,
315                fidl::encoding::DefaultFuchsiaResourceDialect,
316                0x426e13de44070751,
317            >(_buf?)?
318            .into_result::<SpeedtestMarker>("socket_down")?;
319            Ok(_response)
320        }
321        self.client.send_query_and_decode::<SpeedtestSocketDownRequest, TransferReport>(
322            (socket, params),
323            0x426e13de44070751,
324            fidl::encoding::DynamicFlags::FLEXIBLE,
325            _decode,
326        )
327    }
328}
329
330pub struct SpeedtestEventStream {
331    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
332}
333
334impl std::marker::Unpin for SpeedtestEventStream {}
335
336impl futures::stream::FusedStream for SpeedtestEventStream {
337    fn is_terminated(&self) -> bool {
338        self.event_receiver.is_terminated()
339    }
340}
341
342impl futures::Stream for SpeedtestEventStream {
343    type Item = Result<SpeedtestEvent, fidl::Error>;
344
345    fn poll_next(
346        mut self: std::pin::Pin<&mut Self>,
347        cx: &mut std::task::Context<'_>,
348    ) -> std::task::Poll<Option<Self::Item>> {
349        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
350            &mut self.event_receiver,
351            cx
352        )?) {
353            Some(buf) => std::task::Poll::Ready(Some(SpeedtestEvent::decode(buf))),
354            None => std::task::Poll::Ready(None),
355        }
356    }
357}
358
359#[derive(Debug)]
360pub enum SpeedtestEvent {
361    #[non_exhaustive]
362    _UnknownEvent {
363        /// Ordinal of the event that was sent.
364        ordinal: u64,
365    },
366}
367
368impl SpeedtestEvent {
369    /// Decodes a message buffer as a [`SpeedtestEvent`].
370    fn decode(
371        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
372    ) -> Result<SpeedtestEvent, fidl::Error> {
373        let (bytes, _handles) = buf.split_mut();
374        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
375        debug_assert_eq!(tx_header.tx_id, 0);
376        match tx_header.ordinal {
377            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
378                Ok(SpeedtestEvent::_UnknownEvent { ordinal: tx_header.ordinal })
379            }
380            _ => Err(fidl::Error::UnknownOrdinal {
381                ordinal: tx_header.ordinal,
382                protocol_name: <SpeedtestMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
383            }),
384        }
385    }
386}
387
388/// A Stream of incoming requests for fuchsia.developer.ffx.speedtest/Speedtest.
389pub struct SpeedtestRequestStream {
390    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
391    is_terminated: bool,
392}
393
394impl std::marker::Unpin for SpeedtestRequestStream {}
395
396impl futures::stream::FusedStream for SpeedtestRequestStream {
397    fn is_terminated(&self) -> bool {
398        self.is_terminated
399    }
400}
401
402impl fidl::endpoints::RequestStream for SpeedtestRequestStream {
403    type Protocol = SpeedtestMarker;
404    type ControlHandle = SpeedtestControlHandle;
405
406    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
407        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
408    }
409
410    fn control_handle(&self) -> Self::ControlHandle {
411        SpeedtestControlHandle { inner: self.inner.clone() }
412    }
413
414    fn into_inner(
415        self,
416    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
417    {
418        (self.inner, self.is_terminated)
419    }
420
421    fn from_inner(
422        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
423        is_terminated: bool,
424    ) -> Self {
425        Self { inner, is_terminated }
426    }
427}
428
429impl futures::Stream for SpeedtestRequestStream {
430    type Item = Result<SpeedtestRequest, fidl::Error>;
431
432    fn poll_next(
433        mut self: std::pin::Pin<&mut Self>,
434        cx: &mut std::task::Context<'_>,
435    ) -> std::task::Poll<Option<Self::Item>> {
436        let this = &mut *self;
437        if this.inner.check_shutdown(cx) {
438            this.is_terminated = true;
439            return std::task::Poll::Ready(None);
440        }
441        if this.is_terminated {
442            panic!("polled SpeedtestRequestStream after completion");
443        }
444        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
445            |bytes, handles| {
446                match this.inner.channel().read_etc(cx, bytes, handles) {
447                    std::task::Poll::Ready(Ok(())) => {}
448                    std::task::Poll::Pending => return std::task::Poll::Pending,
449                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
450                        this.is_terminated = true;
451                        return std::task::Poll::Ready(None);
452                    }
453                    std::task::Poll::Ready(Err(e)) => {
454                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
455                            e.into(),
456                        ))))
457                    }
458                }
459
460                // A message has been received from the channel
461                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
462
463                std::task::Poll::Ready(Some(match header.ordinal {
464                    0x1511ccb237874689 => {
465                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
466                        let mut req = fidl::new_empty!(
467                            fidl::encoding::EmptyPayload,
468                            fidl::encoding::DefaultFuchsiaResourceDialect
469                        );
470                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
471                        let control_handle = SpeedtestControlHandle { inner: this.inner.clone() };
472                        Ok(SpeedtestRequest::Ping {
473                            responder: SpeedtestPingResponder {
474                                control_handle: std::mem::ManuallyDrop::new(control_handle),
475                                tx_id: header.tx_id,
476                            },
477                        })
478                    }
479                    0x7c530a369209ae87 => {
480                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
481                        let mut req = fidl::new_empty!(
482                            SpeedtestSocketUpRequest,
483                            fidl::encoding::DefaultFuchsiaResourceDialect
484                        );
485                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SpeedtestSocketUpRequest>(&header, _body_bytes, handles, &mut req)?;
486                        let control_handle = SpeedtestControlHandle { inner: this.inner.clone() };
487                        Ok(SpeedtestRequest::SocketUp {
488                            socket: req.socket,
489                            params: req.params,
490
491                            responder: SpeedtestSocketUpResponder {
492                                control_handle: std::mem::ManuallyDrop::new(control_handle),
493                                tx_id: header.tx_id,
494                            },
495                        })
496                    }
497                    0x426e13de44070751 => {
498                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
499                        let mut req = fidl::new_empty!(
500                            SpeedtestSocketDownRequest,
501                            fidl::encoding::DefaultFuchsiaResourceDialect
502                        );
503                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SpeedtestSocketDownRequest>(&header, _body_bytes, handles, &mut req)?;
504                        let control_handle = SpeedtestControlHandle { inner: this.inner.clone() };
505                        Ok(SpeedtestRequest::SocketDown {
506                            socket: req.socket,
507                            params: req.params,
508
509                            responder: SpeedtestSocketDownResponder {
510                                control_handle: std::mem::ManuallyDrop::new(control_handle),
511                                tx_id: header.tx_id,
512                            },
513                        })
514                    }
515                    _ if header.tx_id == 0
516                        && header
517                            .dynamic_flags()
518                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
519                    {
520                        Ok(SpeedtestRequest::_UnknownMethod {
521                            ordinal: header.ordinal,
522                            control_handle: SpeedtestControlHandle { inner: this.inner.clone() },
523                            method_type: fidl::MethodType::OneWay,
524                        })
525                    }
526                    _ if header
527                        .dynamic_flags()
528                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
529                    {
530                        this.inner.send_framework_err(
531                            fidl::encoding::FrameworkErr::UnknownMethod,
532                            header.tx_id,
533                            header.ordinal,
534                            header.dynamic_flags(),
535                            (bytes, handles),
536                        )?;
537                        Ok(SpeedtestRequest::_UnknownMethod {
538                            ordinal: header.ordinal,
539                            control_handle: SpeedtestControlHandle { inner: this.inner.clone() },
540                            method_type: fidl::MethodType::TwoWay,
541                        })
542                    }
543                    _ => Err(fidl::Error::UnknownOrdinal {
544                        ordinal: header.ordinal,
545                        protocol_name:
546                            <SpeedtestMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
547                    }),
548                }))
549            },
550        )
551    }
552}
553
554#[derive(Debug)]
555pub enum SpeedtestRequest {
556    /// No-op, server responds immediately.
557    Ping { responder: SpeedtestPingResponder },
558    /// Server writes data into the provided zircon socket and reports stats.
559    SocketUp { socket: fidl::Socket, params: TransferParams, responder: SpeedtestSocketUpResponder },
560    /// Server reads data from the provided zircon socket and reports stats.
561    SocketDown {
562        socket: fidl::Socket,
563        params: TransferParams,
564        responder: SpeedtestSocketDownResponder,
565    },
566    /// An interaction was received which does not match any known method.
567    #[non_exhaustive]
568    _UnknownMethod {
569        /// Ordinal of the method that was called.
570        ordinal: u64,
571        control_handle: SpeedtestControlHandle,
572        method_type: fidl::MethodType,
573    },
574}
575
576impl SpeedtestRequest {
577    #[allow(irrefutable_let_patterns)]
578    pub fn into_ping(self) -> Option<(SpeedtestPingResponder)> {
579        if let SpeedtestRequest::Ping { responder } = self {
580            Some((responder))
581        } else {
582            None
583        }
584    }
585
586    #[allow(irrefutable_let_patterns)]
587    pub fn into_socket_up(
588        self,
589    ) -> Option<(fidl::Socket, TransferParams, SpeedtestSocketUpResponder)> {
590        if let SpeedtestRequest::SocketUp { socket, params, responder } = self {
591            Some((socket, params, responder))
592        } else {
593            None
594        }
595    }
596
597    #[allow(irrefutable_let_patterns)]
598    pub fn into_socket_down(
599        self,
600    ) -> Option<(fidl::Socket, TransferParams, SpeedtestSocketDownResponder)> {
601        if let SpeedtestRequest::SocketDown { socket, params, responder } = self {
602            Some((socket, params, responder))
603        } else {
604            None
605        }
606    }
607
608    /// Name of the method defined in FIDL
609    pub fn method_name(&self) -> &'static str {
610        match *self {
611            SpeedtestRequest::Ping { .. } => "ping",
612            SpeedtestRequest::SocketUp { .. } => "socket_up",
613            SpeedtestRequest::SocketDown { .. } => "socket_down",
614            SpeedtestRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
615                "unknown one-way method"
616            }
617            SpeedtestRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
618                "unknown two-way method"
619            }
620        }
621    }
622}
623
624#[derive(Debug, Clone)]
625pub struct SpeedtestControlHandle {
626    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
627}
628
629impl fidl::endpoints::ControlHandle for SpeedtestControlHandle {
630    fn shutdown(&self) {
631        self.inner.shutdown()
632    }
633    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
634        self.inner.shutdown_with_epitaph(status)
635    }
636
637    fn is_closed(&self) -> bool {
638        self.inner.channel().is_closed()
639    }
640    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
641        self.inner.channel().on_closed()
642    }
643
644    #[cfg(target_os = "fuchsia")]
645    fn signal_peer(
646        &self,
647        clear_mask: zx::Signals,
648        set_mask: zx::Signals,
649    ) -> Result<(), zx_status::Status> {
650        use fidl::Peered;
651        self.inner.channel().signal_peer(clear_mask, set_mask)
652    }
653}
654
655impl SpeedtestControlHandle {}
656
657#[must_use = "FIDL methods require a response to be sent"]
658#[derive(Debug)]
659pub struct SpeedtestPingResponder {
660    control_handle: std::mem::ManuallyDrop<SpeedtestControlHandle>,
661    tx_id: u32,
662}
663
664/// Set the the channel to be shutdown (see [`SpeedtestControlHandle::shutdown`])
665/// if the responder is dropped without sending a response, so that the client
666/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
667impl std::ops::Drop for SpeedtestPingResponder {
668    fn drop(&mut self) {
669        self.control_handle.shutdown();
670        // Safety: drops once, never accessed again
671        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
672    }
673}
674
675impl fidl::endpoints::Responder for SpeedtestPingResponder {
676    type ControlHandle = SpeedtestControlHandle;
677
678    fn control_handle(&self) -> &SpeedtestControlHandle {
679        &self.control_handle
680    }
681
682    fn drop_without_shutdown(mut self) {
683        // Safety: drops once, never accessed again due to mem::forget
684        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
685        // Prevent Drop from running (which would shut down the channel)
686        std::mem::forget(self);
687    }
688}
689
690impl SpeedtestPingResponder {
691    /// Sends a response to the FIDL transaction.
692    ///
693    /// Sets the channel to shutdown if an error occurs.
694    pub fn send(self) -> Result<(), fidl::Error> {
695        let _result = self.send_raw();
696        if _result.is_err() {
697            self.control_handle.shutdown();
698        }
699        self.drop_without_shutdown();
700        _result
701    }
702
703    /// Similar to "send" but does not shutdown the channel if an error occurs.
704    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
705        let _result = self.send_raw();
706        self.drop_without_shutdown();
707        _result
708    }
709
710    fn send_raw(&self) -> Result<(), fidl::Error> {
711        self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
712            fidl::encoding::Flexible::new(()),
713            self.tx_id,
714            0x1511ccb237874689,
715            fidl::encoding::DynamicFlags::FLEXIBLE,
716        )
717    }
718}
719
720#[must_use = "FIDL methods require a response to be sent"]
721#[derive(Debug)]
722pub struct SpeedtestSocketUpResponder {
723    control_handle: std::mem::ManuallyDrop<SpeedtestControlHandle>,
724    tx_id: u32,
725}
726
727/// Set the the channel to be shutdown (see [`SpeedtestControlHandle::shutdown`])
728/// if the responder is dropped without sending a response, so that the client
729/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
730impl std::ops::Drop for SpeedtestSocketUpResponder {
731    fn drop(&mut self) {
732        self.control_handle.shutdown();
733        // Safety: drops once, never accessed again
734        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
735    }
736}
737
738impl fidl::endpoints::Responder for SpeedtestSocketUpResponder {
739    type ControlHandle = SpeedtestControlHandle;
740
741    fn control_handle(&self) -> &SpeedtestControlHandle {
742        &self.control_handle
743    }
744
745    fn drop_without_shutdown(mut self) {
746        // Safety: drops once, never accessed again due to mem::forget
747        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
748        // Prevent Drop from running (which would shut down the channel)
749        std::mem::forget(self);
750    }
751}
752
753impl SpeedtestSocketUpResponder {
754    /// Sends a response to the FIDL transaction.
755    ///
756    /// Sets the channel to shutdown if an error occurs.
757    pub fn send(self, mut payload: &TransferReport) -> Result<(), fidl::Error> {
758        let _result = self.send_raw(payload);
759        if _result.is_err() {
760            self.control_handle.shutdown();
761        }
762        self.drop_without_shutdown();
763        _result
764    }
765
766    /// Similar to "send" but does not shutdown the channel if an error occurs.
767    pub fn send_no_shutdown_on_err(self, mut payload: &TransferReport) -> Result<(), fidl::Error> {
768        let _result = self.send_raw(payload);
769        self.drop_without_shutdown();
770        _result
771    }
772
773    fn send_raw(&self, mut payload: &TransferReport) -> Result<(), fidl::Error> {
774        self.control_handle.inner.send::<fidl::encoding::FlexibleType<TransferReport>>(
775            fidl::encoding::Flexible::new(payload),
776            self.tx_id,
777            0x7c530a369209ae87,
778            fidl::encoding::DynamicFlags::FLEXIBLE,
779        )
780    }
781}
782
783#[must_use = "FIDL methods require a response to be sent"]
784#[derive(Debug)]
785pub struct SpeedtestSocketDownResponder {
786    control_handle: std::mem::ManuallyDrop<SpeedtestControlHandle>,
787    tx_id: u32,
788}
789
790/// Set the the channel to be shutdown (see [`SpeedtestControlHandle::shutdown`])
791/// if the responder is dropped without sending a response, so that the client
792/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
793impl std::ops::Drop for SpeedtestSocketDownResponder {
794    fn drop(&mut self) {
795        self.control_handle.shutdown();
796        // Safety: drops once, never accessed again
797        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
798    }
799}
800
801impl fidl::endpoints::Responder for SpeedtestSocketDownResponder {
802    type ControlHandle = SpeedtestControlHandle;
803
804    fn control_handle(&self) -> &SpeedtestControlHandle {
805        &self.control_handle
806    }
807
808    fn drop_without_shutdown(mut self) {
809        // Safety: drops once, never accessed again due to mem::forget
810        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
811        // Prevent Drop from running (which would shut down the channel)
812        std::mem::forget(self);
813    }
814}
815
816impl SpeedtestSocketDownResponder {
817    /// Sends a response to the FIDL transaction.
818    ///
819    /// Sets the channel to shutdown if an error occurs.
820    pub fn send(self, mut payload: &TransferReport) -> Result<(), fidl::Error> {
821        let _result = self.send_raw(payload);
822        if _result.is_err() {
823            self.control_handle.shutdown();
824        }
825        self.drop_without_shutdown();
826        _result
827    }
828
829    /// Similar to "send" but does not shutdown the channel if an error occurs.
830    pub fn send_no_shutdown_on_err(self, mut payload: &TransferReport) -> Result<(), fidl::Error> {
831        let _result = self.send_raw(payload);
832        self.drop_without_shutdown();
833        _result
834    }
835
836    fn send_raw(&self, mut payload: &TransferReport) -> Result<(), fidl::Error> {
837        self.control_handle.inner.send::<fidl::encoding::FlexibleType<TransferReport>>(
838            fidl::encoding::Flexible::new(payload),
839            self.tx_id,
840            0x426e13de44070751,
841            fidl::encoding::DynamicFlags::FLEXIBLE,
842        )
843    }
844}
845
846mod internal {
847    use super::*;
848
849    impl fidl::encoding::ResourceTypeMarker for SpeedtestSocketDownRequest {
850        type Borrowed<'a> = &'a mut Self;
851        fn take_or_borrow<'a>(
852            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
853        ) -> Self::Borrowed<'a> {
854            value
855        }
856    }
857
858    unsafe impl fidl::encoding::TypeMarker for SpeedtestSocketDownRequest {
859        type Owned = Self;
860
861        #[inline(always)]
862        fn inline_align(_context: fidl::encoding::Context) -> usize {
863            8
864        }
865
866        #[inline(always)]
867        fn inline_size(_context: fidl::encoding::Context) -> usize {
868            24
869        }
870    }
871
872    unsafe impl
873        fidl::encoding::Encode<
874            SpeedtestSocketDownRequest,
875            fidl::encoding::DefaultFuchsiaResourceDialect,
876        > for &mut SpeedtestSocketDownRequest
877    {
878        #[inline]
879        unsafe fn encode(
880            self,
881            encoder: &mut fidl::encoding::Encoder<
882                '_,
883                fidl::encoding::DefaultFuchsiaResourceDialect,
884            >,
885            offset: usize,
886            _depth: fidl::encoding::Depth,
887        ) -> fidl::Result<()> {
888            encoder.debug_check_bounds::<SpeedtestSocketDownRequest>(offset);
889            // Delegate to tuple encoding.
890            fidl::encoding::Encode::<
891                SpeedtestSocketDownRequest,
892                fidl::encoding::DefaultFuchsiaResourceDialect,
893            >::encode(
894                (
895                    <fidl::encoding::HandleType<
896                        fidl::Socket,
897                        { fidl::ObjectType::SOCKET.into_raw() },
898                        16388,
899                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
900                        &mut self.socket
901                    ),
902                    <TransferParams as fidl::encoding::ValueTypeMarker>::borrow(&self.params),
903                ),
904                encoder,
905                offset,
906                _depth,
907            )
908        }
909    }
910    unsafe impl<
911            T0: fidl::encoding::Encode<
912                fidl::encoding::HandleType<
913                    fidl::Socket,
914                    { fidl::ObjectType::SOCKET.into_raw() },
915                    16388,
916                >,
917                fidl::encoding::DefaultFuchsiaResourceDialect,
918            >,
919            T1: fidl::encoding::Encode<TransferParams, fidl::encoding::DefaultFuchsiaResourceDialect>,
920        >
921        fidl::encoding::Encode<
922            SpeedtestSocketDownRequest,
923            fidl::encoding::DefaultFuchsiaResourceDialect,
924        > for (T0, T1)
925    {
926        #[inline]
927        unsafe fn encode(
928            self,
929            encoder: &mut fidl::encoding::Encoder<
930                '_,
931                fidl::encoding::DefaultFuchsiaResourceDialect,
932            >,
933            offset: usize,
934            depth: fidl::encoding::Depth,
935        ) -> fidl::Result<()> {
936            encoder.debug_check_bounds::<SpeedtestSocketDownRequest>(offset);
937            // Zero out padding regions. There's no need to apply masks
938            // because the unmasked parts will be overwritten by fields.
939            unsafe {
940                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
941                (ptr as *mut u64).write_unaligned(0);
942            }
943            // Write the fields.
944            self.0.encode(encoder, offset + 0, depth)?;
945            self.1.encode(encoder, offset + 8, depth)?;
946            Ok(())
947        }
948    }
949
950    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
951        for SpeedtestSocketDownRequest
952    {
953        #[inline(always)]
954        fn new_empty() -> Self {
955            Self {
956                socket: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 16388>, fidl::encoding::DefaultFuchsiaResourceDialect),
957                params: fidl::new_empty!(
958                    TransferParams,
959                    fidl::encoding::DefaultFuchsiaResourceDialect
960                ),
961            }
962        }
963
964        #[inline]
965        unsafe fn decode(
966            &mut self,
967            decoder: &mut fidl::encoding::Decoder<
968                '_,
969                fidl::encoding::DefaultFuchsiaResourceDialect,
970            >,
971            offset: usize,
972            _depth: fidl::encoding::Depth,
973        ) -> fidl::Result<()> {
974            decoder.debug_check_bounds::<Self>(offset);
975            // Verify that padding bytes are zero.
976            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
977            let padval = unsafe { (ptr as *const u64).read_unaligned() };
978            let mask = 0xffffffff00000000u64;
979            let maskedval = padval & mask;
980            if maskedval != 0 {
981                return Err(fidl::Error::NonZeroPadding {
982                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
983                });
984            }
985            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 16388>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket, decoder, offset + 0, _depth)?;
986            fidl::decode!(
987                TransferParams,
988                fidl::encoding::DefaultFuchsiaResourceDialect,
989                &mut self.params,
990                decoder,
991                offset + 8,
992                _depth
993            )?;
994            Ok(())
995        }
996    }
997
998    impl fidl::encoding::ResourceTypeMarker for SpeedtestSocketUpRequest {
999        type Borrowed<'a> = &'a mut Self;
1000        fn take_or_borrow<'a>(
1001            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1002        ) -> Self::Borrowed<'a> {
1003            value
1004        }
1005    }
1006
1007    unsafe impl fidl::encoding::TypeMarker for SpeedtestSocketUpRequest {
1008        type Owned = Self;
1009
1010        #[inline(always)]
1011        fn inline_align(_context: fidl::encoding::Context) -> usize {
1012            8
1013        }
1014
1015        #[inline(always)]
1016        fn inline_size(_context: fidl::encoding::Context) -> usize {
1017            24
1018        }
1019    }
1020
1021    unsafe impl
1022        fidl::encoding::Encode<
1023            SpeedtestSocketUpRequest,
1024            fidl::encoding::DefaultFuchsiaResourceDialect,
1025        > for &mut SpeedtestSocketUpRequest
1026    {
1027        #[inline]
1028        unsafe fn encode(
1029            self,
1030            encoder: &mut fidl::encoding::Encoder<
1031                '_,
1032                fidl::encoding::DefaultFuchsiaResourceDialect,
1033            >,
1034            offset: usize,
1035            _depth: fidl::encoding::Depth,
1036        ) -> fidl::Result<()> {
1037            encoder.debug_check_bounds::<SpeedtestSocketUpRequest>(offset);
1038            // Delegate to tuple encoding.
1039            fidl::encoding::Encode::<
1040                SpeedtestSocketUpRequest,
1041                fidl::encoding::DefaultFuchsiaResourceDialect,
1042            >::encode(
1043                (
1044                    <fidl::encoding::HandleType<
1045                        fidl::Socket,
1046                        { fidl::ObjectType::SOCKET.into_raw() },
1047                        16392,
1048                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
1049                        &mut self.socket
1050                    ),
1051                    <TransferParams as fidl::encoding::ValueTypeMarker>::borrow(&self.params),
1052                ),
1053                encoder,
1054                offset,
1055                _depth,
1056            )
1057        }
1058    }
1059    unsafe impl<
1060            T0: fidl::encoding::Encode<
1061                fidl::encoding::HandleType<
1062                    fidl::Socket,
1063                    { fidl::ObjectType::SOCKET.into_raw() },
1064                    16392,
1065                >,
1066                fidl::encoding::DefaultFuchsiaResourceDialect,
1067            >,
1068            T1: fidl::encoding::Encode<TransferParams, fidl::encoding::DefaultFuchsiaResourceDialect>,
1069        >
1070        fidl::encoding::Encode<
1071            SpeedtestSocketUpRequest,
1072            fidl::encoding::DefaultFuchsiaResourceDialect,
1073        > for (T0, T1)
1074    {
1075        #[inline]
1076        unsafe fn encode(
1077            self,
1078            encoder: &mut fidl::encoding::Encoder<
1079                '_,
1080                fidl::encoding::DefaultFuchsiaResourceDialect,
1081            >,
1082            offset: usize,
1083            depth: fidl::encoding::Depth,
1084        ) -> fidl::Result<()> {
1085            encoder.debug_check_bounds::<SpeedtestSocketUpRequest>(offset);
1086            // Zero out padding regions. There's no need to apply masks
1087            // because the unmasked parts will be overwritten by fields.
1088            unsafe {
1089                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1090                (ptr as *mut u64).write_unaligned(0);
1091            }
1092            // Write the fields.
1093            self.0.encode(encoder, offset + 0, depth)?;
1094            self.1.encode(encoder, offset + 8, depth)?;
1095            Ok(())
1096        }
1097    }
1098
1099    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1100        for SpeedtestSocketUpRequest
1101    {
1102        #[inline(always)]
1103        fn new_empty() -> Self {
1104            Self {
1105                socket: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 16392>, fidl::encoding::DefaultFuchsiaResourceDialect),
1106                params: fidl::new_empty!(
1107                    TransferParams,
1108                    fidl::encoding::DefaultFuchsiaResourceDialect
1109                ),
1110            }
1111        }
1112
1113        #[inline]
1114        unsafe fn decode(
1115            &mut self,
1116            decoder: &mut fidl::encoding::Decoder<
1117                '_,
1118                fidl::encoding::DefaultFuchsiaResourceDialect,
1119            >,
1120            offset: usize,
1121            _depth: fidl::encoding::Depth,
1122        ) -> fidl::Result<()> {
1123            decoder.debug_check_bounds::<Self>(offset);
1124            // Verify that padding bytes are zero.
1125            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1126            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1127            let mask = 0xffffffff00000000u64;
1128            let maskedval = padval & mask;
1129            if maskedval != 0 {
1130                return Err(fidl::Error::NonZeroPadding {
1131                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1132                });
1133            }
1134            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 16392>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket, decoder, offset + 0, _depth)?;
1135            fidl::decode!(
1136                TransferParams,
1137                fidl::encoding::DefaultFuchsiaResourceDialect,
1138                &mut self.params,
1139                decoder,
1140                offset + 8,
1141                _depth
1142            )?;
1143            Ok(())
1144        }
1145    }
1146}
fidl_fuchsia_developer_ffx_speedtest/fidl_fuchsia_developer_ffx_speedtest.rs

fidl_fuchsia_developer_ffx_speedtest/
fidl_fuchsia_developer_ffx_speedtest.rs
