use calloop::{InsertError, LoopHandle, RegistrationToken};
use calloop_wayland_source::WaylandSource;
use wayland_client::{Connection, DispatchError, EventQueue};
pub(crate) fn insert_source<State: 'static>(
handle: &LoopHandle<'static, ()>,
connection: Connection,
queue: EventQueue<State>,
mut state: State,
) -> Result<RegistrationToken, InsertError<WaylandSource<State>>> {
handle.insert_source(
WaylandSource::new(connection.clone(), queue),
move |_, queue, _| dispatch_pending(&connection, queue, &mut state),
)
}
pub(crate) fn dispatch_pending<State>(
connection: &Connection,
queue: &mut EventQueue<State>,
state: &mut State,
) -> Result<usize, DispatchError> {
let dispatched = queue.dispatch_pending(state)?;
match connection.backend().last_error() {
Some(error) => Err(DispatchError::Backend(error)),
None => Ok(dispatched),
}
}
#[cfg(test)]
mod tests {
use std::io::Write as _;
use std::os::unix::net::UnixStream;
use std::time::Duration;
use calloop::EventLoop;
use wayland_client::protocol::wl_registry::{self, WlRegistry};
use wayland_client::{Connection, Dispatch, QueueHandle};
struct State;
impl Dispatch<WlRegistry, ()> for State {
fn event(
_: &mut Self,
_: &WlRegistry,
_: wl_registry::Event,
_: &(),
_: &Connection,
_: &QueueHandle<Self>,
) {
}
}
fn display_error(message: &str) -> Vec<u8> {
let mut text = message.as_bytes().to_vec();
text.push(0);
let length = text.len() as u32;
text.resize(text.len().next_multiple_of(4), 0);
let size = 8 + 12 + text.len() as u32;
let mut event = Vec::new();
for word in [1, size << 16, 2, 0, length] {
event.extend_from_slice(&u32::to_ne_bytes(word));
}
event.extend_from_slice(&text);
event
}
#[test]
fn a_protocol_error_ends_the_event_loop() {
let (client, mut server) = UnixStream::pair().unwrap();
let connection = Connection::from_socket(client).unwrap();
let queue = connection.new_event_queue::<State>();
let _registry = connection.display().get_registry(&queue.handle(), ());
connection.flush().unwrap();
server
.write_all(&display_error("invalid global wl_output (42)"))
.unwrap();
let mut event_loop = EventLoop::<()>::try_new().unwrap();
super::insert_source(&event_loop.handle(), connection, queue, State).unwrap();
let ended = (0..100).any(|_| {
event_loop
.dispatch(Duration::from_millis(10), &mut ())
.is_err()
});
assert!(ended, "the event loop kept running on a broken connection");
drop(server);
}
}