wip: modularize once again

jack/src/from_jack.rs

@@ -0,0 +1,13 @@
+use crate::*;
+
+/// Implement [TryFrom<&Arc<RwLock<JackConnection>>>]: create app state from wrapped JACK handle.
+#[macro_export] macro_rules! from_jack {
+    (|$jack:ident|$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)? $cb:expr) => {
+        impl $(<$($L),*$($T $(: $U)?),*>)? TryFrom<&Arc<RwLock<JackConnection>>> for $Struct $(<$($L),*$($T),*>)? {
+            type Error = Box<dyn std::error::Error>;
+            fn try_from ($jack: &Arc<RwLock<JackConnection>>) -> Usually<Self> {
+                Ok($cb)
+            }
+        }
+    };
+}

jack/src/jack_audio.rs

@@ -0,0 +1,26 @@
+use crate::*;
+
+/// Implement [Audio]: provide JACK callbacks.
+#[macro_export] macro_rules! audio {
+    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?,$c:ident,$s:ident|$cb:expr) => {
+        impl $(<$($L),*$($T $(: $U)?),*>)? Audio for $Struct $(<$($L),*$($T),*>)? {
+            #[inline] fn process (&mut $self, $c: &Client, $s: &ProcessScope) -> Control { $cb }
+        }
+    }
+}
+
+/// Trait for thing that has a JACK process callback.
+pub trait Audio: Send + Sync {
+    fn process (&mut self, _: &Client, _: &ProcessScope) -> Control {
+        Control::Continue
+    }
+    fn callback (
+        state: &Arc<RwLock<Self>>, client: &Client, scope: &ProcessScope
+    ) -> Control where Self: Sized {
+        if let Ok(mut state) = state.write() {
+            state.process(client, scope)
+        } else {
+            Control::Quit
+        }
+    }
+}

jack/src/jack_connection.rs

