Struct PortalSession 

pub struct PortalSession {

    conn: Connection,
    screencast: Proxy<'static>,
    remote: Option<Proxy<'static>>,
    session: OwnedObjectPath,
    pub streams: Vec<PortalStream>,
    pub devices: u32,
    pub cursor_mode: u32,
    pub restore_token: Option<String>,
    pub rd_version: u32,
    kde: bool,
    pub mutter: bool,
    armed: bool,
    notify_tx: OnceLock<Sender<(&'static str, Box<dyn FnOnce(&Proxy<'static>) + Send>)>>,
}

A started portal session: its streams, the devices it may drive, and the token that restores it without a dialog.

Fields

conn: Connection

screencast: Proxy<'static>

remote: Option<Proxy<'static>>

session: OwnedObjectPath

streams: Vec<PortalStream>

devices: u32

cursor_mode: u32

restore_token: Option<String>

rd_version: u32

RemoteDesktop interface version, 0 when the session drives no input. ConnectToEIS exists from version 2.

kde: bool

KDE’s backend serves the session: it reads a smooth scroll’s vertical axis negated.

mutter: bool

Mutter’s remote-desktop service runs on the session bus, which every GNOME backend hands input to: it reads NotifyPointerMotionAbsolute in the stream’s pixels, which xdg-desktop-portal-gnome passes the spec’s logical point on as.

armed: bool

Whether dropping the session closes it on the portal: not while open still runs it inside its zbus::block_on, which a second one inside would panic on.

notify_tx: OnceLock<Sender<(&'static str, Box<dyn FnOnce(&Proxy<'static>) + Send>)>>

The input thread’s queue, from the first Notify* call on.

Implementations

impl PortalSession

pub fn open( capture: bool, devices: u32, cursor_mode: u32, restore_token: Option<&str>, ) -> Result<Self, String>

Open and start a session. devices (DEVICE_* bits) selects what input the session drives — zero opens a plain ScreenCast session; capture asks for every monitor as its own stream with cursor_mode (CURSOR_*), downgraded to what the portal offers. The call returns once the portal (and any dialog it shows) has answered; a session the portal created before a later step failed is closed before the error returns.

async fn connect(devices: u32, cursor_mode: u32) -> Result<Self, String>

The session bus and the portal interfaces a session with devices speaks to, before any session exists.

async fn start( &mut self, capture: bool, devices: u32, restore_token: Option<&str>, ) -> Result<(), String>

Create the session, select its sources and devices, and start it (open).

pub fn probe() -> Result<(), String>

Whether a ScreenCast portal answers on the session bus; the error says which step did not, since a bus nobody listens on and a portal without a backend read the same.

async fn request( &self, method: &str, options: HashMap<&'_ str, Variant<'_>>, call: impl AsyncFnOnce(&HashMap<&'_ str, Variant<'_>>) -> Result<OwnedObjectPath>, ) -> Result<(u32, HashMap<String, OwnedVariant>), String>

A method whose result arrives as a Response on a request object: subscribe to the request path the handle token names before the call call makes with the completed options, then wait for the answer.

pub fn eis_capable(&self) -> bool

Whether this session can hand out an EIS socket: a RemoteDesktop session (input was granted) on a backend new enough to carry ConnectToEIS.

pub fn connect_to_eis(&self) -> Result<OwnedFd, String>

The EIS socket for this session’s seat. A backend that answers hands input over libei from here on and refuses the Notify* methods, so this is called once, at open, and only when the injector is committed to.

pub fn open_pipewire_remote(&self) -> Result<OwnedFd, String>

The PipeWire connection the streams live on, opened by the portal with the node permissions of this session.

fn notify<B>(&self, method: &'static str, args: B)

where B: Serialize + DynamicType + Send + 'static,

Queue a Notify* call for the input thread, started by the first.

pub fn pointer_motion_abs(&self, node: u32, x: f64, y: f64)

Absolute pointer motion in the logical coordinate space of the stream node, the size it announced: the portal frontend refuses a point outside that size.

pub fn pointer_motion(&self, dx: f64, dy: f64)

pub fn pointer_button(&self, button: i32, pressed: bool)

Button by evdev code.

pub fn pointer_axis(&self, dx: f64, dy: f64, finish: bool)

Smooth scroll by logical pixels, positive down and right as on wl_pointer; finish closes the scroll series. KDE’s backend negates the vertical axis it is handed and drops finish (xdg-desktop-portal-kde’s requestPointerAxis, 5.27 through master), where GNOME’s passes both on, so it is handed the axis negated.

pub fn pointer_axis_discrete(&self, axis: u32, steps: i32)

Wheel steps: axis 0 vertical, 1 horizontal.

pub fn keysym(&self, keysym: i32, pressed: bool)

pub fn keycode(&self, keycode: i32, pressed: bool)

Key by evdev keycode, in the host’s own layout.

impl PortalSession

async fn close(&self)

Close the session on the portal, if one was created.

Trait Implementations

impl Drop for PortalSession

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.