use std::process::Stdio;
use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};
use pop_launcher::{GpuPreference, Indice, Request, Response};
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
use tokio::process::{Child, Command};
use tokio::sync::{Mutex, mpsc};
use crate::model::Item;
#[derive(Debug, thiserror::Error)]
pub enum Error {
#[error("failed to spawn the pop-launcher service")]
Spawn(#[source] std::io::Error),
#[error("pop-launcher stdin/stdout was not captured")]
MissingPipe,
}
#[derive(Debug, Clone)]
pub enum Event {
Update {
seq: u64,
query: String,
items: Vec<Item>,
},
Fill(String),
DesktopEntry {
path: std::path::PathBuf,
gpu_preference: GpuPreference,
action_name: Option<String>,
},
Context {
id: Indice,
options: Vec<pop_launcher::ContextOption>,
},
Close,
Disconnected,
}
#[derive(Clone, Debug)]
pub struct Launcher {
tx: mpsc::UnboundedSender<Request>,
last_query: Arc<Mutex<String>>,
seq: Arc<AtomicU64>,
}
impl Launcher {
pub fn spawn() -> Result<(Self, mpsc::UnboundedReceiver<Event>, LauncherGuard), Error> {
let mut child = Command::new("pop-launcher")
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::inherit())
.kill_on_drop(true)
.spawn()
.map_err(Error::Spawn)?;
let mut stdin = child.stdin.take().ok_or(Error::MissingPipe)?;
let stdout = child.stdout.take().ok_or(Error::MissingPipe)?;
let (request_tx, mut request_rx) = mpsc::unbounded_channel::<Request>();
let (event_tx, event_rx) = mpsc::unbounded_channel::<Event>();
let last_query = Arc::new(Mutex::new(String::new()));
let seq = Arc::new(AtomicU64::new(0));
tokio::spawn(async move {
while let Some(request) = request_rx.recv().await {
let Ok(mut line) = serde_json::to_vec(&request) else {
tracing::error!(?request, "failed to serialise launcher request");
continue;
};
line.push(b'\n');
if let Err(error) = stdin.write_all(&line).await {
tracing::warn!(%error, "pop-launcher stdin closed");
break;
}
if let Err(error) = stdin.flush().await {
tracing::warn!(%error, "failed to flush pop-launcher stdin");
break;
}
}
});
let reader_query = Arc::clone(&last_query);
let reader_seq = Arc::clone(&seq);
tokio::spawn(async move {
let mut lines = BufReader::new(stdout).lines();
loop {
match lines.next_line().await {
Ok(Some(line)) => {
let response: Response = match serde_json::from_str(&line) {
Ok(response) => response,
Err(error) => {
tracing::warn!(%error, %line, "undecodable launcher response");
continue;
}
};
let event = match response {
Response::Update(results) => {
let query = reader_query.lock().await.clone();
Event::Update {
seq: reader_seq.load(Ordering::Relaxed),
query,
items: results
.into_iter()
.map(Item::from_search_result)
.collect(),
}
}
Response::Fill(text) => Event::Fill(text),
Response::DesktopEntry {
path,
gpu_preference,
action_name,
} => Event::DesktopEntry {
path,
gpu_preference,
action_name,
},
Response::Context { id, options } => Event::Context { id, options },
Response::Close => Event::Close,
};
if event_tx.send(event).is_err() {
break;
}
}
Ok(None) => {
let _ = event_tx.send(Event::Disconnected);
break;
}
Err(error) => {
tracing::warn!(%error, "pop-launcher stdout read failed");
let _ = event_tx.send(Event::Disconnected);
break;
}
}
}
});
let launcher = Self {
tx: request_tx,
last_query,
seq,
};
Ok((launcher, event_rx, LauncherGuard { child }))
}
pub fn search(&self, query: impl Into<String>) -> u64 {
let query = query.into();
let seq = self.seq.fetch_add(1, Ordering::Relaxed) + 1;
let last_query = Arc::clone(&self.last_query);
let text = query.clone();
tokio::spawn(async move {
*last_query.lock().await = text;
});
self.send(Request::Search(query));
seq
}
pub fn activate(&self, id: Indice) {
self.send(Request::Activate(id));
}
pub fn complete(&self, id: Indice) {
self.send(Request::Complete(id));
}
pub fn context(&self, id: Indice) {
self.send(Request::Context(id));
}
pub fn activate_context(&self, id: Indice, context: Indice) {
self.send(Request::ActivateContext { id, context });
}
pub fn quit(&self, id: Indice) {
self.send(Request::Quit(id));
}
pub fn dismissed(&self) {
self.send(Request::Close);
}
pub fn interrupt(&self) {
self.send(Request::Interrupt);
}
fn send(&self, request: Request) {
if self.tx.send(request).is_err() {
tracing::warn!("pop-launcher request channel closed");
}
}
}
pub struct LauncherGuard {
child: Child,
}
impl LauncherGuard {
pub async fn shutdown(mut self) {
let _ = self.child.kill().await;
}
}