@@ -0,0 +1,132 @@
+use crate::*;
+
+/// This is a boxed realtime callback.
+pub type BoxedAudioHandler     = Box<dyn FnMut(&Client, &ProcessScope) -> Control + Send>;
+
+/// This is the notification handler wrapper for a boxed realtime callback.
+pub type DynamicAudioHandler   = ClosureProcessHandler<(), BoxedAudioHandler>;
+
+/// This is a boxed [JackEvent] callback.
+pub type BoxedJackEventHandler = Box<dyn Fn(JackEvent) + Send + Sync>;
+
+/// This is the notification handler wrapper for a boxed [JackEvent] callback.
+pub type DynamicNotifications  = Notifications<BoxedJackEventHandler>;
+
+/// This is a running JACK [AsyncClient] with maximum type erasure.
+/// It has one [Box] containing a function that handles [JackEvent]s,
+/// and another [Box] containing a function that handles realtime IO,
+/// and that's all it knows about them.
+pub type DynamicAsyncClient    = AsyncClient<DynamicNotifications, DynamicAudioHandler>;
+
+/// This is a connection which may be `Inactive`, `Activating`, or `Active`.
+/// In the `Active` and `Inactive` states, its `client` method returns a
+/// [Client] which you can use to talk to the JACK API.
+#[derive(Debug)]
+pub enum JackConnection {
+    /// Before activation.
+    Inactive(Client),
+    /// During activation.
+    Activating,
+    /// After activation. Must not be dropped for JACK thread to persist.
+    Active(DynamicAsyncClient),
+}
+
+impl From<JackConnection> for Client {
+    fn from (jack: JackConnection) -> Self {
+        match jack {
+            JackConnection::Inactive(client) => client,
+            JackConnection::Activating       => panic!("jack client still activating"),
+            JackConnection::Active(_)        => panic!("jack client already activated"),
+        }
+    }
+}
+
+impl JackConnection {
+    pub fn new (name: &str) -> Usually<Self> {
+        let (client, _) = Client::new(name, ClientOptions::NO_START_SERVER)?;
+        Ok(Self::Inactive(client))
+    }
+    /// Return the internal [Client] handle that lets you call the JACK API.
+    pub fn client (&self) -> &Client {
+        match self {
+            Self::Inactive(ref client) => client,
+            Self::Activating           => panic!("jack client has not finished activation"),
+            Self::Active(ref client)   => client.as_client(),
+        }
+    }
+    /// Activate a connection with an application.
+    ///
+    /// Consume a `JackConnection::Inactive`,
+    /// binding a process callback and
+    /// returning a `JackConnection::Active`.
+    ///
+    /// Needs work. Strange ownership situation between the callback
+    /// and the host object.
+    fn activate (
+        self,
+        mut cb: impl FnMut(&Arc<RwLock<Self>>, &Client, &ProcessScope) -> Control + Send + 'static,
+    ) -> Usually<Arc<RwLock<Self>>>
+    where
+        Self: Send + Sync + 'static
+    {
+        let client = Client::from(self);
+        let state  = Arc::new(RwLock::new(Self::Activating));
+        let event  = Box::new(move|_|{/*TODO*/}) as Box<dyn Fn(JackEvent) + Send + Sync>;
+        let events = Notifications(event);
+        let frame  = Box::new({let state = state.clone(); move|c: &_, s: &_|cb(&state, c, s)});
+        let frames = ClosureProcessHandler::new(frame as BoxedAudioHandler);
+        *state.write().unwrap() = Self::Active(client.activate_async(events, frames)?);
+        Ok(state)
+    }
+    /// Activate a connection with an application.
+    ///
+    /// * Wrap a [JackConnection::Inactive] into [Arc<RwLock<_>>].
+    /// * Pass it to the `init` callback
+    ///   * This allows user code to connect to JACK
+    ///   * While user code retains clone of the
+    ///     [Arc<RwLock<JackConnection>>] that is
+    ///     passed to `init`, the audio engine is running.
+    pub fn activate_with <T: Audio + 'static> (
+        self,
+        init: impl FnOnce(&Arc<RwLock<JackConnection>>)->Usually<T>
+    )
+        -> Usually<Arc<RwLock<T>>>
+    {
+        // Wrap self for multiple ownership.
+        let connection = Arc::new(RwLock::new(self));
+        // Run init callback. Return value is target. Target must retain clone of `connection`.
+        let target = Arc::new(RwLock::new(init(&connection)?));
+        // Swap the `client` from the `JackConnection::Inactive`
+        // for a `JackConnection::Activating`.
+        let mut client = Self::Activating;
+        std::mem::swap(&mut*connection.write().unwrap(), &mut client);
+        // Replace the `JackConnection::Activating` with a
+        // `JackConnection::Active` wrapping the [AsyncClient]
+        // returned by the activation.
+        *connection.write().unwrap() = Self::Active(Client::from(client).activate_async(
+            // This is the misc notifications handler. It's a struct that wraps a [Box]
+            // which performs type erasure on a callback that takes [JackEvent], which is
+            // one of the available misc notifications.
+            Notifications(Box::new(move|_|{/*TODO*/}) as BoxedJackEventHandler),
+            // This is the main processing handler. It's a struct that wraps a [Box]
+            // which performs type erasure on a callback that takes [Client] and [ProcessScope]
+            // and passes them down to the `target`'s `process` callback, which in turn
+            // implements audio and MIDI input and output on a realtime basis.
+            ClosureProcessHandler::new(Box::new({
+                let target = target.clone();
+                move|c: &_, s: &_|if let Ok(mut target) = target.write() {
+                    target.process(c, s)
+                } else {
+                    Control::Quit
+                }
+            }) as BoxedAudioHandler),
+        )?);
+        Ok(target)
+    }
+    pub fn port_by_name (&self, name: &str) -> Option<Port<Unowned>> {
+        self.client().port_by_name(name)
+    }
+    pub fn register_port <PS: PortSpec> (&self, name: &str, spec: PS) -> Usually<Port<PS>> {
+        Ok(self.client().register_port(name, spec)?)
+    }
+}

