Session Items

WpSessionItem

GObject
    ╰──WpSessionItem
        ╰──WpSessionBin

Wp.SessionItem.prototype.activate

function Wp.SessionItem.prototype.activate(callback: Gio.AsyncReadyCallback, callback_data: Object): {
    // javascript wrapper for 'wp_session_item_activate'
}

Activates the item asynchronously. You can use Wp.SessionItem.prototype.activate_finish in the callback to get the result of this operation.

This internally starts a Wp.Transition that calls into vfunc_activate_get_next_step() and vfunc_activate_execute_step() to advance. If the transition fails, vfunc_activate_rollback() is called to reverse previous actions.

The default implementation of the above virtual functions activates the item successfully without doing anything. In order to implement a meaningful session item, you should override all 3 of them.

When this method is called, the Wp.SiFlags.ACTIVATING flag is set. When the operation finishes successfully, that flag is cleared and replaced with either Wp.SiFlags.ACTIVE or Wp.SiFlags.ACTIVATE_ERROR, depending on the success outcome of the operation. In order to clear Wp.SiFlags.ACTIVATE_ERROR, you can either call Wp.SessionItem.prototype.deactivate or Wp.SessionItem.prototype.activate to try activating again.

This method cannot be called if another operation (activation or export) is in progress (%WP_SI_FLAGS_MASK_OPERATION_IN_PROGRESS) or if the item is already activated.

Wp.SessionItem.prototype.activate_finish

function Wp.SessionItem.prototype.activate_finish(res: Gio.AsyncResult): {
    // javascript wrapper for 'wp_session_item_activate_finish'
}

Wp.SessionItem.prototype.clear_flag

function Wp.SessionItem.prototype.clear_flag(flag: Wp.SiFlags): {
    // javascript wrapper for 'wp_session_item_clear_flag'
}

Clears the specified flag from this item.

Note that bits 1-8 cannot be cleared using this function, they can only be changed internally.

Wp.SessionItem.prototype.configure

function Wp.SessionItem.prototype.configure(args: GLib.Variant): {
    // javascript wrapper for 'wp_session_item_configure'
}

Wp.SessionItem.prototype.deactivate

function Wp.SessionItem.prototype.deactivate(): {
    // javascript wrapper for 'wp_session_item_deactivate'
}

De-activates the item and/or cancels any ongoing activation operation.

If the item was not activated, this method does nothing.

Wp.SessionItem.prototype.export

function Wp.SessionItem.prototype.export(session: Wp.Session, callback: Gio.AsyncReadyCallback, callback_data: Object): {
    // javascript wrapper for 'wp_session_item_export'
}

Exports this item asynchronously on PipeWire, making it part of the specified session. You can use Wp.SessionItem.prototype.export_finish in the callback to get the result of this operation.

This internally starts a Wp.Transition that calls into vfunc_export_get_next_step() and vfunc_export_execute_step() to advance. If the transition fails, vfunc_export_rollback() is called to reverse previous actions.

Exporting is internally implemented for endpoints (items that implement Wp.SiEndpoint) and endpoint links (items that implement Wp.SiLink). On other items the default implementation will immediately call the callback, reporting error. You can extend this to export custom interfaces by overriding the virtual functions mentioned above.

When this method is called, the Wp.SiFlags.EXPORTING flag is set. When the operation finishes successfully, that flag is cleared and replaced with either Wp.SiFlags.EXPORTED or Wp.SiFlags.EXPORT_ERROR, depending on the success outcome of the operation. In order to clear Wp.SiFlags.EXPORT_ERROR, you can either call Wp.SessionItem.prototype.unexport or Wp.SessionItem.prototype.export to try exporting again.

This method cannot be called if another operation (activation or export) is in progress (%WP_SI_FLAGS_MASK_OPERATION_IN_PROGRESS) or if the item is already exported.

Wp.SessionItem.prototype.export_finish

function Wp.SessionItem.prototype.export_finish(res: Gio.AsyncResult): {
    // javascript wrapper for 'wp_session_item_export_finish'
}

Wp.SessionItem.prototype.get_associated_proxy

function Wp.SessionItem.prototype.get_associated_proxy(proxy_type: GObject.Type): {
    // javascript wrapper for 'wp_session_item_get_associated_proxy'
}

An associated proxy is a Wp.Proxy subclass instance that is somehow related to this item. For example:

• An exported Wp.SiEndpoint should have at least:
  • an associated Wp.Endpoint
  • an associated Wp.Session
• An exported Wp.SiStream should have at least:
  • an associated Wp.EndpointStream
  • an associated Wp.Endpoint
• In cases where the item wraps a single PipeWire node, it should also have an associated Wp.Node

Wp.SessionItem.prototype.get_associated_proxy_id

function Wp.SessionItem.prototype.get_associated_proxy_id(proxy_type: GObject.Type): {
    // javascript wrapper for 'wp_session_item_get_associated_proxy_id'
}

