Struct CoreBox

pub struct CoreBox<'c> { /* private fields */ }

Implementations

impl<'c> CoreBox<'c>

pub unsafe fn from_raw(raw: NonNull<pw_core>) -> CoreBox<'c>

Create a CoreBox by taking ownership of a raw pw_core.

Safety

The provided pointer must point to a valid, well aligned pw_core.

The raw core must not be manually destroyed or moved, as the new CoreBox takes ownership of it.

The lifetime of the returned box is unbounded. The caller is responsible to make sure that the context used with this core outlives the core.

pub fn into_raw(self) -> NonNull<pw_core>

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>

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<'c> AsRef<Core> for CoreBox<'c>

fn as_ref(&self) -> &Core

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

impl<'c> Debug for CoreBox<'c>

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

Formats the value using the given formatter.

impl<'c> Deref for CoreBox<'c>

type Target = Core

The resulting type after dereferencing.

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

Dereferences the value.

impl<'c> Drop for CoreBox<'c>

fn drop(&mut self)

Executes the destructor for this type.