jack/src/jack_event.rs

@@ -0,0 +1,65 @@
+use crate::*;
+
+#[derive(Debug, Clone, PartialEq)]
+/// Event enum for JACK events.
+pub enum JackEvent {
+    ThreadInit,
+    Shutdown(ClientStatus, Arc<str>),
+    Freewheel(bool),
+    SampleRate(Frames),
+    ClientRegistration(Arc<str>, bool),
+    PortRegistration(PortId, bool),
+    PortRename(PortId, Arc<str>, Arc<str>),
+    PortsConnected(PortId, PortId, bool),
+    GraphReorder,
+    XRun,
+}
+
+/// Generic notification handler that emits [JackEvent]
+pub struct Notifications<T: Fn(JackEvent) + Send>(pub T);
+
+impl<T: Fn(JackEvent) + Send> NotificationHandler for Notifications<T> {
+    fn thread_init(&self, _: &Client) {
+        self.0(JackEvent::ThreadInit);
+    }
+
+    unsafe fn shutdown(&mut self, status: ClientStatus, reason: &str) {
+        self.0(JackEvent::Shutdown(status, reason.into()));
+    }
+
+    fn freewheel(&mut self, _: &Client, enabled: bool) {
+        self.0(JackEvent::Freewheel(enabled));
+    }
+
+    fn sample_rate(&mut self, _: &Client, frames: Frames) -> Control {
+        self.0(JackEvent::SampleRate(frames));
+        Control::Quit
+    }
+
+    fn client_registration(&mut self, _: &Client, name: &str, reg: bool) {
+        self.0(JackEvent::ClientRegistration(name.into(), reg));
+    }
+
+    fn port_registration(&mut self, _: &Client, id: PortId, reg: bool) {
+        self.0(JackEvent::PortRegistration(id, reg));
+    }
+
+    fn port_rename(&mut self, _: &Client, id: PortId, old: &str, new: &str) -> Control {
+        self.0(JackEvent::PortRename(id, old.into(), new.into()));
+        Control::Continue
+    }
+
+    fn ports_connected(&mut self, _: &Client, a: PortId, b: PortId, are: bool) {
+        self.0(JackEvent::PortsConnected(a, b, are));
+    }
+
+    fn graph_reorder(&mut self, _: &Client) -> Control {
+        self.0(JackEvent::GraphReorder);
+        Control::Continue
+    }
+
+    fn xrun(&mut self, _: &Client) -> Control {
+        self.0(JackEvent::XRun);
+        Control::Continue
+    }
+}

jack/src/jack_port.rs

