Struct ListenerLocalBuilder

pub struct ListenerLocalBuilder<'a, D> { /* private fields */ }

A builder for registering stream event callbacks.

Use Stream::add_local_listener or Stream::add_local_listener_with_user_data to create this and register callbacks that will be called when events of interest occur. After adding callbacks, use register to get back a StreamListener.

Examples

let stream_listener = stream.add_local_listener::<()>()
    .state_changed(|_stream, _user_data, old, new| println!("Stream state changed from {old:?} to {new:?}"))
    .control_info(|_stream, _user_data, id, control| println!("Stream control info: id {id}, control {control:?}"))
    .io_changed(|_stream, _user_data, id, area, size| println!("Stream IO change: IO type {id}, area {area:?}, size {size}"))
    .param_changed(|_stream, _user_data, id, param| println!("Stream param change: id {id}, param {:?}",
        param.map(Pod::as_bytes)))
    .add_buffer(|_stream, _user_data, buffer| println!("Stream buffer added {buffer:?}"))
    .remove_buffer(|_stream, _user_data, buffer| println!("Stream buffer removed {buffer:?}"))
    .process(|stream, _user_data| {
        println!("Stream can be processed");
        let buf = stream.dequeue_buffer();
        // Produce or consume data using the buffer
        // The buffer is enqueued back to the stream when it's dropped
    })
    .drained(|_stream, _user_data| println!("Stream is drained"))
    .register();

Implementations

impl<'a, D> ListenerLocalBuilder<'a, D>

pub fn state_changed<F>(self, callback: F) -> Self

where F: FnMut(&Stream, &mut D, StreamState, StreamState) + 'static,

Set the stream state_changed event callback of the listener.

This event is emitted when the stream state changes.

Callback parameters

stream: The stream
data: User data
old: Old stream state
new: New stream state

Examples

let stream_listener = stream.add_local_listener::<()>()
    .state_changed(|_stream, _user_data, old, new| println!("Stream state changed from {old:?} to {new:?}"))
    .register();

pub fn control_info<F>(self, callback: F) -> Self

where F: FnMut(&Stream, &mut D, u32, *const pw_stream_control) + 'static,

Set the stream control_info event callback of the listener.

This event is emitted when there is information about a control.

Callback parameters

stream: The stream
user_data: User data
id: Type of the control
control: The control

Examples

let stream_listener = stream.add_local_listener::<()>()
    .control_info(|_stream, _user_data, id, _control| println!("Stream control info {id}"))
    .register();

pub fn io_changed<F>(self, callback: F) -> Self

where F: FnMut(&Stream, &mut D, u32, *mut c_void, u32) + 'static,

Set the stream io_changed event callback of the listener.

This event is emitted when IO is changed on the stream.

Callback parameters

stream: The stream
user_data: User data
id: Type of the IO area
area: The IO area
size: The IO area size

Examples

let stream_listener = stream.add_local_listener::<()>()
    .io_changed(|_stream, _user_data, id, _area, size| println!("Stream IO change: IO type {id}"))
    .register();

pub fn param_changed<F>(self, callback: F) -> Self

where F: FnMut(&Stream, &mut D, u32, Option<&Pod>) + 'static,

Set the stream param_changed event callback of the listener.

This event is emitted when a param is changed.

Callback parameters

stream: The stream
user_data: User data
id: Type of the param
param: The param

Examples

let stream_listener = stream.add_local_listener::<()>()
    .param_changed(|_stream, _user_data, id, param| println!("Stream param change: id {id}, param {:?}",
        param.map(Pod::as_bytes)))
    .register();

pub fn add_buffer<F>(self, callback: F) -> Self

where F: FnMut(&Stream, &mut D, *mut pw_buffer) + 'static,

Set the stream add_buffer event callback of the listener.

This event is emitted when a buffer was added for this stream.

Callback parameters

stream: The stream
user_data: User data
buffer: The buffer

Examples

let stream_listener = stream.add_local_listener::<()>()
    .add_buffer(|_stream, _user_data, buffer| println!("Stream buffer added {buffer:?}"))
    .register();

pub fn remove_buffer<F>(self, callback: F) -> Self

where F: FnMut(&Stream, &mut D, *mut pw_buffer) + 'static,

Set the stream remove_buffer event callback of the listener.

This event is emitted when a buffer was removed for this stream.

Callback parameters

stream: The stream
user_data: User data
buffer: The buffer

Examples

let stream_listener = stream.add_local_listener::<()>()
    .remove_buffer(|_stream, _user_data, buffer| println!("Stream buffer removed {buffer:?}"))
    .register();

pub fn process<F>(self, callback: F) -> Self

where F: FnMut(&Stream, &mut D) + 'static,

Set the stream process event callback of the listener.

This event is emitted when a buffer can be queued (for playback streams) or dequeued (for capture streams).

This is normally called from the mainloop but can also be called directly from the realtime data thread if the user is prepared to deal with this.

Callback parameters

stream: The stream
user_data: User data

Examples

let stream_listener = stream.add_local_listener::<()>()
    .process(|stream, _user_data| {
        println!("Stream can be processed");
        let buf = stream.dequeue_buffer();
        // Produce or consume data using the buffer
        // The buffer is enqueued back to the stream when it's dropped
    })
    .register();

pub fn drained<F>(self, callback: F) -> Self

where F: FnMut(&Stream, &mut D) + 'static,

Set the stream drained event callback of the listener.

This event is emitted when the stream is drained.

Callback parameters

stream: The stream
user_data: User data

Examples

let stream_listener = stream.add_local_listener::<()>()
    .drained(|_stream, _user_data| println!("Stream is drained"))
    .register();

pub fn register(self) -> Result<StreamListener<D>, Error>

Subscribe to events and register any provided callbacks.