Struct jack::AsyncClient

pub struct AsyncClient<N, P> { /* fields omitted */ }

A JACK client that is processing data asynchronously, in real-time.

To create input or output (either sound or midi), a Port can be used within the process callback. See Client::register_port on creating ports. Also, see Port for documentation on the API for port.

Example

// Create a client and a handler
let (client, _status) =
    jack::Client::new("my_client", jack::ClientOptions::NO_START_SERVER).unwrap();
let process_handler = jack::ClosureProcessHandler::new(
    move |_: &jack::Client, _: &jack::ProcessScope| jack::Control::Continue,
);

// An active async client is created, `client` is consumed.
let active_client = client.activate_async((), process_handler).unwrap();

Methods

impl<N, P> AsyncClient<N, P> where
    N: NotificationHandler,
    P: ProcessHandler, 

fn new(
    client: Client,
    notification_handler: N,
    process_handler: P
) -> Result<Self, Error>

Tell the JACK server that the program is ready to start processing audio. JACK will call the methods specified by the NotificationHandler and ProcessHandler objects.

On failure, either Err(Error::CallbackRegistrationError) or Err(Error::ClientActivationError) is returned.

notification_handler and process_handler are consumed, but they are returned when Client::deactivate is called.

impl<N, P> AsyncClient<N, P>

fn as_client<'a>(&'a self) -> &'a Client

Return the underlying jack::Client.

fn deactivate(self) -> Result<(Client, N, P), Error>

Tell the JACK server to remove this client from the process graph. Also, disconnect all ports belonging to it since inactive clients have no port connections.

The handler that was used for Client::activate is returned on success. Its state may have changed due to JACK calling its methods.

In the case of error, the Client is destroyed because its state is unknown, and it is therefore unsafe to continue using.

Trait Implementations

impl<N: Send, P: Send> Send for AsyncClient<N, P>

impl<N, P> Drop for AsyncClient<N, P>

Closes the client.

fn drop(&mut self)

Deactivate and close the client.

impl<N, P> Debug for AsyncClient<N, P>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.