@@ -0,0 +1,185 @@
+use crate::*;
+
+/// This is a utility trait for things that may register or connect [Port]s.
+/// It contains shorthand methods to this purpose. It's implemented for
+/// `Arc<RwLock<JackConnection>>` for terse port registration in the
+/// `init` callback of [JackClient::activate_with].
+pub trait RegisterPort {
+    fn midi_in   (&self, name: impl AsRef<str>, connect: &[impl AsRef<str>]) -> Usually<Port<MidiIn>>;
+    fn midi_out  (&self, name: impl AsRef<str>, connect: &[impl AsRef<str>]) -> Usually<Port<MidiOut>>;
+    fn audio_in  (&self, name: impl AsRef<str>, connect: &[impl AsRef<str>]) -> Usually<Port<AudioIn>>;
+    fn audio_out (&self, name: impl AsRef<str>, connect: &[impl AsRef<str>]) -> Usually<Port<AudioOut>>;
+}
+
+impl RegisterPort for Arc<RwLock<JackConnection>> {
+    fn midi_in (&self, name: impl AsRef<str>, connect: &[impl AsRef<str>]) -> Usually<Port<MidiIn>> {
+        let jack = self.read().unwrap();
+        let input = jack.client().register_port(name.as_ref(), MidiIn::default())?;
+        for port in connect.iter() {
+            let port = port.as_ref();
+            if let Some(output) = jack.port_by_name(port).as_ref() {
+                jack.client().connect_ports(output, &input)?;
+            } else {
+                panic!("Missing MIDI output: {port}. Use jack_lsp to list all port names.");
+            }
+        }
+        Ok(input)
+    }
+    fn midi_out (&self, name: impl AsRef<str>, connect: &[impl AsRef<str>]) -> Usually<Port<MidiOut>> {
+        let jack = self.read().unwrap();
+        let output = jack.client().register_port(name.as_ref(), MidiOut::default())?;
+        for port in connect.iter() {
+            let port = port.as_ref();
+            if let Some(input) = jack.port_by_name(port).as_ref() {
+                jack.client().connect_ports(&output, input)?;
+            } else {
+                panic!("Missing MIDI input: {port}. Use jack_lsp to list all port names.");
+            }
+        }
+        Ok(output)
+    }
+    fn audio_in (&self, name: impl AsRef<str>, connect: &[impl AsRef<str>]) -> Usually<Port<AudioIn>> {
+        let jack = self.read().unwrap();
+        let input = jack.client().register_port(name.as_ref(), AudioIn::default())?;
+        for port in connect.iter() {
+            let port = port.as_ref();
+            if let Some(output) = jack.port_by_name(port).as_ref() {
+                jack.client().connect_ports(output, &input)?;
+            } else {
+                panic!("Missing MIDI output: {port}. Use jack_lsp to list all port names.");
+            }
+        }
+        Ok(input)
+    }
+    fn audio_out (&self, name: impl AsRef<str>, connect: &[impl AsRef<str>]) -> Usually<Port<AudioOut>> {
+        let jack = self.read().unwrap();
+        let output = jack.client().register_port(name.as_ref(), AudioOut::default())?;
+        for port in connect.iter() {
+            let port = port.as_ref();
+            if let Some(input) = jack.port_by_name(port).as_ref() {
+                jack.client().connect_ports(&output, input)?;
+            } else {
+                panic!("Missing MIDI input: {port}. Use jack_lsp to list all port names.");
+            }
+        }
+        Ok(output)
+    }
+}
+
+///// Collection of JACK ports as [AudioIn]/[AudioOut]/[MidiIn]/[MidiOut].
+//#[derive(Default, Debug)]
+//pub struct JackPorts {
+    //pub audio_ins: BTreeMap<String, Port<AudioIn>>,
+    //pub midi_ins: BTreeMap<String, Port<MidiIn>>,
+    //pub audio_outs: BTreeMap<String, Port<AudioOut>>,
+    //pub midi_outs: BTreeMap<String, Port<MidiOut>>,
+//}
+
+///// Collection of JACK ports as [Unowned].
+//#[derive(Default, Debug)]
+//pub struct UnownedJackPorts {
+    //pub audio_ins: BTreeMap<String, Port<Unowned>>,
+    //pub midi_ins: BTreeMap<String, Port<Unowned>>,
+    //pub audio_outs: BTreeMap<String, Port<Unowned>>,
+    //pub midi_outs: BTreeMap<String, Port<Unowned>>,
+//}
+
+//impl JackPorts {
+    //pub fn clone_unowned(&self) -> UnownedJackPorts {
+        //let mut unowned = UnownedJackPorts::default();
+        //for (name, port) in self.midi_ins.iter() {
+            //unowned.midi_ins.insert(name.clone(), port.clone_unowned());
+        //}
+        //for (name, port) in self.midi_outs.iter() {
+            //unowned.midi_outs.insert(name.clone(), port.clone_unowned());
+        //}
+        //for (name, port) in self.audio_ins.iter() {
+            //unowned.audio_ins.insert(name.clone(), port.clone_unowned());
+        //}
+        //for (name, port) in self.audio_outs.iter() {
+            //unowned
+                //.audio_outs
+                //.insert(name.clone(), port.clone_unowned());
+        //}
+        //unowned
+    //}
+//}
+
+///// Implement the `Ports` trait.
+//#[macro_export]
+//macro_rules! ports {
+    //($T:ty $({ $(audio: {
+        //$(ins:  |$ai_arg:ident|$ai_impl:expr,)?
+        //$(outs: |$ao_arg:ident|$ao_impl:expr,)?
+    //})? $(midi: {
+        //$(ins:  |$mi_arg:ident|$mi_impl:expr,)?
+        //$(outs: |$mo_arg:ident|$mo_impl:expr,)?
+    //})?})?) => {
+        //impl Ports for $T {$(
+            //$(
+                //$(fn audio_ins <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+                    //let cb = |$ai_arg:&'a Self|$ai_impl;
+                    //cb(self)
+                //})?
+            //)?
+            //$(
+                //$(fn audio_outs <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+                    //let cb = (|$ao_arg:&'a Self|$ao_impl);
+                    //cb(self)
+                //})?
+            //)?
+        //)? $(
+            //$(
+                //$(fn midi_ins <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+                    //let cb = (|$mi_arg:&'a Self|$mi_impl);
+                    //cb(self)
+                //})?
+            //)?
+            //$(
+                //$(fn midi_outs <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+                    //let cb = (|$mo_arg:&'a Self|$mo_impl);
+                    //cb(self)
+                //})?
+            //)?
+        //)?}
+    //};
+//}
+
+/// Trait for things that may expose JACK ports.
+pub trait Ports {
+    fn audio_ins(&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(vec![])
+    }
+    fn audio_outs(&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(vec![])
+    }
+    fn midi_ins(&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(vec![])
+    }
+    fn midi_outs(&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(vec![])
+    }
+}
+
+fn register_ports<T: PortSpec + Copy>(
+    client: &Client,
+    names: Vec<String>,
+    spec: T,
+) -> Usually<BTreeMap<String, Port<T>>> {
+    names
+        .into_iter()
+        .try_fold(BTreeMap::new(), |mut ports, name| {
+            let port = client.register_port(&name, spec)?;
+            ports.insert(name, port);
+            Ok(ports)
+        })
+}
+
+fn query_ports(client: &Client, names: Vec<String>) -> BTreeMap<String, Port<Unowned>> {
+    names.into_iter().fold(BTreeMap::new(), |mut ports, name| {
+        let port = client.port_by_name(&name).unwrap();
+        ports.insert(name, port);
+        ports
+    })
+}
+

