fidl_fuchsia_bluetooth_a2dp/
fidl_fuchsia_bluetooth_a2dp.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_a2dp_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
15pub struct AudioModeMarker;
16
17impl fidl::endpoints::ProtocolMarker for AudioModeMarker {
18    type Proxy = AudioModeProxy;
19    type RequestStream = AudioModeRequestStream;
20    #[cfg(target_os = "fuchsia")]
21    type SynchronousProxy = AudioModeSynchronousProxy;
22
23    const DEBUG_NAME: &'static str = "fuchsia.bluetooth.a2dp.AudioMode";
24}
25impl fidl::endpoints::DiscoverableProtocolMarker for AudioModeMarker {}
26
27pub trait AudioModeProxyInterface: Send + Sync {
28    type SetRoleResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
29    fn r#set_role(&self, role: Role) -> Self::SetRoleResponseFut;
30}
31#[derive(Debug)]
32#[cfg(target_os = "fuchsia")]
33pub struct AudioModeSynchronousProxy {
34    client: fidl::client::sync::Client,
35}
36
37#[cfg(target_os = "fuchsia")]
38impl fidl::endpoints::SynchronousProxy for AudioModeSynchronousProxy {
39    type Proxy = AudioModeProxy;
40    type Protocol = AudioModeMarker;
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 AudioModeSynchronousProxy {
57    pub fn new(channel: fidl::Channel) -> Self {
58        let protocol_name = <AudioModeMarker 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<AudioModeEvent, fidl::Error> {
72        AudioModeEvent::decode(self.client.wait_for_event(deadline)?)
73    }
74
75    /// Switch the device to act as the specified A2DP Role. If the device is already
76    /// set to the requested role, calling this method is a no-op.
77    ///
78    /// When this method returns, a client can depend on the following:
79    /// 1. If the role was switched, the previous profile has requested removal
80    ///    from the hosts' SDP databases, and all L2CAP channels associated with
81    ///    the previous profile have initiated or completed the process of closing.
82    /// 2. The device is in the requested A2DP role.
83    ///
84    /// If the role cannot be set due to an internal error, the server will close
85    /// the channel.
86    pub fn r#set_role(
87        &self,
88        mut role: Role,
89        ___deadline: zx::MonotonicInstant,
90    ) -> Result<(), fidl::Error> {
91        let _response =
92            self.client.send_query::<AudioModeSetRoleRequest, fidl::encoding::EmptyPayload>(
93                (role,),
94                0x55bc139643a166a6,
95                fidl::encoding::DynamicFlags::empty(),
96                ___deadline,
97            )?;
98        Ok(_response)
99    }
100}
101
102#[cfg(target_os = "fuchsia")]
103impl From<AudioModeSynchronousProxy> for zx::Handle {
104    fn from(value: AudioModeSynchronousProxy) -> Self {
105        value.into_channel().into()
106    }
107}
108
109#[cfg(target_os = "fuchsia")]
110impl From<fidl::Channel> for AudioModeSynchronousProxy {
111    fn from(value: fidl::Channel) -> Self {
112        Self::new(value)
113    }
114}
115
116#[derive(Debug, Clone)]
117pub struct AudioModeProxy {
118    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
119}
120
121impl fidl::endpoints::Proxy for AudioModeProxy {
122    type Protocol = AudioModeMarker;
123
124    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
125        Self::new(inner)
126    }
127
128    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
129        self.client.into_channel().map_err(|client| Self { client })
130    }
131
132    fn as_channel(&self) -> &::fidl::AsyncChannel {
133        self.client.as_channel()
134    }
135}
136
137impl AudioModeProxy {
138    /// Create a new Proxy for fuchsia.bluetooth.a2dp/AudioMode.
139    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
140        let protocol_name = <AudioModeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
141        Self { client: fidl::client::Client::new(channel, protocol_name) }
142    }
143
144    /// Get a Stream of events from the remote end of the protocol.
145    ///
146    /// # Panics
147    ///
148    /// Panics if the event stream was already taken.
149    pub fn take_event_stream(&self) -> AudioModeEventStream {
150        AudioModeEventStream { event_receiver: self.client.take_event_receiver() }
151    }
152
153    /// Switch the device to act as the specified A2DP Role. If the device is already
154    /// set to the requested role, calling this method is a no-op.
155    ///
156    /// When this method returns, a client can depend on the following:
157    /// 1. If the role was switched, the previous profile has requested removal
158    ///    from the hosts' SDP databases, and all L2CAP channels associated with
159    ///    the previous profile have initiated or completed the process of closing.
160    /// 2. The device is in the requested A2DP role.
161    ///
162    /// If the role cannot be set due to an internal error, the server will close
163    /// the channel.
164    pub fn r#set_role(
165        &self,
166        mut role: Role,
167    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
168        AudioModeProxyInterface::r#set_role(self, role)
169    }
170}
171
172impl AudioModeProxyInterface for AudioModeProxy {
173    type SetRoleResponseFut =
174        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
175    fn r#set_role(&self, mut role: Role) -> Self::SetRoleResponseFut {
176        fn _decode(
177            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
178        ) -> Result<(), fidl::Error> {
179            let _response = fidl::client::decode_transaction_body::<
180                fidl::encoding::EmptyPayload,
181                fidl::encoding::DefaultFuchsiaResourceDialect,
182                0x55bc139643a166a6,
183            >(_buf?)?;
184            Ok(_response)
185        }
186        self.client.send_query_and_decode::<AudioModeSetRoleRequest, ()>(
187            (role,),
188            0x55bc139643a166a6,
189            fidl::encoding::DynamicFlags::empty(),
190            _decode,
191        )
192    }
193}
194
195pub struct AudioModeEventStream {
196    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
197}
198
199impl std::marker::Unpin for AudioModeEventStream {}
200
201impl futures::stream::FusedStream for AudioModeEventStream {
202    fn is_terminated(&self) -> bool {
203        self.event_receiver.is_terminated()
204    }
205}
206
207impl futures::Stream for AudioModeEventStream {
208    type Item = Result<AudioModeEvent, fidl::Error>;
209
210    fn poll_next(
211        mut self: std::pin::Pin<&mut Self>,
212        cx: &mut std::task::Context<'_>,
213    ) -> std::task::Poll<Option<Self::Item>> {
214        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
215            &mut self.event_receiver,
216            cx
217        )?) {
218            Some(buf) => std::task::Poll::Ready(Some(AudioModeEvent::decode(buf))),
219            None => std::task::Poll::Ready(None),
220        }
221    }
222}
223
224#[derive(Debug)]
225pub enum AudioModeEvent {}
226
227impl AudioModeEvent {
228    /// Decodes a message buffer as a [`AudioModeEvent`].
229    fn decode(
230        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
231    ) -> Result<AudioModeEvent, fidl::Error> {
232        let (bytes, _handles) = buf.split_mut();
233        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
234        debug_assert_eq!(tx_header.tx_id, 0);
235        match tx_header.ordinal {
236            _ => Err(fidl::Error::UnknownOrdinal {
237                ordinal: tx_header.ordinal,
238                protocol_name: <AudioModeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
239            }),
240        }
241    }
242}
243
244/// A Stream of incoming requests for fuchsia.bluetooth.a2dp/AudioMode.
245pub struct AudioModeRequestStream {
246    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
247    is_terminated: bool,
248}
249
250impl std::marker::Unpin for AudioModeRequestStream {}
251
252impl futures::stream::FusedStream for AudioModeRequestStream {
253    fn is_terminated(&self) -> bool {
254        self.is_terminated
255    }
256}
257
258impl fidl::endpoints::RequestStream for AudioModeRequestStream {
259    type Protocol = AudioModeMarker;
260    type ControlHandle = AudioModeControlHandle;
261
262    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
263        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
264    }
265
266    fn control_handle(&self) -> Self::ControlHandle {
267        AudioModeControlHandle { inner: self.inner.clone() }
268    }
269
270    fn into_inner(
271        self,
272    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
273    {
274        (self.inner, self.is_terminated)
275    }
276
277    fn from_inner(
278        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
279        is_terminated: bool,
280    ) -> Self {
281        Self { inner, is_terminated }
282    }
283}
284
285impl futures::Stream for AudioModeRequestStream {
286    type Item = Result<AudioModeRequest, fidl::Error>;
287
288    fn poll_next(
289        mut self: std::pin::Pin<&mut Self>,
290        cx: &mut std::task::Context<'_>,
291    ) -> std::task::Poll<Option<Self::Item>> {
292        let this = &mut *self;
293        if this.inner.check_shutdown(cx) {
294            this.is_terminated = true;
295            return std::task::Poll::Ready(None);
296        }
297        if this.is_terminated {
298            panic!("polled AudioModeRequestStream after completion");
299        }
300        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
301            |bytes, handles| {
302                match this.inner.channel().read_etc(cx, bytes, handles) {
303                    std::task::Poll::Ready(Ok(())) => {}
304                    std::task::Poll::Pending => return std::task::Poll::Pending,
305                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
306                        this.is_terminated = true;
307                        return std::task::Poll::Ready(None);
308                    }
309                    std::task::Poll::Ready(Err(e)) => {
310                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
311                            e.into(),
312                        ))))
313                    }
314                }
315
316                // A message has been received from the channel
317                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
318
319                std::task::Poll::Ready(Some(match header.ordinal {
320                    0x55bc139643a166a6 => {
321                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
322                        let mut req = fidl::new_empty!(
323                            AudioModeSetRoleRequest,
324                            fidl::encoding::DefaultFuchsiaResourceDialect
325                        );
326                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioModeSetRoleRequest>(&header, _body_bytes, handles, &mut req)?;
327                        let control_handle = AudioModeControlHandle { inner: this.inner.clone() };
328                        Ok(AudioModeRequest::SetRole {
329                            role: req.role,
330
331                            responder: AudioModeSetRoleResponder {
332                                control_handle: std::mem::ManuallyDrop::new(control_handle),
333                                tx_id: header.tx_id,
334                            },
335                        })
336                    }
337                    _ => Err(fidl::Error::UnknownOrdinal {
338                        ordinal: header.ordinal,
339                        protocol_name:
340                            <AudioModeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
341                    }),
342                }))
343            },
344        )
345    }
346}
347
348/// A protocol for specifying which A2DP role this device should operate.
349#[derive(Debug)]
350pub enum AudioModeRequest {
351    /// Switch the device to act as the specified A2DP Role. If the device is already
352    /// set to the requested role, calling this method is a no-op.
353    ///
354    /// When this method returns, a client can depend on the following:
355    /// 1. If the role was switched, the previous profile has requested removal
356    ///    from the hosts' SDP databases, and all L2CAP channels associated with
357    ///    the previous profile have initiated or completed the process of closing.
358    /// 2. The device is in the requested A2DP role.
359    ///
360    /// If the role cannot be set due to an internal error, the server will close
361    /// the channel.
362    SetRole { role: Role, responder: AudioModeSetRoleResponder },
363}
364
365impl AudioModeRequest {
366    #[allow(irrefutable_let_patterns)]
367    pub fn into_set_role(self) -> Option<(Role, AudioModeSetRoleResponder)> {
368        if let AudioModeRequest::SetRole { role, responder } = self {
369            Some((role, responder))
370        } else {
371            None
372        }
373    }
374
375    /// Name of the method defined in FIDL
376    pub fn method_name(&self) -> &'static str {
377        match *self {
378            AudioModeRequest::SetRole { .. } => "set_role",
379        }
380    }
381}
382
383#[derive(Debug, Clone)]
384pub struct AudioModeControlHandle {
385    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
386}
387
388impl fidl::endpoints::ControlHandle for AudioModeControlHandle {
389    fn shutdown(&self) {
390        self.inner.shutdown()
391    }
392    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
393        self.inner.shutdown_with_epitaph(status)
394    }
395
396    fn is_closed(&self) -> bool {
397        self.inner.channel().is_closed()
398    }
399    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
400        self.inner.channel().on_closed()
401    }
402
403    #[cfg(target_os = "fuchsia")]
404    fn signal_peer(
405        &self,
406        clear_mask: zx::Signals,
407        set_mask: zx::Signals,
408    ) -> Result<(), zx_status::Status> {
409        use fidl::Peered;
410        self.inner.channel().signal_peer(clear_mask, set_mask)
411    }
412}
413
414impl AudioModeControlHandle {}
415
416#[must_use = "FIDL methods require a response to be sent"]
417#[derive(Debug)]
418pub struct AudioModeSetRoleResponder {
419    control_handle: std::mem::ManuallyDrop<AudioModeControlHandle>,
420    tx_id: u32,
421}
422
423/// Set the the channel to be shutdown (see [`AudioModeControlHandle::shutdown`])
424/// if the responder is dropped without sending a response, so that the client
425/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
426impl std::ops::Drop for AudioModeSetRoleResponder {
427    fn drop(&mut self) {
428        self.control_handle.shutdown();
429        // Safety: drops once, never accessed again
430        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
431    }
432}
433
434impl fidl::endpoints::Responder for AudioModeSetRoleResponder {
435    type ControlHandle = AudioModeControlHandle;
436
437    fn control_handle(&self) -> &AudioModeControlHandle {
438        &self.control_handle
439    }
440
441    fn drop_without_shutdown(mut self) {
442        // Safety: drops once, never accessed again due to mem::forget
443        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
444        // Prevent Drop from running (which would shut down the channel)
445        std::mem::forget(self);
446    }
447}
448
449impl AudioModeSetRoleResponder {
450    /// Sends a response to the FIDL transaction.
451    ///
452    /// Sets the channel to shutdown if an error occurs.
453    pub fn send(self) -> Result<(), fidl::Error> {
454        let _result = self.send_raw();
455        if _result.is_err() {
456            self.control_handle.shutdown();
457        }
458        self.drop_without_shutdown();
459        _result
460    }
461
462    /// Similar to "send" but does not shutdown the channel if an error occurs.
463    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
464        let _result = self.send_raw();
465        self.drop_without_shutdown();
466        _result
467    }
468
469    fn send_raw(&self) -> Result<(), fidl::Error> {
470        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
471            (),
472            self.tx_id,
473            0x55bc139643a166a6,
474            fidl::encoding::DynamicFlags::empty(),
475        )
476    }
477}
478
479mod internal {
480    use super::*;
481}
fidl_fuchsia_bluetooth_a2dp/fidl_fuchsia_bluetooth_a2dp.rs

fidl_fuchsia_bluetooth_a2dp/
fidl_fuchsia_bluetooth_a2dp.rs
