Struct Session 

pub struct Session<B: Backend> { /* private fields */ }

Devices held across VT switches.

Implementations

impl<B: Backend> Session<B>

pub fn new(backend: B) -> Self

Wrap a seat that is currently active.

Examples found in repository

examples/seat.rs (line 33)

fn main() {
    let paths: Vec<String> = std::env::args().skip(1).collect();

    let mut backend = match drmkit_session::LibseatBackend::open() {
        Ok(backend) => backend,
        Err(SessionError::NoBackend) => {
            println!("no seat here: not a login session, no seatd, no root TTY");
            return;
        }
        Err(error) => {
            eprintln!("seat: {error}");
            std::process::exit(1);
        }
    };

    println!("seat: {}", backend.name());
    let mut session = Session::new(backend);

    for path in &paths {
        match session.take_device(path) {
            Ok(device) => println!("  {path}: fd {}", device.fd),
            Err(error) => println!("  {path}: {error}"),
        }
    }

    if paths.is_empty() {
        println!("pass device paths to open some");
    }
}

pub const fn is_active(&self) -> bool

Whether the session currently owns the display.

pub fn devices(&self) -> &[TakenDevice]

The devices being held.

pub fn poll_fd(&self) -> Option<RawFd>

A descriptor to poll for seat activity.

pub fn take_device( &mut self, path: impl AsRef<Path>, ) -> Result<TakenDevice, SessionError>

Open a device through the seat and hold it.

Opening the same path twice returns what is already held rather than a second descriptor: the seat would give one, and then a resume would have two to reopen and the caller two to keep straight.

Errors

• SessionError::Inactive while the session does not own the display. The seat would refuse anyway; failing here says why.
• SessionError::Seat if the seat refuses.

Examples found in repository

examples/seat.rs (line 36)

fn main() {
    let paths: Vec<String> = std::env::args().skip(1).collect();

    let mut backend = match drmkit_session::LibseatBackend::open() {
        Ok(backend) => backend,
        Err(SessionError::NoBackend) => {
            println!("no seat here: not a login session, no seatd, no root TTY");
            return;
        }
        Err(error) => {
            eprintln!("seat: {error}");
            std::process::exit(1);
        }
    };

    println!("seat: {}", backend.name());
    let mut session = Session::new(backend);

    for path in &paths {
        match session.take_device(path) {
            Ok(device) => println!("  {path}: fd {}", device.fd),
            Err(error) => println!("  {path}: {error}"),
        }
    }

    if paths.is_empty() {
        println!("pass device paths to open some");
    }
}

pub fn release_device( &mut self, path: impl AsRef<Path>, ) -> Result<(), SessionError>

Give a device back to the seat.

Errors

• SessionError::UnknownDevice if this session did not open it.
• SessionError::Seat if the seat refuses.

pub fn switch_session(&mut self, session: i32) -> Result<(), SessionError>

Ask to switch to another session, by VT number.

Asynchronous: the seat pauses this session when it honors the request, and resumes it when the user comes back. Useful where the process owns the TTY in graphics mode and the kernel is no longer handling Ctrl+Alt+F<n> itself.

Errors

SessionError::Seat if the seat refuses.

pub fn dispatch(&mut self, timeout_ms: i32) -> Result<(), SessionError>

Let the seat deliver what it has, turning it into events to act on.

A negative timeout blocks. Call Session::next_event afterwards.

The reference runs the caller’s callbacks synchronously from inside this call, which means the caller is re-entering the seat from inside the seat’s own dispatch. Queuing instead keeps that from being possible.

A device that cannot be reopened on resume is not an error here: it is reported as a SessionEvent::DeviceLost, and the rest come back.

Errors

SessionError::Seat if the seat refuses to dispatch or to acknowledge a pause.

pub fn next_event(&mut self) -> Option<SessionEvent>

The next thing the caller has to act on.

Trait Implementations

impl<B: Debug + Backend> Debug for Session<B>

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

Formats the value using the given formatter.