fidl_fuchsia_virtualaudio/

fidl_fuchsia_virtualaudio.rs

// WARNING: This file is machine generated by fidlgen.

#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]

use bitflags::bitflags;
use fidl::client::QueryResponseFut;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use fidl::endpoints::{ControlHandle as _, Responder as _};
pub use fidl_fuchsia_virtualaudio_common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

#[derive(Debug, PartialEq)]
pub struct ControlAddDeviceRequest {
    pub config: Configuration,
    pub server: fidl::endpoints::ServerEnd<DeviceMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ControlAddDeviceRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceOnBufferCreatedRequest {
    pub ring_buffer: fidl::Vmo,
    pub num_ring_buffer_frames: u32,
    pub notifications_per_ring: u32,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for DeviceOnBufferCreatedRequest
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceGetBufferResponse {
    pub ring_buffer: fidl::Vmo,
    pub num_ring_buffer_frames: u32,
    pub notifications_per_ring: u32,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for DeviceGetBufferResponse {}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ControlMarker;

impl fidl::endpoints::ProtocolMarker for ControlMarker {
    type Proxy = ControlProxy;
    type RequestStream = ControlRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ControlSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Control";
}
pub type ControlGetDefaultConfigurationResult = Result<Configuration, Error>;
pub type ControlAddDeviceResult = Result<(), Error>;

pub trait ControlProxyInterface: Send + Sync {
    type GetDefaultConfigurationResponseFut: std::future::Future<Output = Result<ControlGetDefaultConfigurationResult, fidl::Error>>
        + Send;
    fn r#get_default_configuration(
        &self,
        type_: DeviceType,
        direction: &Direction,
    ) -> Self::GetDefaultConfigurationResponseFut;
    type AddDeviceResponseFut: std::future::Future<Output = Result<ControlAddDeviceResult, fidl::Error>>
        + Send;
    fn r#add_device(
        &self,
        config: &Configuration,
        server: fidl::endpoints::ServerEnd<DeviceMarker>,
    ) -> Self::AddDeviceResponseFut;
    type GetNumDevicesResponseFut: std::future::Future<Output = Result<(u32, u32, u32), fidl::Error>>
        + Send;
    fn r#get_num_devices(&self) -> Self::GetNumDevicesResponseFut;
    type RemoveAllResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#remove_all(&self) -> Self::RemoveAllResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ControlSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ControlSynchronousProxy {
    type Proxy = ControlProxy;
    type Protocol = ControlMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl ControlSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<ControlEvent, fidl::Error> {
        ControlEvent::decode(self.client.wait_for_event::<ControlMarker>(deadline)?)
    }

    /// Returns the default configuration for the given device type and direction.
    pub fn r#get_default_configuration(
        &self,
        mut type_: DeviceType,
        mut direction: &Direction,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControlGetDefaultConfigurationResult, fidl::Error> {
        let _response = self.client.send_query::<
            ControlGetDefaultConfigurationRequest,
            fidl::encoding::ResultType<ControlGetDefaultConfigurationResponse, Error>,
            ControlMarker,
        >(
            (type_, direction,),
            0x18fbd1298daa19e9,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.config))
    }

