Struct pipewire::core::Core

pub struct Core { /* private fields */ }

Methods from Deref<Target = CoreRef>

pub fn as_raw(&self) -> &pw_core

pub fn as_raw_ptr(&self) -> *mut pw_core

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>( &self, factory_name: &str, properties: &impl AsRef<DictRef> ) -> 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 create_object_cstr<P: ProxyT>( &self, factory_name: &CStr, properties: &impl AsRef<DictRef> ) -> Result<P, Error>

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 resource, as it is no longer needed.

Trait Implementations

impl AsRef<CoreRef> for Core

fn as_ref(&self) -> &CoreRef

Converts this type into a shared reference of the (usually inferred) input type.

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 = CoreRef

The resulting type after dereferencing.

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

Dereferences the value.