Struct wayland_protocols::ext::session_lock::v1::client::ext_session_lock_v1::ExtSessionLockV1
source · pub struct ExtSessionLockV1 {
id: ObjectId,
version: u32,
data: Option<Arc<dyn ObjectData>>,
backend: WeakBackend,
}
Expand description
manage lock state and create lock surfaces
In response to the creation of this object the compositor must send either the locked or finished event.
The locked event indicates that the session is locked. This means that the compositor must stop rendering and providing input to normal clients. Instead the compositor must blank all outputs with an opaque color such that their normal content is fully hidden.
The only surfaces that should be rendered while the session is locked are the lock surfaces created through this interface and optionally, at the compositor’s discretion, special privileged surfaces such as input methods or portions of desktop shell UIs.
The locked event must not be sent until a new “locked” frame (either from a session lock surface or the compositor blanking the output) has been presented on all outputs and no security sensitive normal/unlocked content is possibly visible.
The finished event should be sent immediately on creation of this object if the compositor decides that the locked event will not be sent.
The compositor may wait for the client to create and render session lock surfaces before sending the locked event to avoid displaying intermediate blank frames. However, it must impose a reasonable time limit if waiting and send the locked event as soon as the hard requirements described above can be met if the time limit expires. Clients should immediately create lock surfaces for all outputs on creation of this object to make this possible.
This behavior of the locked event is required in order to prevent possible race conditions with clients that wish to suspend the system or similar after locking the session. Without these semantics, clients triggering a suspend after receiving the locked event would race with the first “locked” frame being presented and normal/unlocked frames might be briefly visible as the system is resumed if the suspend operation wins the race.
If the client dies while the session is locked, the compositor must not unlock the session in response. It is acceptable for the session to be permanently locked if this happens. The compositor may choose to continue to display the lock surfaces the client had mapped before it died or alternatively fall back to a solid color, this is compositor policy.
Compositors may also allow a secure way to recover the session, the details of this are compositor policy. Compositors may allow a new client to create a ext_session_lock_v1 object and take responsibility for unlocking the session, they may even start a new lock client instance automatically.
See also the Event enum for this interface.
Fields§
§id: ObjectId
§version: u32
§data: Option<Arc<dyn ObjectData>>
§backend: WeakBackend
Implementations§
source§impl ExtSessionLockV1
impl ExtSessionLockV1
sourcepub fn destroy(&self)
pub fn destroy(&self)
destroy the session lock
This informs the compositor that the lock object will no longer be used. Existing objects created through this interface remain valid.
After this request is made, lock surfaces created through this object should be destroyed by the client as they will no longer be used by the compositor.
It is a protocol error to make this request if the locked event was sent, the unlock_and_destroy request must be used instead.
sourcepub fn get_lock_surface<U: Send + Sync + 'static, D: Dispatch<ExtSessionLockSurfaceV1, U> + 'static>(
&self,
surface: &WlSurface,
output: &WlOutput,
qh: &QueueHandle<D>,
udata: U,
) -> ExtSessionLockSurfaceV1
pub fn get_lock_surface<U: Send + Sync + 'static, D: Dispatch<ExtSessionLockSurfaceV1, U> + 'static>( &self, surface: &WlSurface, output: &WlOutput, qh: &QueueHandle<D>, udata: U, ) -> ExtSessionLockSurfaceV1
create a lock surface for a given output
The client is expected to create lock surfaces for all outputs currently present and any new outputs as they are advertised. These won’t be displayed by the compositor unless the lock is successful and the locked event is sent.
Providing a wl_surface which already has a role or already has a buffer attached or committed is a protocol error, as is attaching/committing a buffer before the first ext_session_lock_surface_v1.configure event.
Attempting to create more than one lock surface for a given output is a duplicate_output protocol error.
sourcepub fn unlock_and_destroy(&self)
pub fn unlock_and_destroy(&self)
unlock the session, destroying the object
This request indicates that the session should be unlocked, for example because the user has entered their password and it has been verified by the client.
This request also informs the compositor that the lock object will no longer be used and should be destroyed. Existing objects created through this interface remain valid.
After this request is made, lock surfaces created through this object should be destroyed by the client as they will no longer be used by the compositor.
It is a protocol error to make this request if the locked event has not been sent. In that case, the lock object must be destroyed using the destroy request.
Note that a correct client that wishes to exit directly after unlocking the session must use the wl_display.sync request to ensure the server receives and processes the unlock_and_destroy request. Otherwise there is no guarantee that the server has unlocked the session due to the asynchronous nature of the Wayland protocol. For example, the server might terminate the client with a protocol error before it processes the unlock_and_destroy request.
Trait Implementations§
source§impl Borrow<ObjectId> for ExtSessionLockV1
impl Borrow<ObjectId> for ExtSessionLockV1
source§impl Clone for ExtSessionLockV1
impl Clone for ExtSessionLockV1
source§fn clone(&self) -> ExtSessionLockV1
fn clone(&self) -> ExtSessionLockV1
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl Debug for ExtSessionLockV1
impl Debug for ExtSessionLockV1
source§impl Hash for ExtSessionLockV1
impl Hash for ExtSessionLockV1
source§impl PartialEq<Weak<ExtSessionLockV1>> for ExtSessionLockV1
impl PartialEq<Weak<ExtSessionLockV1>> for ExtSessionLockV1
source§impl PartialEq for ExtSessionLockV1
impl PartialEq for ExtSessionLockV1
source§fn eq(&self, other: &ExtSessionLockV1) -> bool
fn eq(&self, other: &ExtSessionLockV1) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl Proxy for ExtSessionLockV1
impl Proxy for ExtSessionLockV1
source§fn data<U: Send + Sync + 'static>(&self) -> Option<&U>
fn data<U: Send + Sync + 'static>(&self) -> Option<&U>
source§fn object_data(&self) -> Option<&Arc<dyn ObjectData>>
fn object_data(&self) -> Option<&Arc<dyn ObjectData>>
source§fn backend(&self) -> &WeakBackend
fn backend(&self) -> &WeakBackend
source§fn send_request(&self, req: Self::Request<'_>) -> Result<(), InvalidId>
fn send_request(&self, req: Self::Request<'_>) -> Result<(), InvalidId>
source§fn send_constructor<I: Proxy>(
&self,
req: Self::Request<'_>,
data: Arc<dyn ObjectData>,
) -> Result<I, InvalidId>
fn send_constructor<I: Proxy>( &self, req: Self::Request<'_>, data: Arc<dyn ObjectData>, ) -> Result<I, InvalidId>
source§fn from_id(conn: &Connection, id: ObjectId) -> Result<Self, InvalidId>
fn from_id(conn: &Connection, id: ObjectId) -> Result<Self, InvalidId>
source§fn inert(backend: WeakBackend) -> Self
fn inert(backend: WeakBackend) -> Self
source§fn parse_event(
conn: &Connection,
msg: Message<ObjectId, OwnedFd>,
) -> Result<(Self, Self::Event), DispatchError>
fn parse_event( conn: &Connection, msg: Message<ObjectId, OwnedFd>, ) -> Result<(Self, Self::Event), DispatchError>
source§fn write_request<'a>(
&self,
conn: &Connection,
msg: Self::Request<'a>,
) -> Result<(Message<ObjectId, BorrowedFd<'a>>, Option<(&'static Interface, u32)>), InvalidId>
fn write_request<'a>( &self, conn: &Connection, msg: Self::Request<'a>, ) -> Result<(Message<ObjectId, BorrowedFd<'a>>, Option<(&'static Interface, u32)>), InvalidId>
impl Eq for ExtSessionLockV1
Auto Trait Implementations§
impl Freeze for ExtSessionLockV1
impl !RefUnwindSafe for ExtSessionLockV1
impl Send for ExtSessionLockV1
impl Sync for ExtSessionLockV1
impl Unpin for ExtSessionLockV1
impl !UnwindSafe for ExtSessionLockV1
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
.source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.