Wp.SessionItem.prototype.get_configuration

function Wp.SessionItem.prototype.get_configuration(): {
    // javascript wrapper for 'wp_session_item_get_configuration'
}

Wp.SessionItem.prototype.get_flags

function Wp.SessionItem.prototype.get_flags(): {
    // javascript wrapper for 'wp_session_item_get_flags'
}

Wp.SessionItem.prototype.get_parent

function Wp.SessionItem.prototype.get_parent(): {
    // javascript wrapper for 'wp_session_item_get_parent'
}

Gets the item's parent, which is the Wp.SessionBin this item has been added to, or NULL if the item does not belong to a session bin.

Wp.SessionItem.prototype.reset

function Wp.SessionItem.prototype.reset(): {
    // javascript wrapper for 'wp_session_item_reset'
}

Resets the state of the item, deactivating it, unexporting it and resetting configuration options as well.

Wp.SessionItem.prototype.set_flag

function Wp.SessionItem.prototype.set_flag(flag: Wp.SiFlags): {
    // javascript wrapper for 'wp_session_item_set_flag'
}

Sets the specified flag on this item.

Note that bits 1-8 cannot be set using this function, they can only be changed internally.

Wp.SessionItem.prototype.unexport

function Wp.SessionItem.prototype.unexport(): {
    // javascript wrapper for 'wp_session_item_unexport'
}

Reverses the effects of a previous call to Wp.SessionItem.prototype.export. This means that after this method is called:

• The item is no longer exported on PipeWire
• The item is no longer associated with a session
• If an export operation was in progress, it is cancelled.

If the item was not exported, this method does nothing.

Wp.SessionItem.prototype.make

function Wp.SessionItem.prototype.make(core: Wp.Core, factory_name: String): {
    // javascript wrapper for 'wp_session_item_make'
}

Finds the factory associated with the given name from the core and uses it to construct a new Wp.SessionItem.

flags-changed

function flags_changed_callback(self: Wp.SessionItem, flags: Wp.SiFlags, user_data: Object): {
    // javascript callback for the 'flags-changed' signal
}

Flags: Run Last

vfunc_activate_execute_step

function vfunc_activate_execute_step(self: Wp.SessionItem, transition: Wp.Transition, step: Number): {
    // javascript implementation of the 'activate_execute_step' virtual method
}

Implements vfunc_execute_step() for the transition of Wp.SessionItem.prototype.activate

vfunc_activate_get_next_step

function vfunc_activate_get_next_step(self: Wp.SessionItem, transition: Wp.Transition, step: Number): {
    // javascript implementation of the 'activate_get_next_step' virtual method
}

Implements vfunc_get_next_step() for the transition of Wp.SessionItem.prototype.activate

vfunc_activate_rollback

function vfunc_activate_rollback(self: Wp.SessionItem): {
    // javascript implementation of the 'activate_rollback' virtual method
}

Reverses any effects of the activation process; see Wp.SessionItem.prototype.activate

vfunc_configure

function vfunc_configure(self: Wp.SessionItem, args: GLib.Variant): {
    // javascript implementation of the 'configure' virtual method
}

See Wp.SessionItem.prototype.configure

vfunc_export_execute_step

function vfunc_export_execute_step(self: Wp.SessionItem, transition: Wp.Transition, step: Number): {
    // javascript implementation of the 'export_execute_step' virtual method
}

Implements vfunc_execute_step() for the transition of Wp.SessionItem.prototype.export

vfunc_export_get_next_step

function vfunc_export_get_next_step(self: Wp.SessionItem, transition: Wp.Transition, step: Number): {
    // javascript implementation of the 'export_get_next_step' virtual method
}

Implements vfunc_get_next_step() for the transition of Wp.SessionItem.prototype.export

vfunc_export_rollback

function vfunc_export_rollback(self: Wp.SessionItem): {
    // javascript implementation of the 'export_rollback' virtual method
}

Reverses any effects of the export process; see Wp.SessionItem.prototype.export

vfunc_get_associated_proxy

function vfunc_get_associated_proxy(self: Wp.SessionItem, proxy_type: GObject.Type): {
    // javascript implementation of the 'get_associated_proxy' virtual method
}

See Wp.SessionItem.prototype.get_associated_proxy

vfunc_get_configuration

function vfunc_get_configuration(self: Wp.SessionItem): {
    // javascript implementation of the 'get_configuration' virtual method
}

See Wp.SessionItem.prototype.get_configuration

vfunc_reset

function vfunc_reset(self: Wp.SessionItem): {
    // javascript implementation of the 'reset' virtual method
}

See Wp.SessionItem.prototype.reset

Wp.SiConfigOptionFlags

Wp.SiFlags

Wp.SI_FLAGS_MASK_OPERATION_IN_PROGRESS

A Wp.SiFlags mask that can be used to test if an async operation (activate or export) is currently in progress.