[−][src]Crate async_i3ipc
async-i3ipc
This crate provides types and functions for working with i3's IPC protocol
in an async context and with async-std (tokio version here). It re-exports the subcrate i3ipc-types
because it is also used for a synchronous implementation of the protocol.
This library follows a similar API to the synchronous version. All important
functions live on the I3 type. You must first await
a
connect call, then you can execute
commands, send/read messages from i3, or subscribe to listen to Event
s.
Subscribe & Listen
use std::io; use async_i3ipc::{ event::{Event, Subscribe}, I3, }; #[async_std::main] async fn main() -> io::Result<()> { let mut i3 = I3::connect().await?; let resp = i3.subscribe([Subscribe::Window]).await?; println!("{:#?}", resp); let mut listener = i3.listen(); while let Ok(event) = listener.next().await { match event { Event::Workspace(ev) => println!("workspace change event {:?}", ev), Event::Window(ev) => println!("window event {:?}", ev), Event::Output(ev) => println!("output event {:?}", ev), Event::Mode(ev) => println!("mode event {:?}", ev), Event::BarConfig(ev) => println!("bar config update {:?}", ev), Event::Binding(ev) => println!("binding event {:?}", ev), Event::Shutdown(ev) => println!("shutdown event {:?}", ev), Event::Tick(ev) => println!("tick event {:?}", ev), } } Ok(()) }
Sending/Reading from I3
To send messages to i3,
call any of the get_*
functions on I3.
use std::io; use async_i3ipc::{reply, I3}; #[async_std::main] async fn main() -> io::Result<()> { let mut i3 = I3::connect().await?; // this type can be inferred, here is written explicitly: let tree: reply::Node = i3.get_tree().await?; println!("{:#?}", tree); Ok(()) }
All the get_*
functions on I3 are simple wrappers around
two main async functions. You could write any of them yourself, in fact:
use async_i3ipc::{msg, reply, MsgResponse, I3}; #[async_std::main] let mut i3 = I3::connect().await?; // send msg RunCommand with a payload let payload = "some_command"; i3.send_msg_body(msg::Msg::RunCommand, payload).await?; let resp: MsgResponse<Vec<reply::Success>> = i3.read_msg().await?;
Re-exports
pub use stream::EventStream; |
Modules
event | For subscribing and receiving events, each struct matches a particular
|
msg | For sending messages to i3 |
reply | Contains structs for deserializing messages from i3 |
stream |
Structs
I3 | Newtype wrapper for |
MsgResponse | Instead of returning an enum, we're returning a struct containing the |
Constants
MAGIC |
Traits
Connect | Types implementing this are provided a connect function and return a stream |
I3IPC | Trait containing methods to encode and decode message from i3 |
I3Protocol |
Functions
decode_event | Given an event type and payload this function will deserialize the proper struct |
decode_event_future | Decode a response into an Event |
decode_msg | Decode a response into a MsgResponse |
decode_response | Convenience function that decodes a single response and passes the type and undecoded buffer to a closure |
socket_path | get socket path from i3 |