merge jack::client into jack

need to remove AudioEngine trait and register callbacks manually

src/jack.rs

@@ -13,10 +13,6 @@ pub mod activate;
 pub(crate) use self::activate::*;
 pub use self::activate::JackActivate;
 
-pub mod client;
-pub(crate) use self::client::*;
-pub use self::client::JackConnection;
-
 pub mod jack_event;
 pub(crate) use self::jack_event::*;
 
@@ -61,56 +57,69 @@ pub trait Audio: Send + Sync {
     }
 }
 
+pub type DynamicAsyncClient = AsyncClient<DynamicNotifications, DynamicAudioHandler>;
 
-/// Trait for things that wrap a JACK client.
+pub type DynamicAudioHandler = ClosureProcessHandler<(), BoxedAudioHandler>;
-pub trait AudioEngine {
 
-    fn transport (&self) -> Transport {
+pub type BoxedAudioHandler = Box<dyn FnMut(&Client, &ProcessScope) -> Control + Send>;
-        self.client().transport()
+
+/// Wraps [Client] or [DynamicAsyncClient] in place.
+#[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),
+}
+
+from!(|jack: JackConnection|Client = 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.
-    fn port_by_name (&self, name: &str) -> Option<Port<Unowned>> {
+    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(),
+        }
+    }
+    /// Bind a process callback to a `JackConnection::Inactive`,
+    /// consuming it and returning a `JackConnection::Active`.
+    ///
+    /// Needs work. Strange ownership situation between the callback
+    /// and the host object.
+    pub 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)
+    }
+    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>> {
-    fn register_port <PS: PortSpec> (&self, name: &str, spec: PS) -> Usually<Port<PS>> {
         Ok(self.client().register_port(name, spec)?)
     }
-
-    fn client (&self) -> &Client;
-
-    fn activate (
-        self,
-        process: impl FnMut(&Arc<RwLock<Self>>, &Client, &ProcessScope) -> Control + Send + 'static
-    ) -> Usually<Arc<RwLock<Self>>> where Self: Send + Sync + 'static;
-
-    fn thread_init (&self, _: &Client) {}
-
-    unsafe fn shutdown (&mut self, _status: ClientStatus, _reason: &str) {}
-
-    fn freewheel (&mut self, _: &Client, _enabled: bool) {}
-
-    fn client_registration (&mut self, _: &Client, _name: &str, _reg: bool) {}
-
-    fn port_registration (&mut self, _: &Client, _id: PortId, _reg: bool) {}
-
-    fn ports_connected (&mut self, _: &Client, _a: PortId, _b: PortId, _are: bool) {}
-
-    fn sample_rate (&mut self, _: &Client, _frames: Frames) -> Control {
-        Control::Continue
-    }
-
-    fn port_rename (&mut self, _: &Client, _id: PortId, _old: &str, _new: &str) -> Control {
-        Control::Continue
-    }
-
-    fn graph_reorder (&mut self, _: &Client) -> Control {
-        Control::Continue
-    }
-
-    fn xrun (&mut self, _: &Client) -> Control {
-        Control::Continue
-    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////
@@ -375,3 +384,17 @@ pub trait AudioEngine {
         //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 {}

src/jack/activate.rs

@@ -34,17 +34,3 @@ impl JackActivate for JackConnection {
         Ok(target)
     }
 }
-
-/// 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 {}

src/jack/client.rs

@@ -1,55 +0,0 @@
-use crate::*;
-pub type DynamicAsyncClient = AsyncClient<DynamicNotifications, DynamicAudioHandler>;
-pub type DynamicAudioHandler = ClosureProcessHandler<(), BoxedAudioHandler>;
-pub type BoxedAudioHandler = Box<dyn FnMut(&Client, &ProcessScope) -> Control + Send>;
-/// Wraps [Client] or [DynamicAsyncClient] in place.
-#[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),
-}
-from!(|jack: JackConnection|Client = 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))
-    }
-}
-impl AudioEngine for JackConnection {
-    /// Return the internal [Client] handle that lets you call the JACK API.
-    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(),
-        }
-    }
-    /// Bind a process callback to a `JackConnection::Inactive`,
-    /// turning it into 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)
-    }
-}