jack/src/lib.rs

@@ -0,0 +1,222 @@
+pub(crate) use std::sync::{Arc, RwLock};
+pub(crate) use std::collections::BTreeMap;
+
+pub use ::jack;
+pub(crate) use ::jack::{
+    contrib::ClosureProcessHandler, NotificationHandler,
+    Client, AsyncClient, ClientOptions, ClientStatus,
+    ProcessScope, Control, CycleTimes, Frames,
+    Port, PortId, PortSpec, Unowned, MidiIn, MidiOut, AudioIn, AudioOut,
+    Transport, TransportState, MidiIter, MidiWriter, RawMidi,
+};
+
+mod from_jack; pub use self::from_jack::*;
+mod jack_audio; pub use self::jack_audio::*;
+mod jack_connection; pub use self::jack_connection::*;
+mod jack_event; pub use self::jack_event::*;
+mod jack_port; pub use self::jack_port::*;
+
+pub(crate) type Usually<T> = Result<T, Box<dyn std::error::Error>>;
+
+////////////////////////////////////////////////////////////////////////////////////
+
+///// A [AudioComponent] bound to a JACK client and a set of ports.
+//pub struct JackDevice<E: Engine> {
+    ///// The active JACK client of this device.
+    //pub client: DynamicAsyncClient,
+    ///// The device state, encapsulated for sharing between threads.
+    //pub state: Arc<RwLock<Box<dyn AudioComponent<E>>>>,
+    ///// Unowned copies of the device's JACK ports, for connecting to the device.
+    ///// The "real" readable/writable `Port`s are owned by the `state`.
+    //pub ports: UnownedJackPorts,
+//}
+
+//impl<E: Engine> std::fmt::Debug for JackDevice<E> {
+    //fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        //f.debug_struct("JackDevice")
+            //.field("ports", &self.ports)
+            //.finish()
+    //}
+//}
+
+//impl<E: Engine> Render for JackDevice<E> {
+    //type Engine = E;
+    //fn min_size(&self, to: E::Size) -> Perhaps<E::Size> {
+        //self.state.read().unwrap().layout(to)
+    //}
+    //fn render(&self, to: &mut E::Output) -> Usually<()> {
+        //self.state.read().unwrap().render(to)
+    //}
+//}
+
+//impl<E: Engine> Handle<E> for JackDevice<E> {
+    //fn handle(&mut self, from: &E::Input) -> Perhaps<E::Handled> {
+        //self.state.write().unwrap().handle(from)
+    //}
+//}
+
+//impl<E: Engine> Ports for JackDevice<E> {
+    //fn audio_ins(&self) -> Usually<Vec<&Port<Unowned>>> {
+        //Ok(self.ports.audio_ins.values().collect())
+    //}
+    //fn audio_outs(&self) -> Usually<Vec<&Port<Unowned>>> {
+        //Ok(self.ports.audio_outs.values().collect())
+    //}
+    //fn midi_ins(&self) -> Usually<Vec<&Port<Unowned>>> {
+        //Ok(self.ports.midi_ins.values().collect())
+    //}
+    //fn midi_outs(&self) -> Usually<Vec<&Port<Unowned>>> {
+        //Ok(self.ports.midi_outs.values().collect())
+    //}
+//}
+
+//impl<E: Engine> JackDevice<E> {
+    ///// Returns a locked mutex of the state's contents.
+    //pub fn state(&self) -> LockResult<RwLockReadGuard<Box<dyn AudioComponent<E>>>> {
+        //self.state.read()
+    //}
+    ///// Returns a locked mutex of the state's contents.
+    //pub fn state_mut(&self) -> LockResult<RwLockWriteGuard<Box<dyn AudioComponent<E>>>> {
+        //self.state.write()
+    //}
+    //pub fn connect_midi_in(&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
+        //Ok(self
+            //.client
+            //.as_client()
+            //.connect_ports(port, self.midi_ins()?[index])?)
+    //}
+    //pub fn connect_midi_out(&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
+        //Ok(self
+            //.client
+            //.as_client()
+            //.connect_ports(self.midi_outs()?[index], port)?)
+    //}
+    //pub fn connect_audio_in(&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
+        //Ok(self
+            //.client
+            //.as_client()
+            //.connect_ports(port, self.audio_ins()?[index])?)
+    //}
+    //pub fn connect_audio_out(&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
+        //Ok(self
+            //.client
+            //.as_client()
+            //.connect_ports(self.audio_outs()?[index], port)?)
+    //}
+//}
+
+///// `JackDevice` factory. Creates JACK `Client`s, performs port registration
+///// and activation, and encapsulates a `AudioComponent` into a `JackDevice`.
+//pub struct Jack {
+    //pub client: Client,
+    //pub midi_ins: Vec<String>,
+    //pub audio_ins: Vec<String>,
+    //pub midi_outs: Vec<String>,
+    //pub audio_outs: Vec<String>,
+//}
+
+//impl Jack {
+    //pub fn new(name: &str) -> Usually<Self> {
+        //Ok(Self {
+            //midi_ins: vec![],
+            //audio_ins: vec![],
+            //midi_outs: vec![],
+            //audio_outs: vec![],
+            //client: Client::new(name, ClientOptions::NO_START_SERVER)?.0,
+        //})
+    //}
+    //pub fn run<'a: 'static, D, E>(
+        //self,
+        //state: impl FnOnce(JackPorts) -> Box<D>,
+    //) -> Usually<JackDevice<E>>
+    //where
+        //D: AudioComponent<E> + Sized + 'static,
+        //E: Engine + 'static,
+    //{
+        //let owned_ports = JackPorts {
+            //audio_ins: register_ports(&self.client, self.audio_ins, AudioIn::default())?,
+            //audio_outs: register_ports(&self.client, self.audio_outs, AudioOut::default())?,
+            //midi_ins: register_ports(&self.client, self.midi_ins, MidiIn::default())?,
+            //midi_outs: register_ports(&self.client, self.midi_outs, MidiOut::default())?,
+        //};
+        //let midi_outs = owned_ports
+            //.midi_outs
+            //.values()
+            //.map(|p| Ok(p.name()?))
+            //.collect::<Usually<Vec<_>>>()?;
+        //let midi_ins = owned_ports
+            //.midi_ins
+            //.values()
+            //.map(|p| Ok(p.name()?))
+            //.collect::<Usually<Vec<_>>>()?;
+        //let audio_outs = owned_ports
+            //.audio_outs
+            //.values()
+            //.map(|p| Ok(p.name()?))
+            //.collect::<Usually<Vec<_>>>()?;
+        //let audio_ins = owned_ports
+            //.audio_ins
+            //.values()
+            //.map(|p| Ok(p.name()?))
+            //.collect::<Usually<Vec<_>>>()?;
+        //let state = Arc::new(RwLock::new(state(owned_ports) as Box<dyn AudioComponent<E>>));
+        //let client = self.client.activate_async(
+            //Notifications(Box::new({
+                //let _state = state.clone();
+                //move |_event| {
+                    //// FIXME: this deadlocks
+                    ////state.lock().unwrap().handle(&event).unwrap();
+                //}
+            //}) as Box<dyn Fn(JackEvent) + Send + Sync>),
+            //ClosureProcessHandler::new(Box::new({
+                //let state = state.clone();
+                //move |c: &Client, s: &ProcessScope| state.write().unwrap().process(c, s)
+            //}) as BoxedAudioHandler),
+        //)?;
+        //Ok(JackDevice {
+            //ports: UnownedJackPorts {
+                //audio_ins: query_ports(&client.as_client(), audio_ins),
+                //audio_outs: query_ports(&client.as_client(), audio_outs),
+                //midi_ins: query_ports(&client.as_client(), midi_ins),
+                //midi_outs: query_ports(&client.as_client(), midi_outs),
+            //},
+            //client,
+            //state,
+        //})
+    //}
+    //pub fn audio_in(mut self, name: &str) -> Self {
+        //self.audio_ins.push(name.to_string());
+        //self
+    //}
+    //pub fn audio_out(mut self, name: &str) -> Self {
+        //self.audio_outs.push(name.to_string());
+        //self
+    //}
+    //pub fn midi_in(mut self, name: &str) -> Self {
+        //self.midi_ins.push(name.to_string());
+        //self
+    //}
+    //pub fn midi_out(mut self, name: &str) -> Self {
+        //self.midi_outs.push(name.to_string());
+        //self
+    //}
+//}
+
+///// A UI component that may be associated with a JACK client by the `Jack` factory.
+//pub trait AudioComponent<E: Engine>: Component<E> + Audio {
+    ///// Perform type erasure for collecting heterogeneous devices.
+    //fn boxed(self) -> Box<dyn AudioComponent<E>>
+    //where
+        //Self: Sized + 'static,
+    //{
+        //Box::new(self)
+    //}
+//}
+
+///// All things that implement the required traits can be treated as `AudioComponent`.
+//impl<E: Engine, W: Component<E> + Audio> AudioComponent<E> for W {}
+
+/////////
+
+/*
+*/