Struct pipewire::Core

pub struct Core { /* private fields */ }

Methods from Deref<Target = CoreInner>

pub fn add_listener_local(&self) -> ListenerLocalBuilder<'_>

pub fn get_registry(&self) -> Result<Registry, Error>

pub fn sync(&self, seq: i32) -> Result<AsyncSeq, Error>

pub fn create_object<P: ProxyT, D: ReadableDict>( &self, factory_name: &str, properties: &D ) -> Result<P, Error>

Create a new object on the PipeWire server from a factory.

You will need specify what type you are expecting to be constructed by either using type inference or the turbofish syntax.

Parameters

• factory_name the name of the factory to use
• properties extra properties that the new object will have

Panics

If factory_name contains a null byte.

Returns

One of:

• Ok(P) on success, where P is the newly created object
• Err(Error::CreationFailed) if the object could not be created
• Err(Error::WrongProxyType) if the created type does not match the type P that the user is trying to create

Examples

Creating a new link:

use pipewire as pw;

pw::init();

let mainloop = pw::MainLoop::new().expect("Failed to create Pipewire Mainloop");
let context = pw::Context::new(&mainloop).expect("Failed to create Pipewire Context");
let core = context
    .connect(None)
    .expect("Failed to connect to Pipewire Core");

// This call uses turbofish syntax to specify that we want a link.
let link = core.create_object::<pw::link::Link, _>(
    // The actual name for a link factory might be different for your system,
    // you should probably obtain a factory from the registry.
    "link-factory",
    &pw::properties! {
        "link.output.port" => "1",
        "link.input.port" => "2",
        "link.output.node" => "3",
        "link.input.node" => "4"
    },
)
.expect("Failed to create object");

See pipewire/examples/create-delete-remote-objects.rs in the crates repository for a more detailed example.

pub fn destroy_object<P: ProxyT>(&self, proxy: P) -> Result<AsyncSeq, Error>

Destroy the object on the remote server represented by the provided proxy.

The proxy will be destroyed alongside the server side ressource, as it is no longer needed.

Trait Implementations

impl Clone for Core

fn clone(&self) -> Core

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Core

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

Formats the value using the given formatter.

impl Deref for Core

type Target = CoreInner

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.