Struct CoreRc

pub struct CoreRc { /* private fields */ }

Reference counting smart pointer providing shared ownership of a PipeWire core.

For the non-owning variant, see CoreWeak. For unique ownership, see CoreBox.

For an explanation of these, see Smart pointers to PipeWire objects.

Implementations

impl CoreRc

pub fn from_raw(ptr: NonNull<pw_core>, context: ContextRc) -> Self

pub fn downgrade(&self) -> CoreWeak

pub fn get_registry_rc(&self) -> Result<RegistryRc, Error>

Methods from Deref<Target = Core>

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<RegistryBox<'_>, Error>

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

Do server roundtrip.

Ask the server to emit the done event with seq.

Since methods are handled in-order and events are delivered in-order, this can be used as a barrier to ensure all previous methods and the resulting events have been handled.

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<Core> for CoreRc

fn as_ref(&self) -> &Core

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

impl Clone for CoreRc

fn clone(&self) -> CoreRc

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CoreRc

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

Formats the value using the given formatter.

impl Deref for CoreRc

type Target = Core

The resulting type after dereferencing.

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

Dereferences the value.