    /// Adds a device to the device tree.
    /// The device lives until the `Device` FIDL channel is closed.
    pub fn r#add_device(
        &self,
        mut config: &Configuration,
        mut server: fidl::endpoints::ServerEnd<DeviceMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControlAddDeviceResult, fidl::Error> {
        let _response = self.client.send_query::<
            ControlAddDeviceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
            ControlMarker,
        >(
            (config, server,),
            0x6b5fff2f3ed7ce9,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Returns the number of active input and output devices and devices with unspecified
    /// direction.
    pub fn r#get_num_devices(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(u32, u32, u32), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            ControlGetNumDevicesResponse,
            ControlMarker,
        >(
            (),
            0x256704ce2f8097af,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((
            _response.num_input_devices,
            _response.num_output_devices,
            _response.num_unspecified_direction_devices,
        ))
    }

    /// Synchronously remove all all active input and output devices.
    pub fn r#remove_all(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::EmptyPayload,
            ControlMarker,
        >(
            (),
            0x7904287969087c4b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

#[cfg(target_os = "fuchsia")]
impl From<ControlSynchronousProxy> for zx::NullableHandle {
    fn from(value: ControlSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for ControlSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for ControlSynchronousProxy {
    type Protocol = ControlMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<ControlMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct ControlProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for ControlProxy {
    type Protocol = ControlMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl ControlProxy {
    /// Create a new Proxy for fuchsia.virtualaudio/Control.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> ControlEventStream {
        ControlEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns the default configuration for the given device type and direction.
    pub fn r#get_default_configuration(
        &self,
        mut type_: DeviceType,
        mut direction: &Direction,
    ) -> fidl::client::QueryResponseFut<
        ControlGetDefaultConfigurationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControlProxyInterface::r#get_default_configuration(self, type_, direction)
    }

    /// Adds a device to the device tree.
    /// The device lives until the `Device` FIDL channel is closed.
    pub fn r#add_device(
        &self,
        mut config: &Configuration,
        mut server: fidl::endpoints::ServerEnd<DeviceMarker>,
    ) -> fidl::client::QueryResponseFut<
        ControlAddDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControlProxyInterface::r#add_device(self, config, server)
    }

    /// Returns the number of active input and output devices and devices with unspecified
    /// direction.
    pub fn r#get_num_devices(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (u32, u32, u32),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControlProxyInterface::r#get_num_devices(self)
    }

    /// Synchronously remove all all active input and output devices.
    pub fn r#remove_all(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        ControlProxyInterface::r#remove_all(self)
    }
}

impl ControlProxyInterface for ControlProxy {
    type GetDefaultConfigurationResponseFut = fidl::client::QueryResponseFut<
        ControlGetDefaultConfigurationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_default_configuration(
        &self,
        mut type_: DeviceType,
        mut direction: &Direction,
    ) -> Self::GetDefaultConfigurationResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControlGetDefaultConfigurationResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ControlGetDefaultConfigurationResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x18fbd1298daa19e9,
            >(_buf?)?;
            Ok(_response.map(|x| x.config))
        }
        self.client.send_query_and_decode::<
            ControlGetDefaultConfigurationRequest,
            ControlGetDefaultConfigurationResult,
        >(
            (type_, direction,),
            0x18fbd1298daa19e9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddDeviceResponseFut = fidl::client::QueryResponseFut<
        ControlAddDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_device(
        &self,
        mut config: &Configuration,
        mut server: fidl::endpoints::ServerEnd<DeviceMarker>,
    ) -> Self::AddDeviceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControlAddDeviceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6b5fff2f3ed7ce9,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<ControlAddDeviceRequest, ControlAddDeviceResult>(
            (config, server),
            0x6b5fff2f3ed7ce9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetNumDevicesResponseFut = fidl::client::QueryResponseFut<
        (u32, u32, u32),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_num_devices(&self) -> Self::GetNumDevicesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(u32, u32, u32), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ControlGetNumDevicesResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x256704ce2f8097af,
            >(_buf?)?;
            Ok((
                _response.num_input_devices,
                _response.num_output_devices,
                _response.num_unspecified_direction_devices,
            ))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (u32, u32, u32)>(
            (),
            0x256704ce2f8097af,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RemoveAllResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#remove_all(&self) -> Self::RemoveAllResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7904287969087c4b,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x7904287969087c4b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct ControlEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for ControlEventStream {}

impl futures::stream::FusedStream for ControlEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for ControlEventStream {
    type Item = Result<ControlEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(ControlEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum ControlEvent {}

impl ControlEvent {
    /// Decodes a message buffer as a [`ControlEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ControlEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <ControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.virtualaudio/Control.
pub struct ControlRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for ControlRequestStream {}

impl futures::stream::FusedStream for ControlRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for ControlRequestStream {
    type Protocol = ControlMarker;
    type ControlHandle = ControlControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        ControlControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for ControlRequestStream {
    type Item = Result<ControlRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled ControlRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x18fbd1298daa19e9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControlGetDefaultConfigurationRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ControlGetDefaultConfigurationRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControlControlHandle { inner: this.inner.clone() };
                        Ok(ControlRequest::GetDefaultConfiguration {
                            type_: req.type_,
                            direction: req.direction,

                            responder: ControlGetDefaultConfigurationResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6b5fff2f3ed7ce9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControlAddDeviceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ControlAddDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControlControlHandle { inner: this.inner.clone() };
                        Ok(ControlRequest::AddDevice {
                            config: req.config,
                            server: req.server,

                            responder: ControlAddDeviceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x256704ce2f8097af => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControlControlHandle { inner: this.inner.clone() };
                        Ok(ControlRequest::GetNumDevices {
                            responder: ControlGetNumDevicesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7904287969087c4b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControlControlHandle { inner: this.inner.clone() };
                        Ok(ControlRequest::RemoveAll {
                            responder: ControlRemoveAllResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// This protocol provides methods for adding and removing virtual audio
/// devices. This protocol is made available through the device tree via
/// `CONTROL_NODE_NAME` and `LEGACY_CONTROL_NODE_NAME`.
#[derive(Debug)]
pub enum ControlRequest {
    /// Returns the default configuration for the given device type and direction.
    GetDefaultConfiguration {
        type_: DeviceType,
        direction: Direction,
        responder: ControlGetDefaultConfigurationResponder,
    },
    /// Adds a device to the device tree.
    /// The device lives until the `Device` FIDL channel is closed.
    AddDevice {
        config: Configuration,
        server: fidl::endpoints::ServerEnd<DeviceMarker>,
        responder: ControlAddDeviceResponder,
    },
    /// Returns the number of active input and output devices and devices with unspecified
    /// direction.
    GetNumDevices { responder: ControlGetNumDevicesResponder },
    /// Synchronously remove all all active input and output devices.
    RemoveAll { responder: ControlRemoveAllResponder },
}

impl ControlRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_default_configuration(
        self,
    ) -> Option<(DeviceType, Direction, ControlGetDefaultConfigurationResponder)> {
        if let ControlRequest::GetDefaultConfiguration { type_, direction, responder } = self {
            Some((type_, direction, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_device(
        self,
    ) -> Option<(Configuration, fidl::endpoints::ServerEnd<DeviceMarker>, ControlAddDeviceResponder)>
    {
        if let ControlRequest::AddDevice { config, server, responder } = self {
            Some((config, server, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_num_devices(self) -> Option<(ControlGetNumDevicesResponder)> {
        if let ControlRequest::GetNumDevices { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_all(self) -> Option<(ControlRemoveAllResponder)> {
        if let ControlRequest::RemoveAll { responder } = self { Some((responder)) } else { None }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ControlRequest::GetDefaultConfiguration { .. } => "get_default_configuration",
            ControlRequest::AddDevice { .. } => "add_device",
            ControlRequest::GetNumDevices { .. } => "get_num_devices",
            ControlRequest::RemoveAll { .. } => "remove_all",
        }
    }
}

#[derive(Debug, Clone)]
pub struct ControlControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl ControlControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

impl fidl::endpoints::ControlHandle for ControlControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl ControlControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ControlGetDefaultConfigurationResponder {
    control_handle: std::mem::ManuallyDrop<ControlControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`ControlControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for ControlGetDefaultConfigurationResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ControlGetDefaultConfigurationResponder {
    type ControlHandle = ControlControlHandle;

    fn control_handle(&self) -> &ControlControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl ControlGetDefaultConfigurationResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<&Configuration, Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&Configuration, Error>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<&Configuration, Error>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            ControlGetDefaultConfigurationResponse,
            Error,
        >>(
            result.map(|config| (config,)),
            self.tx_id,
            0x18fbd1298daa19e9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ControlAddDeviceResponder {
    control_handle: std::mem::ManuallyDrop<ControlControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`ControlControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for ControlAddDeviceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ControlAddDeviceResponder {
    type ControlHandle = ControlControlHandle;

    fn control_handle(&self) -> &ControlControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl ControlAddDeviceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>>(
                result,
                self.tx_id,
                0x6b5fff2f3ed7ce9,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ControlGetNumDevicesResponder {
    control_handle: std::mem::ManuallyDrop<ControlControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`ControlControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for ControlGetNumDevicesResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ControlGetNumDevicesResponder {
    type ControlHandle = ControlControlHandle;

    fn control_handle(&self) -> &ControlControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl ControlGetNumDevicesResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut num_input_devices: u32,
        mut num_output_devices: u32,
        mut num_unspecified_direction_devices: u32,
    ) -> Result<(), fidl::Error> {
        let _result =
            self.send_raw(num_input_devices, num_output_devices, num_unspecified_direction_devices);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut num_input_devices: u32,
        mut num_output_devices: u32,
        mut num_unspecified_direction_devices: u32,
    ) -> Result<(), fidl::Error> {
        let _result =
            self.send_raw(num_input_devices, num_output_devices, num_unspecified_direction_devices);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut num_input_devices: u32,
        mut num_output_devices: u32,
        mut num_unspecified_direction_devices: u32,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ControlGetNumDevicesResponse>(
            (num_input_devices, num_output_devices, num_unspecified_direction_devices),
            self.tx_id,
            0x256704ce2f8097af,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ControlRemoveAllResponder {
    control_handle: std::mem::ManuallyDrop<ControlControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`ControlControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for ControlRemoveAllResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ControlRemoveAllResponder {
    type ControlHandle = ControlControlHandle;

    fn control_handle(&self) -> &ControlControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl ControlRemoveAllResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x7904287969087c4b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct DeviceMarker;

impl fidl::endpoints::ProtocolMarker for DeviceMarker {
    type Proxy = DeviceProxy;
    type RequestStream = DeviceRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DeviceSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Device";
}
pub type DeviceGetFormatResult = Result<(u32, u32, u32, i64), Error>;
pub type DeviceGetGainResult = Result<(bool, bool, f32), Error>;
pub type DeviceGetBufferResult = Result<(fidl::Vmo, u32, u32), Error>;
pub type DeviceSetNotificationFrequencyResult = Result<(), Error>;
pub type DeviceGetPositionResult = Result<(i64, u32), Error>;
pub type DeviceChangePlugStateResult = Result<(), Error>;
pub type DeviceAdjustClockRateResult = Result<(), Error>;

pub trait DeviceProxyInterface: Send + Sync {
    type GetFormatResponseFut: std::future::Future<Output = Result<DeviceGetFormatResult, fidl::Error>>
        + Send;
    fn r#get_format(&self) -> Self::GetFormatResponseFut;
    type GetGainResponseFut: std::future::Future<Output = Result<DeviceGetGainResult, fidl::Error>>
        + Send;
    fn r#get_gain(&self) -> Self::GetGainResponseFut;
    type GetBufferResponseFut: std::future::Future<Output = Result<DeviceGetBufferResult, fidl::Error>>
        + Send;
    fn r#get_buffer(&self) -> Self::GetBufferResponseFut;
    type SetNotificationFrequencyResponseFut: std::future::Future<Output = Result<DeviceSetNotificationFrequencyResult, fidl::Error>>
        + Send;
    fn r#set_notification_frequency(
        &self,
        notifications_per_ring: u32,
    ) -> Self::SetNotificationFrequencyResponseFut;
    type GetPositionResponseFut: std::future::Future<Output = Result<DeviceGetPositionResult, fidl::Error>>
        + Send;
    fn r#get_position(&self) -> Self::GetPositionResponseFut;
    type ChangePlugStateResponseFut: std::future::Future<Output = Result<DeviceChangePlugStateResult, fidl::Error>>
        + Send;
    fn r#change_plug_state(
        &self,
        plug_change_time: i64,
        plugged: bool,
    ) -> Self::ChangePlugStateResponseFut;
    type AdjustClockRateResponseFut: std::future::Future<Output = Result<DeviceAdjustClockRateResult, fidl::Error>>
        + Send;
    fn r#adjust_clock_rate(&self, ppm_from_monotonic: i32) -> Self::AdjustClockRateResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DeviceSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DeviceSynchronousProxy {
    type Proxy = DeviceProxy;
    type Protocol = DeviceMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl DeviceSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<DeviceEvent, fidl::Error> {
        DeviceEvent::decode(self.client.wait_for_event::<DeviceMarker>(deadline)?)
    }

    /// Returns the format selected by the client, or `NO_RING_BUFFER` if the
    /// client has not yet selected a ring buffer format.
    pub fn r#get_format(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceGetFormatResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<DeviceGetFormatResponse, Error>,
            DeviceMarker,
        >(
            (),
            0x6107d32083bacc1b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response
            .map(|x| (x.frames_per_second, x.sample_format, x.num_channels, x.external_delay)))
    }

    /// Returns the current gain state for this device.
    pub fn r#get_gain(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceGetGainResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<DeviceGetGainResponse, Error>,
            DeviceMarker,
        >(
            (),
            0x6d85d82b49fb28e9,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| (x.current_mute, x.current_agc, x.current_gain_db)))
    }

    /// Returns details about the ring buffer. Returns `NO_RING_BUFFER` if the
    /// client has not yet created the ring buffer.
    pub fn r#get_buffer(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceGetBufferResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<DeviceGetBufferResponse, Error>,
            DeviceMarker,
        >(
            (),
            0x38e202be0db060d0,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| (x.ring_buffer, x.num_ring_buffer_frames, x.notifications_per_ring)))
    }

    /// Overrides the position notification frequency for this stream.
    /// This affects the frequency of `OnPositionNotify` events only. It does
    /// not affect the frequency of notification events sent through the audio
    /// driver APIs.
    pub fn r#set_notification_frequency(
        &self,
        mut notifications_per_ring: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceSetNotificationFrequencyResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceSetNotificationFrequencyRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
            DeviceMarker,
        >(
            (notifications_per_ring,),
            0x45789b88ca9185b8,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Returns the current position (in bytes) within the ring buffer, along
    /// with the time (per MONOTONIC clock) that corresponds with that position.
    /// This can only be called after the ring buffer is established. Returns
    /// `NOT_STARTED` if the device has not yet Started streaming.
    pub fn r#get_position(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceGetPositionResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<DeviceGetPositionResponse, Error>,
            DeviceMarker,
        >(
            (),
            0x6fe5bbf9065258e8,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| (x.monotonic_time, x.ring_position)))
    }

    /// Hot-plugs or hot-unplugs an active virtual device, at the specified
    /// time.
    pub fn r#change_plug_state(
        &self,
        mut plug_change_time: i64,
        mut plugged: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceChangePlugStateResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceChangePlugStateRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
            DeviceMarker,
        >(
            (plug_change_time, plugged,),
            0x61aa2d370caaf8f0,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Immediately change the virtual device's clock rate, as expressed in the
    /// timing and content of position notifications the driver emits.
    /// 'ppm_monotonic' cannot exceed [-1000,+1000]. Each rate change in rate is
    /// standalone; i.e. successive rate changes are not cumulative.
    pub fn r#adjust_clock_rate(
        &self,
        mut ppm_from_monotonic: i32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceAdjustClockRateResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceAdjustClockRateRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
            DeviceMarker,
        >(
            (ppm_from_monotonic,),
            0x754661f655350134,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

#[cfg(target_os = "fuchsia")]
impl From<DeviceSynchronousProxy> for zx::NullableHandle {
    fn from(value: DeviceSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for DeviceSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for DeviceSynchronousProxy {
    type Protocol = DeviceMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<DeviceMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct DeviceProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for DeviceProxy {
    type Protocol = DeviceMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl DeviceProxy {
    /// Create a new Proxy for fuchsia.virtualaudio/Device.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> DeviceEventStream {
        DeviceEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns the format selected by the client, or `NO_RING_BUFFER` if the
    /// client has not yet selected a ring buffer format.
    pub fn r#get_format(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DeviceGetFormatResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#get_format(self)
    }

    /// Returns the current gain state for this device.
    pub fn r#get_gain(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DeviceGetGainResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#get_gain(self)
    }

    /// Returns details about the ring buffer. Returns `NO_RING_BUFFER` if the
    /// client has not yet created the ring buffer.
    pub fn r#get_buffer(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DeviceGetBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#get_buffer(self)
    }

    /// Overrides the position notification frequency for this stream.
    /// This affects the frequency of `OnPositionNotify` events only. It does
    /// not affect the frequency of notification events sent through the audio
    /// driver APIs.
    pub fn r#set_notification_frequency(
        &self,
        mut notifications_per_ring: u32,
    ) -> fidl::client::QueryResponseFut<
        DeviceSetNotificationFrequencyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#set_notification_frequency(self, notifications_per_ring)
    }

    /// Returns the current position (in bytes) within the ring buffer, along
    /// with the time (per MONOTONIC clock) that corresponds with that position.
    /// This can only be called after the ring buffer is established. Returns
    /// `NOT_STARTED` if the device has not yet Started streaming.
    pub fn r#get_position(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DeviceGetPositionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#get_position(self)
    }

    /// Hot-plugs or hot-unplugs an active virtual device, at the specified
    /// time.
    pub fn r#change_plug_state(
        &self,
        mut plug_change_time: i64,
        mut plugged: bool,
    ) -> fidl::client::QueryResponseFut<
        DeviceChangePlugStateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#change_plug_state(self, plug_change_time, plugged)
    }

    /// Immediately change the virtual device's clock rate, as expressed in the
    /// timing and content of position notifications the driver emits.
    /// 'ppm_monotonic' cannot exceed [-1000,+1000]. Each rate change in rate is
    /// standalone; i.e. successive rate changes are not cumulative.
    pub fn r#adjust_clock_rate(
        &self,
        mut ppm_from_monotonic: i32,
    ) -> fidl::client::QueryResponseFut<
        DeviceAdjustClockRateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#adjust_clock_rate(self, ppm_from_monotonic)
    }
}

impl DeviceProxyInterface for DeviceProxy {
    type GetFormatResponseFut = fidl::client::QueryResponseFut<
        DeviceGetFormatResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_format(&self) -> Self::GetFormatResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceGetFormatResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceGetFormatResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6107d32083bacc1b,
            >(_buf?)?;
            Ok(_response
                .map(|x| (x.frames_per_second, x.sample_format, x.num_channels, x.external_delay)))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, DeviceGetFormatResult>(
            (),
            0x6107d32083bacc1b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetGainResponseFut = fidl::client::QueryResponseFut<
        DeviceGetGainResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_gain(&self) -> Self::GetGainResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceGetGainResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceGetGainResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6d85d82b49fb28e9,
            >(_buf?)?;
            Ok(_response.map(|x| (x.current_mute, x.current_agc, x.current_gain_db)))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, DeviceGetGainResult>(
            (),
            0x6d85d82b49fb28e9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetBufferResponseFut = fidl::client::QueryResponseFut<
        DeviceGetBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_buffer(&self) -> Self::GetBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceGetBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceGetBufferResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x38e202be0db060d0,
            >(_buf?)?;
            Ok(_response
                .map(|x| (x.ring_buffer, x.num_ring_buffer_frames, x.notifications_per_ring)))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, DeviceGetBufferResult>(
            (),
            0x38e202be0db060d0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetNotificationFrequencyResponseFut = fidl::client::QueryResponseFut<
        DeviceSetNotificationFrequencyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_notification_frequency(
        &self,
        mut notifications_per_ring: u32,
    ) -> Self::SetNotificationFrequencyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceSetNotificationFrequencyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x45789b88ca9185b8,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            DeviceSetNotificationFrequencyRequest,
            DeviceSetNotificationFrequencyResult,
        >(
            (notifications_per_ring,),
            0x45789b88ca9185b8,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetPositionResponseFut = fidl::client::QueryResponseFut<
        DeviceGetPositionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_position(&self) -> Self::GetPositionResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceGetPositionResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceGetPositionResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6fe5bbf9065258e8,
            >(_buf?)?;
            Ok(_response.map(|x| (x.monotonic_time, x.ring_position)))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, DeviceGetPositionResult>(
            (),
            0x6fe5bbf9065258e8,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ChangePlugStateResponseFut = fidl::client::QueryResponseFut<
        DeviceChangePlugStateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#change_plug_state(
        &self,
        mut plug_change_time: i64,
        mut plugged: bool,
    ) -> Self::ChangePlugStateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceChangePlugStateResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x61aa2d370caaf8f0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<DeviceChangePlugStateRequest, DeviceChangePlugStateResult>(
                (plug_change_time, plugged),
                0x61aa2d370caaf8f0,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type AdjustClockRateResponseFut = fidl::client::QueryResponseFut<
        DeviceAdjustClockRateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#adjust_clock_rate(&self, mut ppm_from_monotonic: i32) -> Self::AdjustClockRateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceAdjustClockRateResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x754661f655350134,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<DeviceAdjustClockRateRequest, DeviceAdjustClockRateResult>(
                (ppm_from_monotonic,),
                0x754661f655350134,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

pub struct DeviceEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for DeviceEventStream {}

impl futures::stream::FusedStream for DeviceEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for DeviceEventStream {
    type Item = Result<DeviceEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(DeviceEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum DeviceEvent {
    OnSetFormat {
        frames_per_second: u32,
        sample_format: u32,
        num_channels: u32,
        external_delay: i64,
    },
    OnSetGain {
        current_mute: bool,
        current_agc: bool,
        current_gain_db: f32,
    },
    OnBufferCreated {
        ring_buffer: fidl::Vmo,
        num_ring_buffer_frames: u32,
        notifications_per_ring: u32,
    },
    OnStart {
        start_time: i64,
    },
    OnStop {
        stop_time: i64,
        ring_position: u32,
    },
    OnPositionNotify {
        monotonic_time: i64,
        ring_position: u32,
    },
}

impl DeviceEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_set_format(self) -> Option<(u32, u32, u32, i64)> {
        if let DeviceEvent::OnSetFormat {
            frames_per_second,
            sample_format,
            num_channels,
            external_delay,
        } = self
        {
            Some((frames_per_second, sample_format, num_channels, external_delay))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_set_gain(self) -> Option<(bool, bool, f32)> {
        if let DeviceEvent::OnSetGain { current_mute, current_agc, current_gain_db } = self {
            Some((current_mute, current_agc, current_gain_db))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_buffer_created(self) -> Option<(fidl::Vmo, u32, u32)> {
        if let DeviceEvent::OnBufferCreated {
            ring_buffer,
            num_ring_buffer_frames,
            notifications_per_ring,
        } = self
        {
            Some((ring_buffer, num_ring_buffer_frames, notifications_per_ring))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_start(self) -> Option<i64> {
        if let DeviceEvent::OnStart { start_time } = self { Some((start_time)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_stop(self) -> Option<(i64, u32)> {
        if let DeviceEvent::OnStop { stop_time, ring_position } = self {
            Some((stop_time, ring_position))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_position_notify(self) -> Option<(i64, u32)> {
        if let DeviceEvent::OnPositionNotify { monotonic_time, ring_position } = self {
            Some((monotonic_time, ring_position))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`DeviceEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<DeviceEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            0x2a547759ab3678b2 => {
                let mut out = fidl::new_empty!(
                    DeviceOnSetFormatRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceOnSetFormatRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((DeviceEvent::OnSetFormat {
                    frames_per_second: out.frames_per_second,
                    sample_format: out.sample_format,
                    num_channels: out.num_channels,
                    external_delay: out.external_delay,
                }))
            }
            0x31fffec81b3a9393 => {
                let mut out = fidl::new_empty!(
                    DeviceOnSetGainRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceOnSetGainRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((DeviceEvent::OnSetGain {
                    current_mute: out.current_mute,
                    current_agc: out.current_agc,
                    current_gain_db: out.current_gain_db,
                }))
            }
            0x5c2eb72e264afefd => {
                let mut out = fidl::new_empty!(
                    DeviceOnBufferCreatedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceOnBufferCreatedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((DeviceEvent::OnBufferCreated {
                    ring_buffer: out.ring_buffer,
                    num_ring_buffer_frames: out.num_ring_buffer_frames,
                    notifications_per_ring: out.notifications_per_ring,
                }))
            }
            0x498f0b7e64d7ca58 => {
                let mut out = fidl::new_empty!(
                    DeviceOnStartRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceOnStartRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((DeviceEvent::OnStart { start_time: out.start_time }))
            }
            0x6f5d4d2fe223ae5b => {
                let mut out = fidl::new_empty!(
                    DeviceOnStopRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceOnStopRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((DeviceEvent::OnStop {
                    stop_time: out.stop_time,
                    ring_position: out.ring_position,
                }))
            }
            0x79274c4de9013585 => {
                let mut out = fidl::new_empty!(
                    DeviceOnPositionNotifyRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceOnPositionNotifyRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((DeviceEvent::OnPositionNotify {
                    monotonic_time: out.monotonic_time,
                    ring_position: out.ring_position,
                }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.virtualaudio/Device.
pub struct DeviceRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for DeviceRequestStream {}

impl futures::stream::FusedStream for DeviceRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for DeviceRequestStream {
    type Protocol = DeviceMarker;
    type ControlHandle = DeviceControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        DeviceControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for DeviceRequestStream {
    type Item = Result<DeviceRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled DeviceRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x6107d32083bacc1b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetFormat {
                            responder: DeviceGetFormatResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6d85d82b49fb28e9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetGain {
                            responder: DeviceGetGainResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x38e202be0db060d0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetBuffer {
                            responder: DeviceGetBufferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x45789b88ca9185b8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceSetNotificationFrequencyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceSetNotificationFrequencyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::SetNotificationFrequency {
                            notifications_per_ring: req.notifications_per_ring,

                            responder: DeviceSetNotificationFrequencyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6fe5bbf9065258e8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetPosition {
                            responder: DeviceGetPositionResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x61aa2d370caaf8f0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceChangePlugStateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceChangePlugStateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::ChangePlugState {
                            plug_change_time: req.plug_change_time,
                            plugged: req.plugged,

                            responder: DeviceChangePlugStateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x754661f655350134 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceAdjustClockRateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceAdjustClockRateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::AdjustClockRate {
                            ppm_from_monotonic: req.ppm_from_monotonic,

                            responder: DeviceAdjustClockRateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// This protocol represents the base functionality of active audio devices. A
/// device is active until this protocol is closed, at which point the device is
/// automatically removed.
#[derive(Debug)]
pub enum DeviceRequest {
    /// Returns the format selected by the client, or `NO_RING_BUFFER` if the
    /// client has not yet selected a ring buffer format.
    GetFormat { responder: DeviceGetFormatResponder },
    /// Returns the current gain state for this device.
    GetGain { responder: DeviceGetGainResponder },
    /// Returns details about the ring buffer. Returns `NO_RING_BUFFER` if the
    /// client has not yet created the ring buffer.
    GetBuffer { responder: DeviceGetBufferResponder },
    /// Overrides the position notification frequency for this stream.
    /// This affects the frequency of `OnPositionNotify` events only. It does
    /// not affect the frequency of notification events sent through the audio
    /// driver APIs.
    SetNotificationFrequency {
        notifications_per_ring: u32,
        responder: DeviceSetNotificationFrequencyResponder,
    },
    /// Returns the current position (in bytes) within the ring buffer, along
    /// with the time (per MONOTONIC clock) that corresponds with that position.
    /// This can only be called after the ring buffer is established. Returns
    /// `NOT_STARTED` if the device has not yet Started streaming.
    GetPosition { responder: DeviceGetPositionResponder },
    /// Hot-plugs or hot-unplugs an active virtual device, at the specified
    /// time.
    ChangePlugState {
        plug_change_time: i64,
        plugged: bool,
        responder: DeviceChangePlugStateResponder,
    },
    /// Immediately change the virtual device's clock rate, as expressed in the
    /// timing and content of position notifications the driver emits.
    /// 'ppm_monotonic' cannot exceed [-1000,+1000]. Each rate change in rate is
    /// standalone; i.e. successive rate changes are not cumulative.
    AdjustClockRate { ppm_from_monotonic: i32, responder: DeviceAdjustClockRateResponder },
}

impl DeviceRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_format(self) -> Option<(DeviceGetFormatResponder)> {
        if let DeviceRequest::GetFormat { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_gain(self) -> Option<(DeviceGetGainResponder)> {
        if let DeviceRequest::GetGain { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_buffer(self) -> Option<(DeviceGetBufferResponder)> {
        if let DeviceRequest::GetBuffer { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_notification_frequency(
        self,
    ) -> Option<(u32, DeviceSetNotificationFrequencyResponder)> {
        if let DeviceRequest::SetNotificationFrequency { notifications_per_ring, responder } = self
        {
            Some((notifications_per_ring, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_position(self) -> Option<(DeviceGetPositionResponder)> {
        if let DeviceRequest::GetPosition { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_change_plug_state(self) -> Option<(i64, bool, DeviceChangePlugStateResponder)> {
        if let DeviceRequest::ChangePlugState { plug_change_time, plugged, responder } = self {
            Some((plug_change_time, plugged, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_adjust_clock_rate(self) -> Option<(i32, DeviceAdjustClockRateResponder)> {
        if let DeviceRequest::AdjustClockRate { ppm_from_monotonic, responder } = self {
            Some((ppm_from_monotonic, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DeviceRequest::GetFormat { .. } => "get_format",
            DeviceRequest::GetGain { .. } => "get_gain",
            DeviceRequest::GetBuffer { .. } => "get_buffer",
            DeviceRequest::SetNotificationFrequency { .. } => "set_notification_frequency",
            DeviceRequest::GetPosition { .. } => "get_position",
            DeviceRequest::ChangePlugState { .. } => "change_plug_state",
            DeviceRequest::AdjustClockRate { .. } => "adjust_clock_rate",
        }
    }
}

#[derive(Debug, Clone)]
pub struct DeviceControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl DeviceControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

impl fidl::endpoints::ControlHandle for DeviceControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl DeviceControlHandle {
    pub fn send_on_set_format(
        &self,
        mut frames_per_second: u32,
        mut sample_format: u32,
        mut num_channels: u32,
        mut external_delay: i64,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<DeviceOnSetFormatRequest>(
            (frames_per_second, sample_format, num_channels, external_delay),
            0,
            0x2a547759ab3678b2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_set_gain(
        &self,
        mut current_mute: bool,
        mut current_agc: bool,
        mut current_gain_db: f32,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<DeviceOnSetGainRequest>(
            (current_mute, current_agc, current_gain_db),
            0,
            0x31fffec81b3a9393,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_buffer_created(
        &self,
        mut ring_buffer: fidl::Vmo,
        mut num_ring_buffer_frames: u32,
        mut notifications_per_ring: u32,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<DeviceOnBufferCreatedRequest>(
            (ring_buffer, num_ring_buffer_frames, notifications_per_ring),
            0,
            0x5c2eb72e264afefd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_start(&self, mut start_time: i64) -> Result<(), fidl::Error> {
        self.inner.send::<DeviceOnStartRequest>(
            (start_time,),
            0,
            0x498f0b7e64d7ca58,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_stop(
        &self,
        mut stop_time: i64,
        mut ring_position: u32,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<DeviceOnStopRequest>(
            (stop_time, ring_position),
            0,
            0x6f5d4d2fe223ae5b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_position_notify(
        &self,
        mut monotonic_time: i64,
        mut ring_position: u32,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<DeviceOnPositionNotifyRequest>(
            (monotonic_time, ring_position),
            0,
            0x79274c4de9013585,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceGetFormatResponder {
    control_handle: std::mem::ManuallyDrop<DeviceControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DeviceControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DeviceGetFormatResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DeviceGetFormatResponder {
    type ControlHandle = DeviceControlHandle;

    fn control_handle(&self) -> &DeviceControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DeviceGetFormatResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(u32, u32, u32, i64), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(u32, u32, u32, i64), Error>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(u32, u32, u32, i64), Error>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<DeviceGetFormatResponse, Error>>(
                result,
                self.tx_id,
                0x6107d32083bacc1b,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceGetGainResponder {
    control_handle: std::mem::ManuallyDrop<DeviceControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DeviceControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DeviceGetGainResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DeviceGetGainResponder {
    type ControlHandle = DeviceControlHandle;

    fn control_handle(&self) -> &DeviceControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DeviceGetGainResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(bool, bool, f32), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(bool, bool, f32), Error>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(bool, bool, f32), Error>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<DeviceGetGainResponse, Error>>(
            result,
            self.tx_id,
            0x6d85d82b49fb28e9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceGetBufferResponder {
    control_handle: std::mem::ManuallyDrop<DeviceControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DeviceControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DeviceGetBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DeviceGetBufferResponder {
    type ControlHandle = DeviceControlHandle;

    fn control_handle(&self) -> &DeviceControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DeviceGetBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(fidl::Vmo, u32, u32), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(fidl::Vmo, u32, u32), Error>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(fidl::Vmo, u32, u32), Error>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<DeviceGetBufferResponse, Error>>(
                result,
                self.tx_id,
                0x38e202be0db060d0,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceSetNotificationFrequencyResponder {
    control_handle: std::mem::ManuallyDrop<DeviceControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DeviceControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DeviceSetNotificationFrequencyResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DeviceSetNotificationFrequencyResponder {
    type ControlHandle = DeviceControlHandle;

    fn control_handle(&self) -> &DeviceControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DeviceSetNotificationFrequencyResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>>(
                result,
                self.tx_id,
                0x45789b88ca9185b8,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceGetPositionResponder {
    control_handle: std::mem::ManuallyDrop<DeviceControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DeviceControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DeviceGetPositionResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DeviceGetPositionResponder {
    type ControlHandle = DeviceControlHandle;

    fn control_handle(&self) -> &DeviceControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DeviceGetPositionResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(i64, u32), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(i64, u32), Error>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(i64, u32), Error>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<DeviceGetPositionResponse, Error>>(
                result,
                self.tx_id,
                0x6fe5bbf9065258e8,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceChangePlugStateResponder {
    control_handle: std::mem::ManuallyDrop<DeviceControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DeviceControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DeviceChangePlugStateResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DeviceChangePlugStateResponder {
    type ControlHandle = DeviceControlHandle;

    fn control_handle(&self) -> &DeviceControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DeviceChangePlugStateResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>>(
                result,
                self.tx_id,
                0x61aa2d370caaf8f0,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceAdjustClockRateResponder {
    control_handle: std::mem::ManuallyDrop<DeviceControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DeviceControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DeviceAdjustClockRateResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DeviceAdjustClockRateResponder {
    type ControlHandle = DeviceControlHandle;

    fn control_handle(&self) -> &DeviceControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DeviceAdjustClockRateResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>>(
                result,
                self.tx_id,
                0x754661f655350134,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for ControlAddDeviceRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ControlAddDeviceRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            24
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ControlAddDeviceRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ControlAddDeviceRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControlAddDeviceRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ControlAddDeviceRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <Configuration as fidl::encoding::ValueTypeMarker>::borrow(&self.config),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.server),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<Configuration, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ControlAddDeviceRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControlAddDeviceRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ControlAddDeviceRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                config: fidl::new_empty!(
                    Configuration,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                server: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                Configuration,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.config,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.server,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DeviceOnBufferCreatedRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DeviceOnBufferCreatedRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            12
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            DeviceOnBufferCreatedRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DeviceOnBufferCreatedRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceOnBufferCreatedRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                DeviceOnBufferCreatedRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fidl::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.ring_buffer
                    ),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.num_ring_buffer_frames),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.notifications_per_ring),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
    >
        fidl::encoding::Encode<
            DeviceOnBufferCreatedRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceOnBufferCreatedRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DeviceOnBufferCreatedRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                ring_buffer: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                num_ring_buffer_frames: fidl::new_empty!(
                    u32,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                notifications_per_ring: fidl::new_empty!(
                    u32,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.ring_buffer, decoder, offset + 0, _depth)?;
            fidl::decode!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.num_ring_buffer_frames,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.notifications_per_ring,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DeviceGetBufferResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DeviceGetBufferResponse {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            12
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            DeviceGetBufferResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DeviceGetBufferResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceGetBufferResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                DeviceGetBufferResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fidl::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.ring_buffer
                    ),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.num_ring_buffer_frames),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.notifications_per_ring),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
    >
        fidl::encoding::Encode<
            DeviceGetBufferResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceGetBufferResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DeviceGetBufferResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                ring_buffer: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                num_ring_buffer_frames: fidl::new_empty!(
                    u32,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                notifications_per_ring: fidl::new_empty!(
                    u32,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.ring_buffer, decoder, offset + 0, _depth)?;
            fidl::decode!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.num_ring_buffer_frames,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.notifications_per_ring,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }
}