fidl_fuchsia_hardware_audio_signalprocessing/

fidl_fuchsia_hardware_audio_signalprocessing.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_hardware_audio_signalprocessing__common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ConnectorSignalProcessingConnectRequest {
    pub protocol: fidl::endpoints::ServerEnd<SignalProcessingMarker>,
}

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

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

impl fidl::endpoints::ProtocolMarker for ConnectorMarker {
    type Proxy = ConnectorProxy;
    type RequestStream = ConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ConnectorSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Connector";
}

pub trait ConnectorProxyInterface: Send + Sync {
    fn r#signal_processing_connect(
        &self,
        protocol: fidl::endpoints::ServerEnd<SignalProcessingMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ConnectorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ConnectorSynchronousProxy {
    type Proxy = ConnectorProxy;
    type Protocol = ConnectorMarker;

    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 ConnectorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ConnectorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    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<ConnectorEvent, fidl::Error> {
        ConnectorEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Connect to a `SignalProcessing` protocol.
    /// Multiple connections may be supported, if a new connection request is not supported, i.e.
    /// the maximum number of connections have already been created, for instance one, then the
    /// `protocol` channel (not the channel upon which `SignalProcessingConnect` is being called)
    /// will be closed with a `ZX_ERR_ALREADY_BOUND` epitaph.
    /// If signal processing is not supported at all, then the `protocol` channel (again, not the
    /// channel upon which `SignalProcessingConnect` is being called) will be closed with a
    /// `ZX_ERR_NOT_SUPPORTED` epitaph.
    /// This method is named `SignalProcessingConnect` instead of `Connect` because this protocol
    /// is intended to be composed, and hence the more verbose name allows differentiation and
    /// improved clarity.
    pub fn r#signal_processing_connect(
        &self,
        mut protocol: fidl::endpoints::ServerEnd<SignalProcessingMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ConnectorSignalProcessingConnectRequest>(
            (protocol,),
            0xa81907ce6066295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

impl fidl::endpoints::Proxy for ConnectorProxy {
    type Protocol = ConnectorMarker;

    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 ConnectorProxy {
    /// Create a new Proxy for fuchsia.hardware.audio.signalprocessing/Connector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ConnectorMarker 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) -> ConnectorEventStream {
        ConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connect to a `SignalProcessing` protocol.
    /// Multiple connections may be supported, if a new connection request is not supported, i.e.
    /// the maximum number of connections have already been created, for instance one, then the
    /// `protocol` channel (not the channel upon which `SignalProcessingConnect` is being called)
    /// will be closed with a `ZX_ERR_ALREADY_BOUND` epitaph.
    /// If signal processing is not supported at all, then the `protocol` channel (again, not the
    /// channel upon which `SignalProcessingConnect` is being called) will be closed with a
    /// `ZX_ERR_NOT_SUPPORTED` epitaph.
    /// This method is named `SignalProcessingConnect` instead of `Connect` because this protocol
    /// is intended to be composed, and hence the more verbose name allows differentiation and
    /// improved clarity.
    pub fn r#signal_processing_connect(
        &self,
        mut protocol: fidl::endpoints::ServerEnd<SignalProcessingMarker>,
    ) -> Result<(), fidl::Error> {
        ConnectorProxyInterface::r#signal_processing_connect(self, protocol)
    }
}

impl ConnectorProxyInterface for ConnectorProxy {
    fn r#signal_processing_connect(
        &self,
        mut protocol: fidl::endpoints::ServerEnd<SignalProcessingMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ConnectorSignalProcessingConnectRequest>(
            (protocol,),
            0xa81907ce6066295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

impl futures::Stream for ConnectorEventStream {
    type Item = Result<ConnectorEvent, 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(ConnectorEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

impl ConnectorEvent {
    /// Decodes a message buffer as a [`ConnectorEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ConnectorEvent, 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: <ConnectorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.hardware.audio.signalprocessing/Connector.
pub struct ConnectorRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for ConnectorRequestStream {
    type Protocol = ConnectorMarker;
    type ControlHandle = ConnectorControlHandle;

    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 {
        ConnectorControlHandle { 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 ConnectorRequestStream {
    type Item = Result<ConnectorRequest, 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 ConnectorRequestStream 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 {
                    0xa81907ce6066295 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ConnectorSignalProcessingConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ConnectorSignalProcessingConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ConnectorControlHandle { inner: this.inner.clone() };
                        Ok(ConnectorRequest::SignalProcessingConnect {
                            protocol: req.protocol,

                            control_handle,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ConnectorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// For an overview of the signal processing protocols see
/// [Audio Signal Processing](//docs/concepts/drivers/driver_architectures/audio_drivers/audio_signal_processing.md)
#[derive(Debug)]
pub enum ConnectorRequest {
    /// Connect to a `SignalProcessing` protocol.
    /// Multiple connections may be supported, if a new connection request is not supported, i.e.
    /// the maximum number of connections have already been created, for instance one, then the
    /// `protocol` channel (not the channel upon which `SignalProcessingConnect` is being called)
    /// will be closed with a `ZX_ERR_ALREADY_BOUND` epitaph.
    /// If signal processing is not supported at all, then the `protocol` channel (again, not the
    /// channel upon which `SignalProcessingConnect` is being called) will be closed with a
    /// `ZX_ERR_NOT_SUPPORTED` epitaph.
    /// This method is named `SignalProcessingConnect` instead of `Connect` because this protocol
    /// is intended to be composed, and hence the more verbose name allows differentiation and
    /// improved clarity.
    SignalProcessingConnect {
        protocol: fidl::endpoints::ServerEnd<SignalProcessingMarker>,
        control_handle: ConnectorControlHandle,
    },
}

impl ConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_signal_processing_connect(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<SignalProcessingMarker>, ConnectorControlHandle)> {
        if let ConnectorRequest::SignalProcessingConnect { protocol, control_handle } = self {
            Some((protocol, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ConnectorRequest::SignalProcessingConnect { .. } => "signal_processing_connect",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for ConnectorControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        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 ConnectorControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for ReaderMarker {
    type Proxy = ReaderProxy;
    type RequestStream = ReaderRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ReaderSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Reader";
}
pub type ReaderGetElementsResult = Result<Vec<Element>, i32>;
pub type ReaderGetTopologiesResult = Result<Vec<Topology>, i32>;

pub trait ReaderProxyInterface: Send + Sync {
    type GetElementsResponseFut: std::future::Future<Output = Result<ReaderGetElementsResult, fidl::Error>>
        + Send;
    fn r#get_elements(&self) -> Self::GetElementsResponseFut;
    type WatchElementStateResponseFut: std::future::Future<Output = Result<ElementState, fidl::Error>>
        + Send;
    fn r#watch_element_state(
        &self,
        processing_element_id: u64,
    ) -> Self::WatchElementStateResponseFut;
    type GetTopologiesResponseFut: std::future::Future<Output = Result<ReaderGetTopologiesResult, fidl::Error>>
        + Send;
    fn r#get_topologies(&self) -> Self::GetTopologiesResponseFut;
    type WatchTopologyResponseFut: std::future::Future<Output = Result<u64, fidl::Error>> + Send;
    fn r#watch_topology(&self) -> Self::WatchTopologyResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ReaderSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ReaderSynchronousProxy {
    type Proxy = ReaderProxy;
    type Protocol = ReaderMarker;

    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 ReaderSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ReaderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    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<ReaderEvent, fidl::Error> {
        ReaderEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Returns a vector of supported processing elements.
    /// This vector must include one or more processing elements.
    pub fn r#get_elements(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ReaderGetElementsResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<ReaderGetElementsResponse, i32>,
        >(
            (),
            0x1b14ff4adf5dc6f8,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.processing_elements))
    }

    /// Get the processing element state via a hanging get.
    /// For a given `processing_element_id`, the driver will immediately reply to the first
    /// `WatchElementState` sent by the client. The driver will not respond to subsequent client
    /// `WatchElementState` calls for that `processing_element_id` until any portion of the
    /// `ElementState` has changed from what was most recently reported for that element.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_INVALID_ARGS`, if
    /// `processing_element_id` does not match an ElementId returned by `GetElements`.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_BAD_STATE`, if this
    /// method is called again while there is already a pending `WatchElementState` for this client
    /// and `processing_element_id`.
    pub fn r#watch_element_state(
        &self,
        mut processing_element_id: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ElementState, fidl::Error> {
        let _response = self
            .client
            .send_query::<ReaderWatchElementStateRequest, ReaderWatchElementStateResponse>(
                (processing_element_id,),
                0x524da8772a69056f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.state)
    }

    /// Returns a vector of supported topologies.
    /// This vector must include one or more topologies.
    /// If more than one topology is returned, then the client may select any topology from the
    /// list by calling `SetTopology`.
    /// If only one topology is returned, `SetTopology` can still be called but causes no change.
    ///
    /// Each Element must be included in at least one Topology, but need not be included in every
    /// Topology.
    pub fn r#get_topologies(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ReaderGetTopologiesResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<ReaderGetTopologiesResponse, i32>,
        >(
            (),
            0x73ffb73af24d30b6,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.topologies))
    }

    /// Get the current topology via a hanging get.
    /// The driver will immediately reply to the first `WatchTopology` sent by each client.
    /// The driver will not respond to subsequent `WatchTopology` calls from that client until the
    /// signal processing topology changes; this occurs as a result of a `SetTopology` call.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_BAD_STATE`, if this
    /// method is called again while there is already a pending `WatchTopology` for this client.
    pub fn r#watch_topology(&self, ___deadline: zx::MonotonicInstant) -> Result<u64, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<ReaderWatchTopologyResponse>,
        >(
            (),
            0x66d172acdb36a729,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<ReaderMarker>("watch_topology")?;
        Ok(_response.topology_id)
    }
}

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

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

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

impl fidl::endpoints::Proxy for ReaderProxy {
    type Protocol = ReaderMarker;

    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 ReaderProxy {
    /// Create a new Proxy for fuchsia.hardware.audio.signalprocessing/Reader.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ReaderMarker 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) -> ReaderEventStream {
        ReaderEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns a vector of supported processing elements.
    /// This vector must include one or more processing elements.
    pub fn r#get_elements(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ReaderGetElementsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ReaderProxyInterface::r#get_elements(self)
    }

    /// Get the processing element state via a hanging get.
    /// For a given `processing_element_id`, the driver will immediately reply to the first
    /// `WatchElementState` sent by the client. The driver will not respond to subsequent client
    /// `WatchElementState` calls for that `processing_element_id` until any portion of the
    /// `ElementState` has changed from what was most recently reported for that element.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_INVALID_ARGS`, if
    /// `processing_element_id` does not match an ElementId returned by `GetElements`.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_BAD_STATE`, if this
    /// method is called again while there is already a pending `WatchElementState` for this client
    /// and `processing_element_id`.
    pub fn r#watch_element_state(
        &self,
        mut processing_element_id: u64,
    ) -> fidl::client::QueryResponseFut<ElementState, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        ReaderProxyInterface::r#watch_element_state(self, processing_element_id)
    }

    /// Returns a vector of supported topologies.
    /// This vector must include one or more topologies.
    /// If more than one topology is returned, then the client may select any topology from the
    /// list by calling `SetTopology`.
    /// If only one topology is returned, `SetTopology` can still be called but causes no change.
    ///
    /// Each Element must be included in at least one Topology, but need not be included in every
    /// Topology.
    pub fn r#get_topologies(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ReaderGetTopologiesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ReaderProxyInterface::r#get_topologies(self)
    }

    /// Get the current topology via a hanging get.
    /// The driver will immediately reply to the first `WatchTopology` sent by each client.
    /// The driver will not respond to subsequent `WatchTopology` calls from that client until the
    /// signal processing topology changes; this occurs as a result of a `SetTopology` call.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_BAD_STATE`, if this
    /// method is called again while there is already a pending `WatchTopology` for this client.
    pub fn r#watch_topology(
        &self,
    ) -> fidl::client::QueryResponseFut<u64, fidl::encoding::DefaultFuchsiaResourceDialect> {
        ReaderProxyInterface::r#watch_topology(self)
    }
}

impl ReaderProxyInterface for ReaderProxy {
    type GetElementsResponseFut = fidl::client::QueryResponseFut<
        ReaderGetElementsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_elements(&self) -> Self::GetElementsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ReaderGetElementsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ReaderGetElementsResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1b14ff4adf5dc6f8,
            >(_buf?)?;
            Ok(_response.map(|x| x.processing_elements))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ReaderGetElementsResult>(
            (),
            0x1b14ff4adf5dc6f8,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WatchElementStateResponseFut =
        fidl::client::QueryResponseFut<ElementState, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#watch_element_state(
        &self,
        mut processing_element_id: u64,
    ) -> Self::WatchElementStateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ElementState, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ReaderWatchElementStateResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x524da8772a69056f,
            >(_buf?)?;
            Ok(_response.state)
        }
        self.client.send_query_and_decode::<ReaderWatchElementStateRequest, ElementState>(
            (processing_element_id,),
            0x524da8772a69056f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetTopologiesResponseFut = fidl::client::QueryResponseFut<
        ReaderGetTopologiesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_topologies(&self) -> Self::GetTopologiesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ReaderGetTopologiesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ReaderGetTopologiesResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x73ffb73af24d30b6,
            >(_buf?)?;
            Ok(_response.map(|x| x.topologies))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, ReaderGetTopologiesResult>(
                (),
                0x73ffb73af24d30b6,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type WatchTopologyResponseFut =
        fidl::client::QueryResponseFut<u64, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#watch_topology(&self) -> Self::WatchTopologyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<u64, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<ReaderWatchTopologyResponse>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x66d172acdb36a729,
            >(_buf?)?
            .into_result::<ReaderMarker>("watch_topology")?;
            Ok(_response.topology_id)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, u64>(
            (),
            0x66d172acdb36a729,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

impl futures::Stream for ReaderEventStream {
    type Item = Result<ReaderEvent, 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(ReaderEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum ReaderEvent {
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl ReaderEvent {
    /// Decodes a message buffer as a [`ReaderEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ReaderEvent, 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 {
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(ReaderEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <ReaderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.hardware.audio.signalprocessing/Reader.
pub struct ReaderRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for ReaderRequestStream {
    type Protocol = ReaderMarker;
    type ControlHandle = ReaderControlHandle;

    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 {
        ReaderControlHandle { 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 ReaderRequestStream {
    type Item = Result<ReaderRequest, 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 ReaderRequestStream 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 {
                    0x1b14ff4adf5dc6f8 => {
                        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 = ReaderControlHandle { inner: this.inner.clone() };
                        Ok(ReaderRequest::GetElements {
                            responder: ReaderGetElementsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x524da8772a69056f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ReaderWatchElementStateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ReaderWatchElementStateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ReaderControlHandle { inner: this.inner.clone() };
                        Ok(ReaderRequest::WatchElementState {
                            processing_element_id: req.processing_element_id,

                            responder: ReaderWatchElementStateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x73ffb73af24d30b6 => {
                        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 = ReaderControlHandle { inner: this.inner.clone() };
                        Ok(ReaderRequest::GetTopologies {
                            responder: ReaderGetTopologiesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x66d172acdb36a729 => {
                        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 = ReaderControlHandle { inner: this.inner.clone() };
                        Ok(ReaderRequest::WatchTopology {
                            responder: ReaderWatchTopologyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(ReaderRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: ReaderControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::OneWay,
                        })
                    }
                    _ if header
                        .dynamic_flags()
                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        this.inner.send_framework_err(
                            fidl::encoding::FrameworkErr::UnknownMethod,
                            header.tx_id,
                            header.ordinal,
                            header.dynamic_flags(),
                            (bytes, handles),
                        )?;
                        Ok(ReaderRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: ReaderControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ReaderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// This protocol is required for Composite audio drivers, and unsupported for other audio driver
/// types (Codec, Dai, StreamConfig).
///
/// For an overview see
/// [[Signal Processing Interface]](https://fuchsia.dev/fuchsia-src/concepts/drivers/driver_architectures/audio_drivers/audio_signal_processing).
#[derive(Debug)]
pub enum ReaderRequest {
    /// Returns a vector of supported processing elements.
    /// This vector must include one or more processing elements.
    GetElements { responder: ReaderGetElementsResponder },
    /// Get the processing element state via a hanging get.
    /// For a given `processing_element_id`, the driver will immediately reply to the first
    /// `WatchElementState` sent by the client. The driver will not respond to subsequent client
    /// `WatchElementState` calls for that `processing_element_id` until any portion of the
    /// `ElementState` has changed from what was most recently reported for that element.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_INVALID_ARGS`, if
    /// `processing_element_id` does not match an ElementId returned by `GetElements`.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_BAD_STATE`, if this
    /// method is called again while there is already a pending `WatchElementState` for this client
    /// and `processing_element_id`.
    WatchElementState { processing_element_id: u64, responder: ReaderWatchElementStateResponder },
    /// Returns a vector of supported topologies.
    /// This vector must include one or more topologies.
    /// If more than one topology is returned, then the client may select any topology from the
    /// list by calling `SetTopology`.
    /// If only one topology is returned, `SetTopology` can still be called but causes no change.
    ///
    /// Each Element must be included in at least one Topology, but need not be included in every
    /// Topology.
    GetTopologies { responder: ReaderGetTopologiesResponder },
    /// Get the current topology via a hanging get.
    /// The driver will immediately reply to the first `WatchTopology` sent by each client.
    /// The driver will not respond to subsequent `WatchTopology` calls from that client until the
    /// signal processing topology changes; this occurs as a result of a `SetTopology` call.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_BAD_STATE`, if this
    /// method is called again while there is already a pending `WatchTopology` for this client.
    WatchTopology { responder: ReaderWatchTopologyResponder },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: ReaderControlHandle,
        method_type: fidl::MethodType,
    },
}

impl ReaderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_elements(self) -> Option<(ReaderGetElementsResponder)> {
        if let ReaderRequest::GetElements { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_element_state(self) -> Option<(u64, ReaderWatchElementStateResponder)> {
        if let ReaderRequest::WatchElementState { processing_element_id, responder } = self {
            Some((processing_element_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_topologies(self) -> Option<(ReaderGetTopologiesResponder)> {
        if let ReaderRequest::GetTopologies { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_topology(self) -> Option<(ReaderWatchTopologyResponder)> {
        if let ReaderRequest::WatchTopology { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ReaderRequest::GetElements { .. } => "get_elements",
            ReaderRequest::WatchElementState { .. } => "watch_element_state",
            ReaderRequest::GetTopologies { .. } => "get_topologies",
            ReaderRequest::WatchTopology { .. } => "watch_topology",
            ReaderRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            ReaderRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

impl fidl::endpoints::ControlHandle for ReaderControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        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 ReaderControlHandle {}

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

/// Set the the channel to be shutdown (see [`ReaderControlHandle::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 ReaderGetElementsResponder {
    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 ReaderGetElementsResponder {
    type ControlHandle = ReaderControlHandle;

    fn control_handle(&self) -> &ReaderControlHandle {
        &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 ReaderGetElementsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<&[Element], i32>) -> 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<&[Element], i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<&[Element], i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<ReaderGetElementsResponse, i32>>(
                result.map(|processing_elements| (processing_elements,)),
                self.tx_id,
                0x1b14ff4adf5dc6f8,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`ReaderControlHandle::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 ReaderWatchElementStateResponder {
    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 ReaderWatchElementStateResponder {
    type ControlHandle = ReaderControlHandle;

    fn control_handle(&self) -> &ReaderControlHandle {
        &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 ReaderWatchElementStateResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut state: &ElementState) -> Result<(), fidl::Error> {
        let _result = self.send_raw(state);
        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 state: &ElementState) -> Result<(), fidl::Error> {
        let _result = self.send_raw(state);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut state: &ElementState) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ReaderWatchElementStateResponse>(
            (state,),
            self.tx_id,
            0x524da8772a69056f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`ReaderControlHandle::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 ReaderGetTopologiesResponder {
    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 ReaderGetTopologiesResponder {
    type ControlHandle = ReaderControlHandle;

    fn control_handle(&self) -> &ReaderControlHandle {
        &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 ReaderGetTopologiesResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<&[Topology], i32>) -> 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<&[Topology], i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<&[Topology], i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<ReaderGetTopologiesResponse, i32>>(
                result.map(|topologies| (topologies,)),
                self.tx_id,
                0x73ffb73af24d30b6,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`ReaderControlHandle::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 ReaderWatchTopologyResponder {
    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 ReaderWatchTopologyResponder {
    type ControlHandle = ReaderControlHandle;

    fn control_handle(&self) -> &ReaderControlHandle {
        &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 ReaderWatchTopologyResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut topology_id: u64) -> Result<(), fidl::Error> {
        let _result = self.send_raw(topology_id);
        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 topology_id: u64) -> Result<(), fidl::Error> {
        let _result = self.send_raw(topology_id);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut topology_id: u64) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<ReaderWatchTopologyResponse>>(
            fidl::encoding::Flexible::new((topology_id,)),
            self.tx_id,
            0x66d172acdb36a729,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for SignalProcessingMarker {
    type Proxy = SignalProcessingProxy;
    type RequestStream = SignalProcessingRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = SignalProcessingSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) SignalProcessing";
}
pub type SignalProcessingSetTopologyResult = Result<(), i32>;
pub type SignalProcessingSetElementStateResult = Result<(), i32>;

pub trait SignalProcessingProxyInterface: Send + Sync {
    type GetElementsResponseFut: std::future::Future<Output = Result<ReaderGetElementsResult, fidl::Error>>
        + Send;
    fn r#get_elements(&self) -> Self::GetElementsResponseFut;
    type WatchElementStateResponseFut: std::future::Future<Output = Result<ElementState, fidl::Error>>
        + Send;
    fn r#watch_element_state(
        &self,
        processing_element_id: u64,
    ) -> Self::WatchElementStateResponseFut;
    type GetTopologiesResponseFut: std::future::Future<Output = Result<ReaderGetTopologiesResult, fidl::Error>>
        + Send;
    fn r#get_topologies(&self) -> Self::GetTopologiesResponseFut;
    type WatchTopologyResponseFut: std::future::Future<Output = Result<u64, fidl::Error>> + Send;
    fn r#watch_topology(&self) -> Self::WatchTopologyResponseFut;
    type SetTopologyResponseFut: std::future::Future<Output = Result<SignalProcessingSetTopologyResult, fidl::Error>>
        + Send;
    fn r#set_topology(&self, topology_id: u64) -> Self::SetTopologyResponseFut;
    type SetElementStateResponseFut: std::future::Future<Output = Result<SignalProcessingSetElementStateResult, fidl::Error>>
        + Send;
    fn r#set_element_state(
        &self,
        processing_element_id: u64,
        state: &SettableElementState,
    ) -> Self::SetElementStateResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct SignalProcessingSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for SignalProcessingSynchronousProxy {
    type Proxy = SignalProcessingProxy;
    type Protocol = SignalProcessingMarker;

    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 SignalProcessingSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <SignalProcessingMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    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<SignalProcessingEvent, fidl::Error> {
        SignalProcessingEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Returns a vector of supported processing elements.
    /// This vector must include one or more processing elements.
    pub fn r#get_elements(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ReaderGetElementsResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<ReaderGetElementsResponse, i32>,
        >(
            (),
            0x1b14ff4adf5dc6f8,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.processing_elements))
    }

    /// Get the processing element state via a hanging get.
    /// For a given `processing_element_id`, the driver will immediately reply to the first
    /// `WatchElementState` sent by the client. The driver will not respond to subsequent client
    /// `WatchElementState` calls for that `processing_element_id` until any portion of the
    /// `ElementState` has changed from what was most recently reported for that element.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_INVALID_ARGS`, if
    /// `processing_element_id` does not match an ElementId returned by `GetElements`.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_BAD_STATE`, if this
    /// method is called again while there is already a pending `WatchElementState` for this client
    /// and `processing_element_id`.
    pub fn r#watch_element_state(
        &self,
        mut processing_element_id: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ElementState, fidl::Error> {
        let _response = self
            .client
            .send_query::<ReaderWatchElementStateRequest, ReaderWatchElementStateResponse>(
                (processing_element_id,),
                0x524da8772a69056f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.state)
    }

    /// Returns a vector of supported topologies.
    /// This vector must include one or more topologies.
    /// If more than one topology is returned, then the client may select any topology from the
    /// list by calling `SetTopology`.
    /// If only one topology is returned, `SetTopology` can still be called but causes no change.
    ///
    /// Each Element must be included in at least one Topology, but need not be included in every
    /// Topology.
    pub fn r#get_topologies(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ReaderGetTopologiesResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<ReaderGetTopologiesResponse, i32>,
        >(
            (),
            0x73ffb73af24d30b6,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.topologies))
    }

    /// Get the current topology via a hanging get.
    /// The driver will immediately reply to the first `WatchTopology` sent by each client.
    /// The driver will not respond to subsequent `WatchTopology` calls from that client until the
    /// signal processing topology changes; this occurs as a result of a `SetTopology` call.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_BAD_STATE`, if this
    /// method is called again while there is already a pending `WatchTopology` for this client.
    pub fn r#watch_topology(&self, ___deadline: zx::MonotonicInstant) -> Result<u64, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<ReaderWatchTopologyResponse>,
        >(
            (),
            0x66d172acdb36a729,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SignalProcessingMarker>("watch_topology")?;
        Ok(_response.topology_id)
    }

    /// Sets the currently active topology by specifying a `topology_id`, which matches to an entry
    /// in the vector returned by `GetTopologies`.
    /// The currently active topology is communicated by `WatchTopology` responses. To change which
    /// topology is active, a client uses `SetTopology`.
    ///
    /// If `GetTopologies` returns only one `Topology`, `SetTopology` is optional and has no effect.
    ///
    /// This call will fail and return `ZX_ERR_INVALID_ARGS` if the specified `topology_id` is not
    /// found within the`topologies` returned by `GetTopologies`.
    ///
    /// `SetTopology` may be called before or after non-`SignalProcessing` protocol calls.
    /// If called after non-`SignalProcessing` protocol calls, then `SetTopology` may return
    /// `ZX_ERR_BAD_STATE` to indicate that the operation can not proceed without renegotiation of
    /// the driver state. See `SetElementState` for further discussion.
    pub fn r#set_topology(
        &self,
        mut topology_id: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SignalProcessingSetTopologyResult, fidl::Error> {
        let _response = self.client.send_query::<
            SignalProcessingSetTopologyRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (topology_id,),
            0x1d9a7f9b8fee790c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Controls the processing element specified by `processing_element_id`, a unique ElementId
    /// returned by `GetElements`.
    /// The `state` specified in calls to `SetElementState` is a `SettableElementState`. This is a
    /// subset of `ElementState` because some fields returned by `WatchElementState` (e.g. `latency`
    /// or `plug_state`) can only be observed (not set) by the client.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `processing_element_id` does not match a known ElementId
    /// returned by `GetElements`, or if `state` is not valid for the element. This entails any
    /// violation of the rules specified in this protocol.
    ///
    /// Examples:
    /// `state` specifies that an element should be stopped or bypassed, but the corresponding
    ///     element does not specify (or explicitly set to false) `can_stop` or `can_bypass`.
    /// `state` includes a `type_specific` entry, but that `SettableTypeSpecificElementState` does
    ///     not match the `ElementType` of the element corresponding to `processing_element_id`.
    /// `state` changes an `EqualizerBandState` for an `EQUALIZER` element (so far so good), but
    ///     specifies a change to `frequency` when this element did not set `CAN_CONTROL_FREQUENCY`
    ///     in its `supported_controls`.
    /// `state` specifies a `GainElementState` for a `GAIN` element with a `gain` value that is
    ///     -infinity, NAN, or outside the Element's stated [`min_gain`, `max_gain`] range.
    ///
    /// Callers may intersperse method calls to the `SignalProcessing` protocol with calls to other
    /// driver protocols. Some non-`SignalProcessing` configuration changes may require a
    /// renegotiation of the driver state before certain elements can receive a `SetElementState`.
    /// For example, if a `DaiFormat` is changed, then `SetElementState` changing an `AGL` element's
    /// parameters may not require renegotiation of driver state because changing gain parameters
    /// usually does not change the set of supported audio formats.
    /// By contrast, following the same `DaiFormat` change, before `SetElementState` can be called
    /// on a `CONNECTION_POINT` element, the driver state may need to be reestablished because the
    /// format change may invalidate the set of supported formats returned in a previous
    /// `GetDaiFormats` protocol call for another part of the Topology.
    ///
    /// It is the driver's job to determine when renegotiation is required. When this is needed,
    /// the related `SetElementState` call must return `ZX_ERR_BAD_STATE` and the client must
    /// close the protocol channel entirely, such that the protocol negotiations are started over.
    /// The client then must re-invoke the `SetElementState` call that returned
    /// `ZX_ERR_BAD_STATE` before any non-`SignalProcessing` protocol calls.
    pub fn r#set_element_state(
        &self,
        mut processing_element_id: u64,
        mut state: &SettableElementState,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SignalProcessingSetElementStateResult, fidl::Error> {
        let _response = self.client.send_query::<
            SignalProcessingSetElementStateRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (processing_element_id, state,),
            0x38c3b2d4bae698f4,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

impl fidl::endpoints::Proxy for SignalProcessingProxy {
    type Protocol = SignalProcessingMarker;

    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 SignalProcessingProxy {
    /// Create a new Proxy for fuchsia.hardware.audio.signalprocessing/SignalProcessing.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <SignalProcessingMarker 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) -> SignalProcessingEventStream {
        SignalProcessingEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns a vector of supported processing elements.
    /// This vector must include one or more processing elements.
    pub fn r#get_elements(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ReaderGetElementsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SignalProcessingProxyInterface::r#get_elements(self)
    }

    /// Get the processing element state via a hanging get.
    /// For a given `processing_element_id`, the driver will immediately reply to the first
    /// `WatchElementState` sent by the client. The driver will not respond to subsequent client
    /// `WatchElementState` calls for that `processing_element_id` until any portion of the
    /// `ElementState` has changed from what was most recently reported for that element.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_INVALID_ARGS`, if
    /// `processing_element_id` does not match an ElementId returned by `GetElements`.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_BAD_STATE`, if this
    /// method is called again while there is already a pending `WatchElementState` for this client
    /// and `processing_element_id`.
    pub fn r#watch_element_state(
        &self,
        mut processing_element_id: u64,
    ) -> fidl::client::QueryResponseFut<ElementState, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        SignalProcessingProxyInterface::r#watch_element_state(self, processing_element_id)
    }

    /// Returns a vector of supported topologies.
    /// This vector must include one or more topologies.
    /// If more than one topology is returned, then the client may select any topology from the
    /// list by calling `SetTopology`.
    /// If only one topology is returned, `SetTopology` can still be called but causes no change.
    ///
    /// Each Element must be included in at least one Topology, but need not be included in every
    /// Topology.
    pub fn r#get_topologies(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ReaderGetTopologiesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SignalProcessingProxyInterface::r#get_topologies(self)
    }

    /// Get the current topology via a hanging get.
    /// The driver will immediately reply to the first `WatchTopology` sent by each client.
    /// The driver will not respond to subsequent `WatchTopology` calls from that client until the
    /// signal processing topology changes; this occurs as a result of a `SetTopology` call.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_BAD_STATE`, if this
    /// method is called again while there is already a pending `WatchTopology` for this client.
    pub fn r#watch_topology(
        &self,
    ) -> fidl::client::QueryResponseFut<u64, fidl::encoding::DefaultFuchsiaResourceDialect> {
        SignalProcessingProxyInterface::r#watch_topology(self)
    }

    /// Sets the currently active topology by specifying a `topology_id`, which matches to an entry
    /// in the vector returned by `GetTopologies`.
    /// The currently active topology is communicated by `WatchTopology` responses. To change which
    /// topology is active, a client uses `SetTopology`.
    ///
    /// If `GetTopologies` returns only one `Topology`, `SetTopology` is optional and has no effect.
    ///
    /// This call will fail and return `ZX_ERR_INVALID_ARGS` if the specified `topology_id` is not
    /// found within the`topologies` returned by `GetTopologies`.
    ///
    /// `SetTopology` may be called before or after non-`SignalProcessing` protocol calls.
    /// If called after non-`SignalProcessing` protocol calls, then `SetTopology` may return
    /// `ZX_ERR_BAD_STATE` to indicate that the operation can not proceed without renegotiation of
    /// the driver state. See `SetElementState` for further discussion.
    pub fn r#set_topology(
        &self,
        mut topology_id: u64,
    ) -> fidl::client::QueryResponseFut<
        SignalProcessingSetTopologyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SignalProcessingProxyInterface::r#set_topology(self, topology_id)
    }

    /// Controls the processing element specified by `processing_element_id`, a unique ElementId
    /// returned by `GetElements`.
    /// The `state` specified in calls to `SetElementState` is a `SettableElementState`. This is a
    /// subset of `ElementState` because some fields returned by `WatchElementState` (e.g. `latency`
    /// or `plug_state`) can only be observed (not set) by the client.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `processing_element_id` does not match a known ElementId
    /// returned by `GetElements`, or if `state` is not valid for the element. This entails any
    /// violation of the rules specified in this protocol.
    ///
    /// Examples:
    /// `state` specifies that an element should be stopped or bypassed, but the corresponding
    ///     element does not specify (or explicitly set to false) `can_stop` or `can_bypass`.
    /// `state` includes a `type_specific` entry, but that `SettableTypeSpecificElementState` does
    ///     not match the `ElementType` of the element corresponding to `processing_element_id`.
    /// `state` changes an `EqualizerBandState` for an `EQUALIZER` element (so far so good), but
    ///     specifies a change to `frequency` when this element did not set `CAN_CONTROL_FREQUENCY`
    ///     in its `supported_controls`.
    /// `state` specifies a `GainElementState` for a `GAIN` element with a `gain` value that is
    ///     -infinity, NAN, or outside the Element's stated [`min_gain`, `max_gain`] range.
    ///
    /// Callers may intersperse method calls to the `SignalProcessing` protocol with calls to other
    /// driver protocols. Some non-`SignalProcessing` configuration changes may require a
    /// renegotiation of the driver state before certain elements can receive a `SetElementState`.
    /// For example, if a `DaiFormat` is changed, then `SetElementState` changing an `AGL` element's
    /// parameters may not require renegotiation of driver state because changing gain parameters
    /// usually does not change the set of supported audio formats.
    /// By contrast, following the same `DaiFormat` change, before `SetElementState` can be called
    /// on a `CONNECTION_POINT` element, the driver state may need to be reestablished because the
    /// format change may invalidate the set of supported formats returned in a previous
    /// `GetDaiFormats` protocol call for another part of the Topology.
    ///
    /// It is the driver's job to determine when renegotiation is required. When this is needed,
    /// the related `SetElementState` call must return `ZX_ERR_BAD_STATE` and the client must
    /// close the protocol channel entirely, such that the protocol negotiations are started over.
    /// The client then must re-invoke the `SetElementState` call that returned
    /// `ZX_ERR_BAD_STATE` before any non-`SignalProcessing` protocol calls.
    pub fn r#set_element_state(
        &self,
        mut processing_element_id: u64,
        mut state: &SettableElementState,
    ) -> fidl::client::QueryResponseFut<
        SignalProcessingSetElementStateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SignalProcessingProxyInterface::r#set_element_state(self, processing_element_id, state)
    }
}

impl SignalProcessingProxyInterface for SignalProcessingProxy {
    type GetElementsResponseFut = fidl::client::QueryResponseFut<
        ReaderGetElementsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_elements(&self) -> Self::GetElementsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ReaderGetElementsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ReaderGetElementsResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1b14ff4adf5dc6f8,
            >(_buf?)?;
            Ok(_response.map(|x| x.processing_elements))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ReaderGetElementsResult>(
            (),
            0x1b14ff4adf5dc6f8,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WatchElementStateResponseFut =
        fidl::client::QueryResponseFut<ElementState, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#watch_element_state(
        &self,
        mut processing_element_id: u64,
    ) -> Self::WatchElementStateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ElementState, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ReaderWatchElementStateResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x524da8772a69056f,
            >(_buf?)?;
            Ok(_response.state)
        }
        self.client.send_query_and_decode::<ReaderWatchElementStateRequest, ElementState>(
            (processing_element_id,),
            0x524da8772a69056f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetTopologiesResponseFut = fidl::client::QueryResponseFut<
        ReaderGetTopologiesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_topologies(&self) -> Self::GetTopologiesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ReaderGetTopologiesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ReaderGetTopologiesResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x73ffb73af24d30b6,
            >(_buf?)?;
            Ok(_response.map(|x| x.topologies))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, ReaderGetTopologiesResult>(
                (),
                0x73ffb73af24d30b6,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type WatchTopologyResponseFut =
        fidl::client::QueryResponseFut<u64, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#watch_topology(&self) -> Self::WatchTopologyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<u64, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<ReaderWatchTopologyResponse>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x66d172acdb36a729,
            >(_buf?)?
            .into_result::<SignalProcessingMarker>("watch_topology")?;
            Ok(_response.topology_id)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, u64>(
            (),
            0x66d172acdb36a729,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SetTopologyResponseFut = fidl::client::QueryResponseFut<
        SignalProcessingSetTopologyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_topology(&self, mut topology_id: u64) -> Self::SetTopologyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SignalProcessingSetTopologyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1d9a7f9b8fee790c,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            SignalProcessingSetTopologyRequest,
            SignalProcessingSetTopologyResult,
        >(
            (topology_id,),
            0x1d9a7f9b8fee790c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetElementStateResponseFut = fidl::client::QueryResponseFut<
        SignalProcessingSetElementStateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_element_state(
        &self,
        mut processing_element_id: u64,
        mut state: &SettableElementState,
    ) -> Self::SetElementStateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SignalProcessingSetElementStateResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x38c3b2d4bae698f4,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            SignalProcessingSetElementStateRequest,
            SignalProcessingSetElementStateResult,
        >(
            (processing_element_id, state,),
            0x38c3b2d4bae698f4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

impl futures::Stream for SignalProcessingEventStream {
    type Item = Result<SignalProcessingEvent, 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(SignalProcessingEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum SignalProcessingEvent {
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl SignalProcessingEvent {
    /// Decodes a message buffer as a [`SignalProcessingEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<SignalProcessingEvent, 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 {
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(SignalProcessingEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <SignalProcessingMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.hardware.audio.signalprocessing/SignalProcessing.
pub struct SignalProcessingRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for SignalProcessingRequestStream {
    type Protocol = SignalProcessingMarker;
    type ControlHandle = SignalProcessingControlHandle;

    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 {
        SignalProcessingControlHandle { 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 SignalProcessingRequestStream {
    type Item = Result<SignalProcessingRequest, 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 SignalProcessingRequestStream 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 {
                    0x1b14ff4adf5dc6f8 => {
                        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 =
                            SignalProcessingControlHandle { inner: this.inner.clone() };
                        Ok(SignalProcessingRequest::GetElements {
                            responder: SignalProcessingGetElementsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x524da8772a69056f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ReaderWatchElementStateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ReaderWatchElementStateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            SignalProcessingControlHandle { inner: this.inner.clone() };
                        Ok(SignalProcessingRequest::WatchElementState {
                            processing_element_id: req.processing_element_id,

                            responder: SignalProcessingWatchElementStateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x73ffb73af24d30b6 => {
                        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 =
                            SignalProcessingControlHandle { inner: this.inner.clone() };
                        Ok(SignalProcessingRequest::GetTopologies {
                            responder: SignalProcessingGetTopologiesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x66d172acdb36a729 => {
                        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 =
                            SignalProcessingControlHandle { inner: this.inner.clone() };
                        Ok(SignalProcessingRequest::WatchTopology {
                            responder: SignalProcessingWatchTopologyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1d9a7f9b8fee790c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SignalProcessingSetTopologyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SignalProcessingSetTopologyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            SignalProcessingControlHandle { inner: this.inner.clone() };
                        Ok(SignalProcessingRequest::SetTopology {
                            topology_id: req.topology_id,

                            responder: SignalProcessingSetTopologyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x38c3b2d4bae698f4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SignalProcessingSetElementStateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SignalProcessingSetElementStateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            SignalProcessingControlHandle { inner: this.inner.clone() };
                        Ok(SignalProcessingRequest::SetElementState {
                            processing_element_id: req.processing_element_id,
                            state: req.state,

                            responder: SignalProcessingSetElementStateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(SignalProcessingRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: SignalProcessingControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::OneWay,
                        })
                    }
                    _ if header
                        .dynamic_flags()
                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        this.inner.send_framework_err(
                            fidl::encoding::FrameworkErr::UnknownMethod,
                            header.tx_id,
                            header.ordinal,
                            header.dynamic_flags(),
                            (bytes, handles),
                        )?;
                        Ok(SignalProcessingRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: SignalProcessingControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <SignalProcessingMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// This protocol is required for Composite audio drivers, and unsupported for other audio driver
/// types (Codec, Dai, StreamConfig).
///
/// For an overview see
/// [[Signal Processing Interface]](https://fuchsia.dev/fuchsia-src/concepts/drivers/driver_architectures/audio_drivers/audio_signal_processing).
#[derive(Debug)]
pub enum SignalProcessingRequest {
    /// Returns a vector of supported processing elements.
    /// This vector must include one or more processing elements.
    GetElements { responder: SignalProcessingGetElementsResponder },
    /// Get the processing element state via a hanging get.
    /// For a given `processing_element_id`, the driver will immediately reply to the first
    /// `WatchElementState` sent by the client. The driver will not respond to subsequent client
    /// `WatchElementState` calls for that `processing_element_id` until any portion of the
    /// `ElementState` has changed from what was most recently reported for that element.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_INVALID_ARGS`, if
    /// `processing_element_id` does not match an ElementId returned by `GetElements`.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_BAD_STATE`, if this
    /// method is called again while there is already a pending `WatchElementState` for this client
    /// and `processing_element_id`.
    WatchElementState {
        processing_element_id: u64,
        responder: SignalProcessingWatchElementStateResponder,
    },
    /// Returns a vector of supported topologies.
    /// This vector must include one or more topologies.
    /// If more than one topology is returned, then the client may select any topology from the
    /// list by calling `SetTopology`.
    /// If only one topology is returned, `SetTopology` can still be called but causes no change.
    ///
    /// Each Element must be included in at least one Topology, but need not be included in every
    /// Topology.
    GetTopologies { responder: SignalProcessingGetTopologiesResponder },
    /// Get the current topology via a hanging get.
    /// The driver will immediately reply to the first `WatchTopology` sent by each client.
    /// The driver will not respond to subsequent `WatchTopology` calls from that client until the
    /// signal processing topology changes; this occurs as a result of a `SetTopology` call.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_BAD_STATE`, if this
    /// method is called again while there is already a pending `WatchTopology` for this client.
    WatchTopology { responder: SignalProcessingWatchTopologyResponder },
    /// Sets the currently active topology by specifying a `topology_id`, which matches to an entry
    /// in the vector returned by `GetTopologies`.
    /// The currently active topology is communicated by `WatchTopology` responses. To change which
    /// topology is active, a client uses `SetTopology`.
    ///
    /// If `GetTopologies` returns only one `Topology`, `SetTopology` is optional and has no effect.
    ///
    /// This call will fail and return `ZX_ERR_INVALID_ARGS` if the specified `topology_id` is not
    /// found within the`topologies` returned by `GetTopologies`.
    ///
    /// `SetTopology` may be called before or after non-`SignalProcessing` protocol calls.
    /// If called after non-`SignalProcessing` protocol calls, then `SetTopology` may return
    /// `ZX_ERR_BAD_STATE` to indicate that the operation can not proceed without renegotiation of
    /// the driver state. See `SetElementState` for further discussion.
    SetTopology { topology_id: u64, responder: SignalProcessingSetTopologyResponder },
    /// Controls the processing element specified by `processing_element_id`, a unique ElementId
    /// returned by `GetElements`.
    /// The `state` specified in calls to `SetElementState` is a `SettableElementState`. This is a
    /// subset of `ElementState` because some fields returned by `WatchElementState` (e.g. `latency`
    /// or `plug_state`) can only be observed (not set) by the client.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `processing_element_id` does not match a known ElementId
    /// returned by `GetElements`, or if `state` is not valid for the element. This entails any
    /// violation of the rules specified in this protocol.
    ///
    /// Examples:
    /// `state` specifies that an element should be stopped or bypassed, but the corresponding
    ///     element does not specify (or explicitly set to false) `can_stop` or `can_bypass`.
    /// `state` includes a `type_specific` entry, but that `SettableTypeSpecificElementState` does
    ///     not match the `ElementType` of the element corresponding to `processing_element_id`.
    /// `state` changes an `EqualizerBandState` for an `EQUALIZER` element (so far so good), but
    ///     specifies a change to `frequency` when this element did not set `CAN_CONTROL_FREQUENCY`
    ///     in its `supported_controls`.
    /// `state` specifies a `GainElementState` for a `GAIN` element with a `gain` value that is
    ///     -infinity, NAN, or outside the Element's stated [`min_gain`, `max_gain`] range.
    ///
    /// Callers may intersperse method calls to the `SignalProcessing` protocol with calls to other
    /// driver protocols. Some non-`SignalProcessing` configuration changes may require a
    /// renegotiation of the driver state before certain elements can receive a `SetElementState`.
    /// For example, if a `DaiFormat` is changed, then `SetElementState` changing an `AGL` element's
    /// parameters may not require renegotiation of driver state because changing gain parameters
    /// usually does not change the set of supported audio formats.
    /// By contrast, following the same `DaiFormat` change, before `SetElementState` can be called
    /// on a `CONNECTION_POINT` element, the driver state may need to be reestablished because the
    /// format change may invalidate the set of supported formats returned in a previous
    /// `GetDaiFormats` protocol call for another part of the Topology.
    ///
    /// It is the driver's job to determine when renegotiation is required. When this is needed,
    /// the related `SetElementState` call must return `ZX_ERR_BAD_STATE` and the client must
    /// close the protocol channel entirely, such that the protocol negotiations are started over.
    /// The client then must re-invoke the `SetElementState` call that returned
    /// `ZX_ERR_BAD_STATE` before any non-`SignalProcessing` protocol calls.
    SetElementState {
        processing_element_id: u64,
        state: SettableElementState,
        responder: SignalProcessingSetElementStateResponder,
    },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: SignalProcessingControlHandle,
        method_type: fidl::MethodType,
    },
}

impl SignalProcessingRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_elements(self) -> Option<(SignalProcessingGetElementsResponder)> {
        if let SignalProcessingRequest::GetElements { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_element_state(
        self,
    ) -> Option<(u64, SignalProcessingWatchElementStateResponder)> {
        if let SignalProcessingRequest::WatchElementState { processing_element_id, responder } =
            self
        {
            Some((processing_element_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_topologies(self) -> Option<(SignalProcessingGetTopologiesResponder)> {
        if let SignalProcessingRequest::GetTopologies { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_topology(self) -> Option<(SignalProcessingWatchTopologyResponder)> {
        if let SignalProcessingRequest::WatchTopology { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_topology(self) -> Option<(u64, SignalProcessingSetTopologyResponder)> {
        if let SignalProcessingRequest::SetTopology { topology_id, responder } = self {
            Some((topology_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_element_state(
        self,
    ) -> Option<(u64, SettableElementState, SignalProcessingSetElementStateResponder)> {
        if let SignalProcessingRequest::SetElementState {
            processing_element_id,
            state,
            responder,
        } = self
        {
            Some((processing_element_id, state, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            SignalProcessingRequest::GetElements { .. } => "get_elements",
            SignalProcessingRequest::WatchElementState { .. } => "watch_element_state",
            SignalProcessingRequest::GetTopologies { .. } => "get_topologies",
            SignalProcessingRequest::WatchTopology { .. } => "watch_topology",
            SignalProcessingRequest::SetTopology { .. } => "set_topology",
            SignalProcessingRequest::SetElementState { .. } => "set_element_state",
            SignalProcessingRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay,
                ..
            } => "unknown one-way method",
            SignalProcessingRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay,
                ..
            } => "unknown two-way method",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for SignalProcessingControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        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 SignalProcessingControlHandle {}

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

/// Set the the channel to be shutdown (see [`SignalProcessingControlHandle::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 SignalProcessingGetElementsResponder {
    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 SignalProcessingGetElementsResponder {
    type ControlHandle = SignalProcessingControlHandle;

    fn control_handle(&self) -> &SignalProcessingControlHandle {
        &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 SignalProcessingGetElementsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<&[Element], i32>) -> 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<&[Element], i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<&[Element], i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<ReaderGetElementsResponse, i32>>(
                result.map(|processing_elements| (processing_elements,)),
                self.tx_id,
                0x1b14ff4adf5dc6f8,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`SignalProcessingControlHandle::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 SignalProcessingWatchElementStateResponder {
    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 SignalProcessingWatchElementStateResponder {
    type ControlHandle = SignalProcessingControlHandle;

    fn control_handle(&self) -> &SignalProcessingControlHandle {
        &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 SignalProcessingWatchElementStateResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut state: &ElementState) -> Result<(), fidl::Error> {
        let _result = self.send_raw(state);
        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 state: &ElementState) -> Result<(), fidl::Error> {
        let _result = self.send_raw(state);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut state: &ElementState) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ReaderWatchElementStateResponse>(
            (state,),
            self.tx_id,
            0x524da8772a69056f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`SignalProcessingControlHandle::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 SignalProcessingGetTopologiesResponder {
    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 SignalProcessingGetTopologiesResponder {
    type ControlHandle = SignalProcessingControlHandle;

    fn control_handle(&self) -> &SignalProcessingControlHandle {
        &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 SignalProcessingGetTopologiesResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<&[Topology], i32>) -> 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<&[Topology], i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<&[Topology], i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<ReaderGetTopologiesResponse, i32>>(
                result.map(|topologies| (topologies,)),
                self.tx_id,
                0x73ffb73af24d30b6,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`SignalProcessingControlHandle::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 SignalProcessingWatchTopologyResponder {
    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 SignalProcessingWatchTopologyResponder {
    type ControlHandle = SignalProcessingControlHandle;

    fn control_handle(&self) -> &SignalProcessingControlHandle {
        &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 SignalProcessingWatchTopologyResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut topology_id: u64) -> Result<(), fidl::Error> {
        let _result = self.send_raw(topology_id);
        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 topology_id: u64) -> Result<(), fidl::Error> {
        let _result = self.send_raw(topology_id);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut topology_id: u64) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<ReaderWatchTopologyResponse>>(
            fidl::encoding::Flexible::new((topology_id,)),
            self.tx_id,
            0x66d172acdb36a729,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

/// Set the the channel to be shutdown (see [`SignalProcessingControlHandle::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 SignalProcessingSetTopologyResponder {
    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 SignalProcessingSetTopologyResponder {
    type ControlHandle = SignalProcessingControlHandle;

    fn control_handle(&self) -> &SignalProcessingControlHandle {
        &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 SignalProcessingSetTopologyResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> 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<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

/// Set the the channel to be shutdown (see [`SignalProcessingControlHandle::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 SignalProcessingSetElementStateResponder {
    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 SignalProcessingSetElementStateResponder {
    type ControlHandle = SignalProcessingControlHandle;

    fn control_handle(&self) -> &SignalProcessingControlHandle {
        &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 SignalProcessingSetElementStateResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> 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<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for ConnectorServiceMarker {
    type Proxy = ConnectorServiceProxy;
    type Request = ConnectorServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.audio.signalprocessing.ConnectorService";
}

/// A request for one of the member protocols of ConnectorService.
///
#[cfg(target_os = "fuchsia")]
pub enum ConnectorServiceRequest {
    Connector(ConnectorRequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for ConnectorServiceRequest {
    type Service = ConnectorServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "connector" => Self::Connector(
                <ConnectorRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            _ => panic!("no such member protocol name for service ConnectorService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["connector"]
    }
}
#[cfg(target_os = "fuchsia")]
pub struct ConnectorServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for ConnectorServiceProxy {
    type Service = ConnectorServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl ConnectorServiceProxy {
    pub fn connect_to_connector(&self) -> Result<ConnectorProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<ConnectorMarker>();
        self.connect_channel_to_connector(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_connector`, but returns a sync proxy.
    /// See [`Self::connect_to_connector`] for more details.
    pub fn connect_to_connector_sync(&self) -> Result<ConnectorSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<ConnectorMarker>();
        self.connect_channel_to_connector(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_connector`, but accepts a server end.
    /// See [`Self::connect_to_connector`] for more details.
    pub fn connect_channel_to_connector(
        &self,
        server_end: fidl::endpoints::ServerEnd<ConnectorMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("connector", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for ConnectorSignalProcessingConnectRequest {
        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 ConnectorSignalProcessingConnectRequest {
        type Owned = Self;

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

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

    unsafe impl
        fidl::encoding::Encode<
            ConnectorSignalProcessingConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ConnectorSignalProcessingConnectRequest
    {
        #[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::<ConnectorSignalProcessingConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ConnectorSignalProcessingConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SignalProcessingMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.protocol),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SignalProcessingMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            ConnectorSignalProcessingConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[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::<ConnectorSignalProcessingConnectRequest>(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)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ConnectorSignalProcessingConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                protocol: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SignalProcessingMarker>>,
                    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::Endpoint<fidl::endpoints::ServerEnd<SignalProcessingMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.protocol,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }
}