loop: Add bindings for pw_loop.

This adds a `Loop` struct for creating and managing a `pw_loop` struct.

It also adds a `LoopRef` struct that is a transparent wrapper around `pw_loop`,
and can be obtained from both a `Loop` and `MainLoop`.

The methods previously on the loop trait are moved there, and the loop trait is now only responsible for obtaining
such a `LoopRef` from any loop.

Author: tom-a-wagner

pipewire/examples/pw-mon.rs

@@ -57,17 +57,21 @@ fn monitor(remote: Option<String>) -> Result<()> {
     let main_loop = pw::MainLoop::new()?;
 
     let main_loop_weak = main_loop.downgrade();
-    let _sig_int = main_loop.add_signal_local(Signal::SIGINT, move || {
-        if let Some(main_loop) = main_loop_weak.upgrade() {
-            main_loop.quit();
-        }
-    });
+    let _sig_int = main_loop
+        .as_loop()
+        .add_signal_local(Signal::SIGINT, move || {
+            if let Some(main_loop) = main_loop_weak.upgrade() {
+                main_loop.quit();
+            }
+        });
     let main_loop_weak = main_loop.downgrade();
-    let _sig_term = main_loop.add_signal_local(Signal::SIGTERM, move || {
-        if let Some(main_loop) = main_loop_weak.upgrade() {
-            main_loop.quit();
-        }
-    });
+    let _sig_term = main_loop
+        .as_loop()
+        .add_signal_local(Signal::SIGTERM, move || {
+            if let Some(main_loop) = main_loop_weak.upgrade() {
+                main_loop.quit();
+            }
+        });
 
     let context = pw::Context::new(&main_loop)?;
     let props = remote.map(|remote| {

pipewire/src/channel.rs

@@ -13,7 +13,7 @@
 // ignored because https://gitlab.freedesktop.org/pipewire/pipewire-rs/-/issues/19
 //! ```no_run
 //! use std::{time::Duration, sync::mpsc, thread};
-//! use pipewire::{MainLoop, Loop};
+//! use pipewire::{MainLoop, IsLoop};
 //!
 //! // Our message to the pipewire loop, this tells it to terminate.
 //! struct Terminate;
@@ -51,7 +51,7 @@
 //!     });
 //!
 //!     // Every 100ms, send `"Hello"` to the main thread.
-//!     let timer = mainloop.add_timer(move |_| {
+//!     let timer = mainloop.as_loop().add_timer(move |_| {
 //!         main_sender.send(String::from("Hello"));
 //!     });
 //!     timer.update_timer(
@@ -70,7 +70,7 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-use crate::{IoSource, Loop};
+use crate::{IoSource, IsLoop};
 use spa::flags::IoFlags;
 
 /// A receiver that has not been attached to a loop.
@@ -85,17 +85,17 @@ impl<T: 'static> Receiver<T> {
     ///
     /// This will make the loop call the callback with any messages that get sent to the receiver.
     #[must_use]
-    pub fn attach<F, L>(self, loop_: &L, callback: F) -> AttachedReceiver<T, L>
+    pub fn attach<F, L>(self, loop_: &L, callback: F) -> AttachedReceiver<T>
     where
         F: Fn(T) + 'static,
-        L: Loop,
+        L: IsLoop,
     {
         let channel = self.channel.clone();
         let eventfd = channel.lock().expect("Channel mutex lock poisoned").eventfd;
 
         // Attach the eventfd as an IO source to the loop.
         // Whenever the eventfd is signaled, call the users callback with each message in the queue.
-        let iosource = loop_.add_io(eventfd, IoFlags::IN, move |_| {
+        let iosource = loop_.as_loop().add_io(eventfd, IoFlags::IN, move |_| {
             let mut channel = channel.lock().expect("Channel mutex lock poisoned");
 
             // Read from the eventfd to make it block until written to again.
@@ -121,19 +121,17 @@ impl<T: 'static> Receiver<T> {
 /// A [`Receiver`] that has been attached to a loop.
 ///
 /// Dropping this will cause it to be deattached from the loop, so no more messages will be received.
-pub struct AttachedReceiver<'l, T, L>
+pub struct AttachedReceiver<'l, T>
 where
     T: 'static,
-    L: Loop,
 {
-    _source: IoSource<'l, RawFd, L>,
+    _source: IoSource<'l, RawFd>,
     receiver: Receiver<T>,
 }
 
-impl<'l, T, L> AttachedReceiver<'l, T, L>
+impl<'l, T> AttachedReceiver<'l, T>
 where
     T: 'static,
-    L: Loop,
 {
     /// Deattach the receiver from the loop.
     ///

pipewire/src/context.rs

@@ -5,21 +5,23 @@ use std::{os::unix::prelude::RawFd, ptr};
 
 use crate::core_::Core;
 use crate::error::Error;
-use crate::loop_::Loop;
+use crate::loop_::IsLoop;
 use crate::properties::Properties;
 
 #[derive(Debug)]
-pub struct Context<T: Loop + Clone> {
+pub struct Context<T: IsLoop + Clone> {
     ptr: ptr::NonNull<pw_sys::pw_context>,
     /// Store the loop here, so that the loop is not dropped before the context, which may lead to
     /// undefined behaviour.
     _loop: T,
 }
 
-impl<T: Loop + Clone> Context<T> {
+impl<T: IsLoop + Clone> Context<T> {
     fn new_internal(loop_: &T, properties: Option<Properties>) -> Result<Self, Error> {
         let props = properties.map_or(ptr::null(), |props| props.into_raw()) as *mut _;
-        let context = unsafe { pw_sys::pw_context_new(loop_.as_ptr(), props, 0) };
+        let context = unsafe {
+            pw_sys::pw_context_new(loop_.as_loop().as_raw() as *const _ as *mut _, props, 0)
+        };
         let context = ptr::NonNull::new(context).ok_or(Error::CreationFailed)?;
 
         Ok(Context {
@@ -63,7 +65,7 @@ impl<T: Loop + Clone> Context<T> {
     }
 }
 
-impl<T: Loop + Clone> Drop for Context<T> {
+impl<T: IsLoop + Clone> Drop for Context<T> {
     fn drop(&mut self) {
         unsafe { pw_sys::pw_context_destroy(self.as_ptr()) }
     }

pipewire/src/lib.rs

@@ -77,14 +77,14 @@
 //! For example, we can call a function on an interval:
 //!
 //! ```no_run
-//! // We also need to include the `Loop` trait for this.
-//! use pipewire::{MainLoop, Loop};
+//! // We also need to include the `IsLoop` trait for this.
+//! use pipewire::{MainLoop, IsLoop};
 //! use std::time::Duration;
 //!
 //! fn main() -> Result<(), Box<dyn std::error::Error>> {
 //!     let mainloop = MainLoop::new()?;
 //!
-//!     let timer = mainloop.add_timer(|_| println!("Hello"));
+//!     let timer = mainloop.as_loop().add_timer(|_| println!("Hello"));
 //!     // Call the first time in half a second, and then in a one second interval.
 //!     timer.update_timer(Some(Duration::from_millis(500)), Some(Duration::from_secs(1))).into_result()?;
 //!
@@ -95,7 +95,7 @@
 //! ```
 //! This program will print out "Hello" every second forever.
 //!
-//! You can also react to IO or Signals using similar methods on the [`Loop`] trait.
+//! Using similar methods, you can also react to IO or Signals, or call a callback whenever the loop is idle.
 //!
 //! ## Multithreading
 //! The pipewire library is not really thread-safe, so pipewire objects do not implement [`Send`](`std::marker::Send`)
@@ -146,7 +146,7 @@ mod utils;
 pub mod prelude {
     pub use spa::prelude::*;
 
-    pub use crate::loop_::Loop;
+    pub use crate::loop_::IsLoop;
     pub use crate::stream::ListenerBuilderT;
 }