fidl_fuchsia_bluetooth_hfp_test/
fidl_fuchsia_bluetooth_hfp_test.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_hfp_test_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
15pub struct HfpTestMarker;
16
17impl fidl::endpoints::ProtocolMarker for HfpTestMarker {
18    type Proxy = HfpTestProxy;
19    type RequestStream = HfpTestRequestStream;
20    #[cfg(target_os = "fuchsia")]
21    type SynchronousProxy = HfpTestSynchronousProxy;
22
23    const DEBUG_NAME: &'static str = "fuchsia.bluetooth.hfp.test.HfpTest";
24}
25impl fidl::endpoints::DiscoverableProtocolMarker for HfpTestMarker {}
26
27pub trait HfpTestProxyInterface: Send + Sync {
28    fn r#battery_indicator(&self, level: u8) -> Result<(), fidl::Error>;
29    fn r#set_connection_behavior(&self, behavior: &ConnectionBehavior) -> Result<(), fidl::Error>;
30}
31#[derive(Debug)]
32#[cfg(target_os = "fuchsia")]
33pub struct HfpTestSynchronousProxy {
34    client: fidl::client::sync::Client,
35}
36
37#[cfg(target_os = "fuchsia")]
38impl fidl::endpoints::SynchronousProxy for HfpTestSynchronousProxy {
39    type Proxy = HfpTestProxy;
40    type Protocol = HfpTestMarker;
41
42    fn from_channel(inner: fidl::Channel) -> Self {
43        Self::new(inner)
44    }
45
46    fn into_channel(self) -> fidl::Channel {
47        self.client.into_channel()
48    }
49
50    fn as_channel(&self) -> &fidl::Channel {
51        self.client.as_channel()
52    }
53}
54
55#[cfg(target_os = "fuchsia")]
56impl HfpTestSynchronousProxy {
57    pub fn new(channel: fidl::Channel) -> Self {
58        let protocol_name = <HfpTestMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
59        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
60    }
61
62    pub fn into_channel(self) -> fidl::Channel {
63        self.client.into_channel()
64    }
65
66    /// Waits until an event arrives and returns it. It is safe for other
67    /// threads to make concurrent requests while waiting for an event.
68    pub fn wait_for_event(
69        &self,
70        deadline: zx::MonotonicInstant,
71    ) -> Result<HfpTestEvent, fidl::Error> {
72        HfpTestEvent::decode(self.client.wait_for_event(deadline)?)
73    }
74
75    /// Set the value of the AG battery indicator.
76    ///
77    /// `level` must be within the range 0-5 inclusive. Values outside of this
78    /// range cause the channel to close.
79    pub fn r#battery_indicator(&self, mut level: u8) -> Result<(), fidl::Error> {
80        self.client.send::<HfpTestBatteryIndicatorRequest>(
81            (level,),
82            0x2e77903bc47766a,
83            fidl::encoding::DynamicFlags::empty(),
84        )
85    }
86
87    /// Configure the connection behavior when the component discovers new peers.
88    pub fn r#set_connection_behavior(
89        &self,
90        mut behavior: &ConnectionBehavior,
91    ) -> Result<(), fidl::Error> {
92        self.client.send::<HfpTestSetConnectionBehaviorRequest>(
93            (behavior,),
94            0x33ef757527a5bf07,
95            fidl::encoding::DynamicFlags::empty(),
96        )
97    }
98}
99
100#[cfg(target_os = "fuchsia")]
101impl From<HfpTestSynchronousProxy> for zx::Handle {
102    fn from(value: HfpTestSynchronousProxy) -> Self {
103        value.into_channel().into()
104    }
105}
106
107#[cfg(target_os = "fuchsia")]
108impl From<fidl::Channel> for HfpTestSynchronousProxy {
109    fn from(value: fidl::Channel) -> Self {
110        Self::new(value)
111    }
112}
113
114#[derive(Debug, Clone)]
115pub struct HfpTestProxy {
116    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
117}
118
119impl fidl::endpoints::Proxy for HfpTestProxy {
120    type Protocol = HfpTestMarker;
121
122    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
123        Self::new(inner)
124    }
125
126    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
127        self.client.into_channel().map_err(|client| Self { client })
128    }
129
130    fn as_channel(&self) -> &::fidl::AsyncChannel {
131        self.client.as_channel()
132    }
133}
134
135impl HfpTestProxy {
136    /// Create a new Proxy for fuchsia.bluetooth.hfp.test/HfpTest.
137    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
138        let protocol_name = <HfpTestMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
139        Self { client: fidl::client::Client::new(channel, protocol_name) }
140    }
141
142    /// Get a Stream of events from the remote end of the protocol.
143    ///
144    /// # Panics
145    ///
146    /// Panics if the event stream was already taken.
147    pub fn take_event_stream(&self) -> HfpTestEventStream {
148        HfpTestEventStream { event_receiver: self.client.take_event_receiver() }
149    }
150
151    /// Set the value of the AG battery indicator.
152    ///
153    /// `level` must be within the range 0-5 inclusive. Values outside of this
154    /// range cause the channel to close.
155    pub fn r#battery_indicator(&self, mut level: u8) -> Result<(), fidl::Error> {
156        HfpTestProxyInterface::r#battery_indicator(self, level)
157    }
158
159    /// Configure the connection behavior when the component discovers new peers.
160    pub fn r#set_connection_behavior(
161        &self,
162        mut behavior: &ConnectionBehavior,
163    ) -> Result<(), fidl::Error> {
164        HfpTestProxyInterface::r#set_connection_behavior(self, behavior)
165    }
166}
167
168impl HfpTestProxyInterface for HfpTestProxy {
169    fn r#battery_indicator(&self, mut level: u8) -> Result<(), fidl::Error> {
170        self.client.send::<HfpTestBatteryIndicatorRequest>(
171            (level,),
172            0x2e77903bc47766a,
173            fidl::encoding::DynamicFlags::empty(),
174        )
175    }
176
177    fn r#set_connection_behavior(
178        &self,
179        mut behavior: &ConnectionBehavior,
180    ) -> Result<(), fidl::Error> {
181        self.client.send::<HfpTestSetConnectionBehaviorRequest>(
182            (behavior,),
183            0x33ef757527a5bf07,
184            fidl::encoding::DynamicFlags::empty(),
185        )
186    }
187}
188
189pub struct HfpTestEventStream {
190    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
191}
192
193impl std::marker::Unpin for HfpTestEventStream {}
194
195impl futures::stream::FusedStream for HfpTestEventStream {
196    fn is_terminated(&self) -> bool {
197        self.event_receiver.is_terminated()
198    }
199}
200
201impl futures::Stream for HfpTestEventStream {
202    type Item = Result<HfpTestEvent, fidl::Error>;
203
204    fn poll_next(
205        mut self: std::pin::Pin<&mut Self>,
206        cx: &mut std::task::Context<'_>,
207    ) -> std::task::Poll<Option<Self::Item>> {
208        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
209            &mut self.event_receiver,
210            cx
211        )?) {
212            Some(buf) => std::task::Poll::Ready(Some(HfpTestEvent::decode(buf))),
213            None => std::task::Poll::Ready(None),
214        }
215    }
216}
217
218#[derive(Debug)]
219pub enum HfpTestEvent {}
220
221impl HfpTestEvent {
222    /// Decodes a message buffer as a [`HfpTestEvent`].
223    fn decode(
224        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
225    ) -> Result<HfpTestEvent, fidl::Error> {
226        let (bytes, _handles) = buf.split_mut();
227        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
228        debug_assert_eq!(tx_header.tx_id, 0);
229        match tx_header.ordinal {
230            _ => Err(fidl::Error::UnknownOrdinal {
231                ordinal: tx_header.ordinal,
232                protocol_name: <HfpTestMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
233            }),
234        }
235    }
236}
237
238/// A Stream of incoming requests for fuchsia.bluetooth.hfp.test/HfpTest.
239pub struct HfpTestRequestStream {
240    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
241    is_terminated: bool,
242}
243
244impl std::marker::Unpin for HfpTestRequestStream {}
245
246impl futures::stream::FusedStream for HfpTestRequestStream {
247    fn is_terminated(&self) -> bool {
248        self.is_terminated
249    }
250}
251
252impl fidl::endpoints::RequestStream for HfpTestRequestStream {
253    type Protocol = HfpTestMarker;
254    type ControlHandle = HfpTestControlHandle;
255
256    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
257        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
258    }
259
260    fn control_handle(&self) -> Self::ControlHandle {
261        HfpTestControlHandle { inner: self.inner.clone() }
262    }
263
264    fn into_inner(
265        self,
266    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
267    {
268        (self.inner, self.is_terminated)
269    }
270
271    fn from_inner(
272        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
273        is_terminated: bool,
274    ) -> Self {
275        Self { inner, is_terminated }
276    }
277}
278
279impl futures::Stream for HfpTestRequestStream {
280    type Item = Result<HfpTestRequest, fidl::Error>;
281
282    fn poll_next(
283        mut self: std::pin::Pin<&mut Self>,
284        cx: &mut std::task::Context<'_>,
285    ) -> std::task::Poll<Option<Self::Item>> {
286        let this = &mut *self;
287        if this.inner.check_shutdown(cx) {
288            this.is_terminated = true;
289            return std::task::Poll::Ready(None);
290        }
291        if this.is_terminated {
292            panic!("polled HfpTestRequestStream after completion");
293        }
294        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
295            |bytes, handles| {
296                match this.inner.channel().read_etc(cx, bytes, handles) {
297                    std::task::Poll::Ready(Ok(())) => {}
298                    std::task::Poll::Pending => return std::task::Poll::Pending,
299                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
300                        this.is_terminated = true;
301                        return std::task::Poll::Ready(None);
302                    }
303                    std::task::Poll::Ready(Err(e)) => {
304                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
305                            e.into(),
306                        ))))
307                    }
308                }
309
310                // A message has been received from the channel
311                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
312
313                std::task::Poll::Ready(Some(match header.ordinal {
314                    0x2e77903bc47766a => {
315                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
316                        let mut req = fidl::new_empty!(
317                            HfpTestBatteryIndicatorRequest,
318                            fidl::encoding::DefaultFuchsiaResourceDialect
319                        );
320                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<HfpTestBatteryIndicatorRequest>(&header, _body_bytes, handles, &mut req)?;
321                        let control_handle = HfpTestControlHandle { inner: this.inner.clone() };
322                        Ok(HfpTestRequest::BatteryIndicator { level: req.level, control_handle })
323                    }
324                    0x33ef757527a5bf07 => {
325                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
326                        let mut req = fidl::new_empty!(
327                            HfpTestSetConnectionBehaviorRequest,
328                            fidl::encoding::DefaultFuchsiaResourceDialect
329                        );
330                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<HfpTestSetConnectionBehaviorRequest>(&header, _body_bytes, handles, &mut req)?;
331                        let control_handle = HfpTestControlHandle { inner: this.inner.clone() };
332                        Ok(HfpTestRequest::SetConnectionBehavior {
333                            behavior: req.behavior,
334
335                            control_handle,
336                        })
337                    }
338                    _ => Err(fidl::Error::UnknownOrdinal {
339                        ordinal: header.ordinal,
340                        protocol_name:
341                            <HfpTestMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
342                    }),
343                }))
344            },
345        )
346    }
347}
348
349/// Provides additional methods not in `Hfp` that are strictly for testing.
350#[derive(Debug)]
351pub enum HfpTestRequest {
352    /// Set the value of the AG battery indicator.
353    ///
354    /// `level` must be within the range 0-5 inclusive. Values outside of this
355    /// range cause the channel to close.
356    BatteryIndicator { level: u8, control_handle: HfpTestControlHandle },
357    /// Configure the connection behavior when the component discovers new peers.
358    SetConnectionBehavior { behavior: ConnectionBehavior, control_handle: HfpTestControlHandle },
359}
360
361impl HfpTestRequest {
362    #[allow(irrefutable_let_patterns)]
363    pub fn into_battery_indicator(self) -> Option<(u8, HfpTestControlHandle)> {
364        if let HfpTestRequest::BatteryIndicator { level, control_handle } = self {
365            Some((level, control_handle))
366        } else {
367            None
368        }
369    }
370
371    #[allow(irrefutable_let_patterns)]
372    pub fn into_set_connection_behavior(
373        self,
374    ) -> Option<(ConnectionBehavior, HfpTestControlHandle)> {
375        if let HfpTestRequest::SetConnectionBehavior { behavior, control_handle } = self {
376            Some((behavior, control_handle))
377        } else {
378            None
379        }
380    }
381
382    /// Name of the method defined in FIDL
383    pub fn method_name(&self) -> &'static str {
384        match *self {
385            HfpTestRequest::BatteryIndicator { .. } => "battery_indicator",
386            HfpTestRequest::SetConnectionBehavior { .. } => "set_connection_behavior",
387        }
388    }
389}
390
391#[derive(Debug, Clone)]
392pub struct HfpTestControlHandle {
393    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
394}
395
396impl fidl::endpoints::ControlHandle for HfpTestControlHandle {
397    fn shutdown(&self) {
398        self.inner.shutdown()
399    }
400    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
401        self.inner.shutdown_with_epitaph(status)
402    }
403
404    fn is_closed(&self) -> bool {
405        self.inner.channel().is_closed()
406    }
407    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
408        self.inner.channel().on_closed()
409    }
410
411    #[cfg(target_os = "fuchsia")]
412    fn signal_peer(
413        &self,
414        clear_mask: zx::Signals,
415        set_mask: zx::Signals,
416    ) -> Result<(), zx_status::Status> {
417        use fidl::Peered;
418        self.inner.channel().signal_peer(clear_mask, set_mask)
419    }
420}
421
422impl HfpTestControlHandle {}
423
424mod internal {
425    use super::*;
426}
fidl_fuchsia_bluetooth_hfp_test/fidl_fuchsia_bluetooth_hfp_test.rs

fidl_fuchsia_bluetooth_hfp_test/
fidl_fuchsia_bluetooth_hfp_test.rs
