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::NullableHandle {
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 { Some((responder)) } else { None }
580    }
581
582    #[allow(irrefutable_let_patterns)]
583    pub fn into_socket_up(
584        self,
585    ) -> Option<(fidl::Socket, TransferParams, SpeedtestSocketUpResponder)> {
586        if let SpeedtestRequest::SocketUp { socket, params, responder } = self {
587            Some((socket, params, responder))
588        } else {
589            None
590        }
591    }
592
593    #[allow(irrefutable_let_patterns)]
594    pub fn into_socket_down(
595        self,
596    ) -> Option<(fidl::Socket, TransferParams, SpeedtestSocketDownResponder)> {
597        if let SpeedtestRequest::SocketDown { socket, params, responder } = self {
598            Some((socket, params, responder))
599        } else {
600            None
601        }
602    }
603
604    /// Name of the method defined in FIDL
605    pub fn method_name(&self) -> &'static str {
606        match *self {
607            SpeedtestRequest::Ping { .. } => "ping",
608            SpeedtestRequest::SocketUp { .. } => "socket_up",
609            SpeedtestRequest::SocketDown { .. } => "socket_down",
610            SpeedtestRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
611                "unknown one-way method"
612            }
613            SpeedtestRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
614                "unknown two-way method"
615            }
616        }
617    }
618}
619
620#[derive(Debug, Clone)]
621pub struct SpeedtestControlHandle {
622    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
623}
624
625impl fidl::endpoints::ControlHandle for SpeedtestControlHandle {
626    fn shutdown(&self) {
627        self.inner.shutdown()
628    }
629
630    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
631        self.inner.shutdown_with_epitaph(status)
632    }
633
634    fn is_closed(&self) -> bool {
635        self.inner.channel().is_closed()
636    }
637    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
638        self.inner.channel().on_closed()
639    }
640
641    #[cfg(target_os = "fuchsia")]
642    fn signal_peer(
643        &self,
644        clear_mask: zx::Signals,
645        set_mask: zx::Signals,
646    ) -> Result<(), zx_status::Status> {
647        use fidl::Peered;
648        self.inner.channel().signal_peer(clear_mask, set_mask)
649    }
650}
651
652impl SpeedtestControlHandle {}
653
654#[must_use = "FIDL methods require a response to be sent"]
655#[derive(Debug)]
656pub struct SpeedtestPingResponder {
657    control_handle: std::mem::ManuallyDrop<SpeedtestControlHandle>,
658    tx_id: u32,
659}
660
661/// Set the the channel to be shutdown (see [`SpeedtestControlHandle::shutdown`])
662/// if the responder is dropped without sending a response, so that the client
663/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
664impl std::ops::Drop for SpeedtestPingResponder {
665    fn drop(&mut self) {
666        self.control_handle.shutdown();
667        // Safety: drops once, never accessed again
668        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
669    }
670}
671
672impl fidl::endpoints::Responder for SpeedtestPingResponder {
673    type ControlHandle = SpeedtestControlHandle;
674
675    fn control_handle(&self) -> &SpeedtestControlHandle {
676        &self.control_handle
677    }
678
679    fn drop_without_shutdown(mut self) {
680        // Safety: drops once, never accessed again due to mem::forget
681        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
682        // Prevent Drop from running (which would shut down the channel)
683        std::mem::forget(self);
684    }
685}
686
687impl SpeedtestPingResponder {
688    /// Sends a response to the FIDL transaction.
689    ///
690    /// Sets the channel to shutdown if an error occurs.
691    pub fn send(self) -> Result<(), fidl::Error> {
692        let _result = self.send_raw();
693        if _result.is_err() {
694            self.control_handle.shutdown();
695        }
696        self.drop_without_shutdown();
697        _result
698    }
699
700    /// Similar to "send" but does not shutdown the channel if an error occurs.
701    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
702        let _result = self.send_raw();
703        self.drop_without_shutdown();
704        _result
705    }
706
707    fn send_raw(&self) -> Result<(), fidl::Error> {
708        self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
709            fidl::encoding::Flexible::new(()),
710            self.tx_id,
711            0x1511ccb237874689,
712            fidl::encoding::DynamicFlags::FLEXIBLE,
713        )
714    }
715}
716
717#[must_use = "FIDL methods require a response to be sent"]
718#[derive(Debug)]
719pub struct SpeedtestSocketUpResponder {
720    control_handle: std::mem::ManuallyDrop<SpeedtestControlHandle>,
721    tx_id: u32,
722}
723
724/// Set the the channel to be shutdown (see [`SpeedtestControlHandle::shutdown`])
725/// if the responder is dropped without sending a response, so that the client
726/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
727impl std::ops::Drop for SpeedtestSocketUpResponder {
728    fn drop(&mut self) {
729        self.control_handle.shutdown();
730        // Safety: drops once, never accessed again
731        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
732    }
733}
734
735impl fidl::endpoints::Responder for SpeedtestSocketUpResponder {
736    type ControlHandle = SpeedtestControlHandle;
737
738    fn control_handle(&self) -> &SpeedtestControlHandle {
739        &self.control_handle
740    }
741
742    fn drop_without_shutdown(mut self) {
743        // Safety: drops once, never accessed again due to mem::forget
744        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
745        // Prevent Drop from running (which would shut down the channel)
746        std::mem::forget(self);
747    }
748}
749
750impl SpeedtestSocketUpResponder {
751    /// Sends a response to the FIDL transaction.
752    ///
753    /// Sets the channel to shutdown if an error occurs.
754    pub fn send(self, mut payload: &TransferReport) -> Result<(), fidl::Error> {
755        let _result = self.send_raw(payload);
756        if _result.is_err() {
757            self.control_handle.shutdown();
758        }
759        self.drop_without_shutdown();
760        _result
761    }
762
763    /// Similar to "send" but does not shutdown the channel if an error occurs.
764    pub fn send_no_shutdown_on_err(self, mut payload: &TransferReport) -> Result<(), fidl::Error> {
765        let _result = self.send_raw(payload);
766        self.drop_without_shutdown();
767        _result
768    }
769
770    fn send_raw(&self, mut payload: &TransferReport) -> Result<(), fidl::Error> {
771        self.control_handle.inner.send::<fidl::encoding::FlexibleType<TransferReport>>(
772            fidl::encoding::Flexible::new(payload),
773            self.tx_id,
774            0x7c530a369209ae87,
775            fidl::encoding::DynamicFlags::FLEXIBLE,
776        )
777    }
778}
779
780#[must_use = "FIDL methods require a response to be sent"]
781#[derive(Debug)]
782pub struct SpeedtestSocketDownResponder {
783    control_handle: std::mem::ManuallyDrop<SpeedtestControlHandle>,
784    tx_id: u32,
785}
786
787/// Set the the channel to be shutdown (see [`SpeedtestControlHandle::shutdown`])
788/// if the responder is dropped without sending a response, so that the client
789/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
790impl std::ops::Drop for SpeedtestSocketDownResponder {
791    fn drop(&mut self) {
792        self.control_handle.shutdown();
793        // Safety: drops once, never accessed again
794        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
795    }
796}
797
798impl fidl::endpoints::Responder for SpeedtestSocketDownResponder {
799    type ControlHandle = SpeedtestControlHandle;
800
801    fn control_handle(&self) -> &SpeedtestControlHandle {
802        &self.control_handle
803    }
804
805    fn drop_without_shutdown(mut self) {
806        // Safety: drops once, never accessed again due to mem::forget
807        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
808        // Prevent Drop from running (which would shut down the channel)
809        std::mem::forget(self);
810    }
811}
812
813impl SpeedtestSocketDownResponder {
814    /// Sends a response to the FIDL transaction.
815    ///
816    /// Sets the channel to shutdown if an error occurs.
817    pub fn send(self, mut payload: &TransferReport) -> Result<(), fidl::Error> {
818        let _result = self.send_raw(payload);
819        if _result.is_err() {
820            self.control_handle.shutdown();
821        }
822        self.drop_without_shutdown();
823        _result
824    }
825
826    /// Similar to "send" but does not shutdown the channel if an error occurs.
827    pub fn send_no_shutdown_on_err(self, mut payload: &TransferReport) -> Result<(), fidl::Error> {
828        let _result = self.send_raw(payload);
829        self.drop_without_shutdown();
830        _result
831    }
832
833    fn send_raw(&self, mut payload: &TransferReport) -> Result<(), fidl::Error> {
834        self.control_handle.inner.send::<fidl::encoding::FlexibleType<TransferReport>>(
835            fidl::encoding::Flexible::new(payload),
836            self.tx_id,
837            0x426e13de44070751,
838            fidl::encoding::DynamicFlags::FLEXIBLE,
839        )
840    }
841}
842
843mod internal {
844    use super::*;
845
846    impl fidl::encoding::ResourceTypeMarker for SpeedtestSocketDownRequest {
847        type Borrowed<'a> = &'a mut Self;
848        fn take_or_borrow<'a>(
849            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
850        ) -> Self::Borrowed<'a> {
851            value
852        }
853    }
854
855    unsafe impl fidl::encoding::TypeMarker for SpeedtestSocketDownRequest {
856        type Owned = Self;
857
858        #[inline(always)]
859        fn inline_align(_context: fidl::encoding::Context) -> usize {
860            8
861        }
862
863        #[inline(always)]
864        fn inline_size(_context: fidl::encoding::Context) -> usize {
865            24
866        }
867    }
868
869    unsafe impl
870        fidl::encoding::Encode<
871            SpeedtestSocketDownRequest,
872            fidl::encoding::DefaultFuchsiaResourceDialect,
873        > for &mut SpeedtestSocketDownRequest
874    {
875        #[inline]
876        unsafe fn encode(
877            self,
878            encoder: &mut fidl::encoding::Encoder<
879                '_,
880                fidl::encoding::DefaultFuchsiaResourceDialect,
881            >,
882            offset: usize,
883            _depth: fidl::encoding::Depth,
884        ) -> fidl::Result<()> {
885            encoder.debug_check_bounds::<SpeedtestSocketDownRequest>(offset);
886            // Delegate to tuple encoding.
887            fidl::encoding::Encode::<
888                SpeedtestSocketDownRequest,
889                fidl::encoding::DefaultFuchsiaResourceDialect,
890            >::encode(
891                (
892                    <fidl::encoding::HandleType<
893                        fidl::Socket,
894                        { fidl::ObjectType::SOCKET.into_raw() },
895                        16388,
896                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
897                        &mut self.socket
898                    ),
899                    <TransferParams as fidl::encoding::ValueTypeMarker>::borrow(&self.params),
900                ),
901                encoder,
902                offset,
903                _depth,
904            )
905        }
906    }
907    unsafe impl<
908        T0: fidl::encoding::Encode<
909                fidl::encoding::HandleType<
910                    fidl::Socket,
911                    { fidl::ObjectType::SOCKET.into_raw() },
912                    16388,
913                >,
914                fidl::encoding::DefaultFuchsiaResourceDialect,
915            >,
916        T1: fidl::encoding::Encode<TransferParams, fidl::encoding::DefaultFuchsiaResourceDialect>,
917    >
918        fidl::encoding::Encode<
919            SpeedtestSocketDownRequest,
920            fidl::encoding::DefaultFuchsiaResourceDialect,
921        > for (T0, T1)
922    {
923        #[inline]
924        unsafe fn encode(
925            self,
926            encoder: &mut fidl::encoding::Encoder<
927                '_,
928                fidl::encoding::DefaultFuchsiaResourceDialect,
929            >,
930            offset: usize,
931            depth: fidl::encoding::Depth,
932        ) -> fidl::Result<()> {
933            encoder.debug_check_bounds::<SpeedtestSocketDownRequest>(offset);
934            // Zero out padding regions. There's no need to apply masks
935            // because the unmasked parts will be overwritten by fields.
936            unsafe {
937                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
938                (ptr as *mut u64).write_unaligned(0);
939            }
940            // Write the fields.
941            self.0.encode(encoder, offset + 0, depth)?;
942            self.1.encode(encoder, offset + 8, depth)?;
943            Ok(())
944        }
945    }
946
947    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
948        for SpeedtestSocketDownRequest
949    {
950        #[inline(always)]
951        fn new_empty() -> Self {
952            Self {
953                socket: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 16388>, fidl::encoding::DefaultFuchsiaResourceDialect),
954                params: fidl::new_empty!(
955                    TransferParams,
956                    fidl::encoding::DefaultFuchsiaResourceDialect
957                ),
958            }
959        }
960
961        #[inline]
962        unsafe fn decode(
963            &mut self,
964            decoder: &mut fidl::encoding::Decoder<
965                '_,
966                fidl::encoding::DefaultFuchsiaResourceDialect,
967            >,
968            offset: usize,
969            _depth: fidl::encoding::Depth,
970        ) -> fidl::Result<()> {
971            decoder.debug_check_bounds::<Self>(offset);
972            // Verify that padding bytes are zero.
973            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
974            let padval = unsafe { (ptr as *const u64).read_unaligned() };
975            let mask = 0xffffffff00000000u64;
976            let maskedval = padval & mask;
977            if maskedval != 0 {
978                return Err(fidl::Error::NonZeroPadding {
979                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
980                });
981            }
982            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 16388>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket, decoder, offset + 0, _depth)?;
983            fidl::decode!(
984                TransferParams,
985                fidl::encoding::DefaultFuchsiaResourceDialect,
986                &mut self.params,
987                decoder,
988                offset + 8,
989                _depth
990            )?;
991            Ok(())
992        }
993    }
994
995    impl fidl::encoding::ResourceTypeMarker for SpeedtestSocketUpRequest {
996        type Borrowed<'a> = &'a mut Self;
997        fn take_or_borrow<'a>(
998            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
999        ) -> Self::Borrowed<'a> {
1000            value
1001        }
1002    }
1003
1004    unsafe impl fidl::encoding::TypeMarker for SpeedtestSocketUpRequest {
1005        type Owned = Self;
1006
1007        #[inline(always)]
1008        fn inline_align(_context: fidl::encoding::Context) -> usize {
1009            8
1010        }
1011
1012        #[inline(always)]
1013        fn inline_size(_context: fidl::encoding::Context) -> usize {
1014            24
1015        }
1016    }
1017
1018    unsafe impl
1019        fidl::encoding::Encode<
1020            SpeedtestSocketUpRequest,
1021            fidl::encoding::DefaultFuchsiaResourceDialect,
1022        > for &mut SpeedtestSocketUpRequest
1023    {
1024        #[inline]
1025        unsafe fn encode(
1026            self,
1027            encoder: &mut fidl::encoding::Encoder<
1028                '_,
1029                fidl::encoding::DefaultFuchsiaResourceDialect,
1030            >,
1031            offset: usize,
1032            _depth: fidl::encoding::Depth,
1033        ) -> fidl::Result<()> {
1034            encoder.debug_check_bounds::<SpeedtestSocketUpRequest>(offset);
1035            // Delegate to tuple encoding.
1036            fidl::encoding::Encode::<
1037                SpeedtestSocketUpRequest,
1038                fidl::encoding::DefaultFuchsiaResourceDialect,
1039            >::encode(
1040                (
1041                    <fidl::encoding::HandleType<
1042                        fidl::Socket,
1043                        { fidl::ObjectType::SOCKET.into_raw() },
1044                        16392,
1045                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
1046                        &mut self.socket
1047                    ),
1048                    <TransferParams as fidl::encoding::ValueTypeMarker>::borrow(&self.params),
1049                ),
1050                encoder,
1051                offset,
1052                _depth,
1053            )
1054        }
1055    }
1056    unsafe impl<
1057        T0: fidl::encoding::Encode<
1058                fidl::encoding::HandleType<
1059                    fidl::Socket,
1060                    { fidl::ObjectType::SOCKET.into_raw() },
1061                    16392,
1062                >,
1063                fidl::encoding::DefaultFuchsiaResourceDialect,
1064            >,
1065        T1: fidl::encoding::Encode<TransferParams, fidl::encoding::DefaultFuchsiaResourceDialect>,
1066    >
1067        fidl::encoding::Encode<
1068            SpeedtestSocketUpRequest,
1069            fidl::encoding::DefaultFuchsiaResourceDialect,
1070        > for (T0, T1)
1071    {
1072        #[inline]
1073        unsafe fn encode(
1074            self,
1075            encoder: &mut fidl::encoding::Encoder<
1076                '_,
1077                fidl::encoding::DefaultFuchsiaResourceDialect,
1078            >,
1079            offset: usize,
1080            depth: fidl::encoding::Depth,
1081        ) -> fidl::Result<()> {
1082            encoder.debug_check_bounds::<SpeedtestSocketUpRequest>(offset);
1083            // Zero out padding regions. There's no need to apply masks
1084            // because the unmasked parts will be overwritten by fields.
1085            unsafe {
1086                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1087                (ptr as *mut u64).write_unaligned(0);
1088            }
1089            // Write the fields.
1090            self.0.encode(encoder, offset + 0, depth)?;
1091            self.1.encode(encoder, offset + 8, depth)?;
1092            Ok(())
1093        }
1094    }
1095
1096    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1097        for SpeedtestSocketUpRequest
1098    {
1099        #[inline(always)]
1100        fn new_empty() -> Self {
1101            Self {
1102                socket: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 16392>, fidl::encoding::DefaultFuchsiaResourceDialect),
1103                params: fidl::new_empty!(
1104                    TransferParams,
1105                    fidl::encoding::DefaultFuchsiaResourceDialect
1106                ),
1107            }
1108        }
1109
1110        #[inline]
1111        unsafe fn decode(
1112            &mut self,
1113            decoder: &mut fidl::encoding::Decoder<
1114                '_,
1115                fidl::encoding::DefaultFuchsiaResourceDialect,
1116            >,
1117            offset: usize,
1118            _depth: fidl::encoding::Depth,
1119        ) -> fidl::Result<()> {
1120            decoder.debug_check_bounds::<Self>(offset);
1121            // Verify that padding bytes are zero.
1122            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1123            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1124            let mask = 0xffffffff00000000u64;
1125            let maskedval = padval & mask;
1126            if maskedval != 0 {
1127                return Err(fidl::Error::NonZeroPadding {
1128                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1129                });
1130            }
1131            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 16392>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket, decoder, offset + 0, _depth)?;
1132            fidl::decode!(
1133                TransferParams,
1134                fidl::encoding::DefaultFuchsiaResourceDialect,
1135                &mut self.params,
1136                decoder,
1137                offset + 8,
1138                _depth
1139            )?;
1140            Ok(())
1141        }
1142    }
1143}
fidl_fuchsia_developer_ffx_speedtest/fidl_fuchsia_developer_ffx_speedtest.rs

fidl_fuchsia_developer_ffx_speedtest/
fidl_fuchsia_developer_ffx_speedtest.rs
