bstein/lesavka
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(launcher): use high-quality breakout previews

Browse Source
This commit is contained in:
Brad Stein 2026-04-15 12:20:02 -03:00
parent ae46daa6f8
commit e1092afee2
3 changed files with 303 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

270
client/src/launcher/preview.rs
View File

@ -9,15 +9,15 @@ use gstreamer_app as gst_app;
#[cfg(not(coverage))] #[cfg(not(coverage))]
use gtk::{gdk, glib}; use gtk::{gdk, glib};
#[cfg(not(coverage))] #[cfg(not(coverage))]
use lesavka_common::lesavka::{relay_client::RelayClient, MonitorRequest, VideoPacket}; use lesavka_common::lesavka::{MonitorRequest, VideoPacket, relay_client::RelayClient};
#[cfg(not(coverage))] #[cfg(not(coverage))]
use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
#[cfg(not(coverage))] #[cfg(not(coverage))]
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
#[cfg(not(coverage))] #[cfg(not(coverage))]
use std::time::Duration; use std::time::Duration;
#[cfg(not(coverage))] #[cfg(not(coverage))]
use tonic::{transport::Channel, Request}; use tonic::{Request, transport::Channel};
#[cfg(not(coverage))] #[cfg(not(coverage))]
use tracing::{debug, warn}; use tracing::{debug, warn};
@ -31,7 +31,8 @@ const PREVIEW_IDLE_STATUS: &str = "Connect relay to preview.";
#[cfg(not(coverage))] #[cfg(not(coverage))]
pub struct LauncherPreview { pub struct LauncherPreview {
server_addr: Arc<Mutex<String>>, server_addr: Arc<Mutex<String>>,
feeds: [PreviewFeed; 2], inline_feeds: [PreviewFeed; 2],
window_feeds: [PreviewFeed; 2],
} }
#[cfg(not(coverage))] #[cfg(not(coverage))]
@ -39,6 +40,40 @@ pub struct LauncherPreview {
pub struct PreviewBinding { pub struct PreviewBinding {
enabled: Arc<AtomicBool>, enabled: Arc<AtomicBool>,
alive: Arc<AtomicBool>, alive: Arc<AtomicBool>,
active_bindings: Arc<AtomicUsize>,
}
#[cfg(not(coverage))]
#[derive(Clone, Copy, Debug)]
pub enum PreviewSurface {
Inline,
Window,
}
#[cfg(not(coverage))]
#[derive(Clone, Copy, Debug)]
struct PreviewProfile {
width: i32,
height: i32,
max_bitrate_kbit: u32,
}
#[cfg(not(coverage))]
impl PreviewSurface {
fn profile(self) -> PreviewProfile {
match self {
Self::Inline => PreviewProfile {
width: preview_dimension("LESAVKA_PREVIEW_WIDTH", PREVIEW_WIDTH),
height: preview_dimension("LESAVKA_PREVIEW_HEIGHT", PREVIEW_HEIGHT),
max_bitrate_kbit: preview_bitrate("LESAVKA_PREVIEW_MAX_KBIT", 2_500),
},
Self::Window => PreviewProfile {
width: preview_dimension("LESAVKA_BREAKOUT_PREVIEW_WIDTH", 1280),
height: preview_dimension("LESAVKA_BREAKOUT_PREVIEW_HEIGHT", 720),
max_bitrate_kbit: preview_bitrate("LESAVKA_BREAKOUT_PREVIEW_MAX_KBIT", 8_000),
},
}
}
} }
#[cfg(not(coverage))] #[cfg(not(coverage))]
@ -48,9 +83,13 @@ impl LauncherPreview {
let server_addr = Arc::new(Mutex::new(server_addr)); let server_addr = Arc::new(Mutex::new(server_addr));
Ok(Self { Ok(Self {
server_addr: Arc::clone(&server_addr), server_addr: Arc::clone(&server_addr),
feeds: [ inline_feeds: [
PreviewFeed::spawn(Arc::clone(&server_addr), 0)?, PreviewFeed::spawn(Arc::clone(&server_addr), 0, PreviewSurface::Inline.profile())?,
PreviewFeed::spawn(server_addr, 1)?, PreviewFeed::spawn(server_addr.clone(), 1, PreviewSurface::Inline.profile())?,
],
window_feeds: [
PreviewFeed::spawn(Arc::clone(&server_addr), 0, PreviewSurface::Window.profile())?,
PreviewFeed::spawn(server_addr, 1, PreviewSurface::Window.profile())?,
], ],
}) })
} }
@ -62,7 +101,11 @@ impl LauncherPreview {
} }
pub fn set_session_active(&self, active: bool) { pub fn set_session_active(&self, active: bool) {
for feed in &self.feeds { for feed in self
.inline_feeds
.iter()
.chain(self.window_feeds.iter())
{
feed.set_active(active); feed.set_active(active);
} }
} }
@ -70,30 +113,53 @@ impl LauncherPreview {
pub fn install_on_picture( pub fn install_on_picture(
&self, &self,
monitor_id: usize, monitor_id: usize,
surface: PreviewSurface,
picture: &gtk::Picture, picture: &gtk::Picture,
status_label: &gtk::Label, status_label: &gtk::Label,
) -> Option<PreviewBinding> { ) -> Option<PreviewBinding> {
self.feeds self.feeds_for_surface(surface)
.get(monitor_id) .get(monitor_id)
.map(|feed| feed.install_on_picture(picture, status_label)) .map(|feed| feed.install_on_picture(picture, status_label))
} }
fn feeds_for_surface(&self, surface: PreviewSurface) -> &[PreviewFeed; 2] {
match surface {
PreviewSurface::Inline => &self.inline_feeds,
PreviewSurface::Window => &self.window_feeds,
}
}
} }
#[cfg(not(coverage))] #[cfg(not(coverage))]
impl PreviewBinding { impl PreviewBinding {
pub fn set_enabled(&self, enabled: bool) { pub fn set_enabled(&self, enabled: bool) {
self.enabled.store(enabled, Ordering::Relaxed); let was_enabled = self.enabled.swap(enabled, Ordering::AcqRel);
match (was_enabled, enabled) {
(false, true) => {
self.active_bindings.fetch_add(1, Ordering::AcqRel);
}
(true, false) => {
self.active_bindings.fetch_sub(1, Ordering::AcqRel);
}
_ => {}
}
} }
pub fn close(&self) { pub fn close(&self) {
self.alive.store(false, Ordering::Relaxed); if !self.alive.swap(false, Ordering::AcqRel) {
return;
}
if self.enabled.swap(false, Ordering::AcqRel) {
self.active_bindings.fetch_sub(1, Ordering::AcqRel);
}
} }
} }
#[cfg(not(coverage))] #[cfg(not(coverage))]
struct PreviewFeed { struct PreviewFeed {
shared: Arc<Mutex<SharedPreviewState>>, shared: Arc<Mutex<SharedPreviewState>>,
active: Arc<AtomicBool>, session_active: Arc<AtomicBool>,
active_bindings: Arc<AtomicUsize>,
} }
#[cfg(not(coverage))] #[cfg(not(coverage))]
@ -140,21 +206,38 @@ impl SharedPreviewState {
#[cfg(not(coverage))] #[cfg(not(coverage))]
impl PreviewFeed { impl PreviewFeed {
fn spawn(server_addr: Arc<Mutex<String>>, monitor_id: u32) -> Result<Self> { fn spawn(
server_addr: Arc<Mutex<String>>,
monitor_id: u32,
profile: PreviewProfile,
) -> Result<Self> {
let shared = Arc::new(Mutex::new(SharedPreviewState::new())); let shared = Arc::new(Mutex::new(SharedPreviewState::new()));
let active = Arc::new(AtomicBool::new(false)); let session_active = Arc::new(AtomicBool::new(false));
let active_bindings = Arc::new(AtomicUsize::new(0));
let shared_state = Arc::clone(&shared); let shared_state = Arc::clone(&shared);
let active_flag = Arc::clone(&active); let session_active_flag = Arc::clone(&session_active);
let active_bindings_flag = Arc::clone(&active_bindings);
std::thread::spawn(move || { std::thread::spawn(move || {
if let Err(err) = run_preview_feed(server_addr, monitor_id, active_flag, shared_state) { if let Err(err) = run_preview_feed(
server_addr,
monitor_id,
profile,
session_active_flag,
active_bindings_flag,
shared_state,
) {
warn!(monitor_id, ?err, "launcher preview feed exited"); warn!(monitor_id, ?err, "launcher preview feed exited");
} }
}); });
Ok(Self { shared, active }) Ok(Self {
shared,
session_active,
active_bindings,
})
} }
fn set_active(&self, active: bool) { fn set_active(&self, active: bool) {
self.active.store(active, Ordering::Relaxed); self.session_active.store(active, Ordering::Relaxed);
if !active { if !active {
self.replace_status(PREVIEW_IDLE_STATUS, true); self.replace_status(PREVIEW_IDLE_STATUS, true);
} }
@ -176,8 +259,10 @@ impl PreviewFeed {
let shared = Arc::clone(&self.shared); let shared = Arc::clone(&self.shared);
let enabled = Arc::new(AtomicBool::new(true)); let enabled = Arc::new(AtomicBool::new(true));
let alive = Arc::new(AtomicBool::new(true)); let alive = Arc::new(AtomicBool::new(true));
let active_bindings = Arc::clone(&self.active_bindings);
let enabled_flag = Arc::clone(&enabled); let enabled_flag = Arc::clone(&enabled);
let alive_flag = Arc::clone(&alive); let alive_flag = Arc::clone(&alive);
active_bindings.fetch_add(1, Ordering::AcqRel);
let mut last_generation = 0_u64; let mut last_generation = 0_u64;
glib::timeout_add_local(Duration::from_millis(120), move || { glib::timeout_add_local(Duration::from_millis(120), move || {
if !alive_flag.load(Ordering::Relaxed) { if !alive_flag.load(Ordering::Relaxed) {
@ -219,7 +304,11 @@ impl PreviewFeed {
} }
glib::ControlFlow::Continue glib::ControlFlow::Continue
}); });
PreviewBinding { enabled, alive } PreviewBinding {
enabled,
alive,
active_bindings,
}
} }
} }
@ -235,10 +324,12 @@ struct PreviewFrame {
fn run_preview_feed( fn run_preview_feed(
server_addr: Arc<Mutex<String>>, server_addr: Arc<Mutex<String>>,
monitor_id: u32, monitor_id: u32,
active: Arc<AtomicBool>, profile: PreviewProfile,
session_active: Arc<AtomicBool>,
active_bindings: Arc<AtomicUsize>,
shared: Arc<Mutex<SharedPreviewState>>, shared: Arc<Mutex<SharedPreviewState>>,
) -> Result<()> { ) -> Result<()> {
let (pipeline, appsrc, appsink) = build_preview_pipeline()?; let (pipeline, appsrc, appsink) = build_preview_pipeline(profile)?;
pipeline pipeline
.set_state(gst::State::Playing) .set_state(gst::State::Playing)
.context("starting launcher preview pipeline")?; .context("starting launcher preview pipeline")?;
@ -246,11 +337,13 @@ fn run_preview_feed(
{ {
let shared = Arc::clone(&shared); let shared = Arc::clone(&shared);
let appsink = appsink.clone(); let appsink = appsink.clone();
std::thread::spawn(move || loop { std::thread::spawn(move || {
if let Some(sample) = appsink.try_pull_sample(gst::ClockTime::from_mseconds(250)) { loop {
if let Some(frame) = sample_to_frame(&sample) { if let Some(sample) = appsink.try_pull_sample(gst::ClockTime::from_mseconds(250)) {
if let Ok(mut slot) = shared.lock() { if let Some(frame) = sample_to_frame(&sample) {
slot.push_frame(frame); if let Ok(mut slot) = shared.lock() {
slot.push_frame(frame);
}
} }
} }
} }
@ -263,13 +356,25 @@ fn run_preview_feed(
.context("building preview tokio runtime")?; .context("building preview tokio runtime")?;
let _ = rt.block_on(async move { let _ = rt.block_on(async move {
let mut was_active = false;
let mut retry_delay = Duration::from_millis(750);
loop { loop {
if !active.load(Ordering::Relaxed) { let active_now = session_active.load(Ordering::Relaxed)
&& active_bindings.load(Ordering::Relaxed) > 0;
if !active_now {
was_active = false;
retry_delay = Duration::from_millis(750);
set_shared_status(&shared, PREVIEW_IDLE_STATUS, true); set_shared_status(&shared, PREVIEW_IDLE_STATUS, true);
tokio::time::sleep(Duration::from_millis(150)).await; tokio::time::sleep(Duration::from_millis(150)).await;
continue; continue;
} }
if !was_active {
was_active = true;
set_shared_status(&shared, "Waking relay preview...", true);
tokio::time::sleep(Duration::from_millis(350)).await;
}
set_shared_status(&shared, "Connecting relay preview...", true); set_shared_status(&shared, "Connecting relay preview...", true);
let current_addr = match server_addr.lock() { let current_addr = match server_addr.lock() {
Ok(value) => value.clone(), Ok(value) => value.clone(),
@ -290,14 +395,14 @@ fn run_preview_feed(
format!("Preview host is unavailable: {err}"), format!("Preview host is unavailable: {err}"),
true, true,
); );
tokio::time::sleep(Duration::from_millis(750)).await; tokio::time::sleep(retry_delay).await;
continue; continue;
} }
}, },
Err(err) => { Err(err) => {
warn!(monitor_id, ?err, "launcher preview endpoint invalid"); warn!(monitor_id, ?err, "launcher preview endpoint invalid");
set_shared_status(&shared, format!("Preview address is invalid: {err}"), true); set_shared_status(&shared, format!("Preview address is invalid: {err}"), true);
tokio::time::sleep(Duration::from_millis(750)).await; tokio::time::sleep(retry_delay).await;
continue; continue;
} }
}; };
@ -305,14 +410,17 @@ fn run_preview_feed(
let mut cli = RelayClient::new(channel); let mut cli = RelayClient::new(channel);
let req = MonitorRequest { let req = MonitorRequest {
id: monitor_id, id: monitor_id,
max_bitrate: preview_max_bitrate(), max_bitrate: profile.max_bitrate_kbit,
}; };
match cli.capture_video(Request::new(req)).await { match cli.capture_video(Request::new(req)).await {
Ok(mut stream) => { Ok(mut stream) => {
retry_delay = Duration::from_millis(750);
debug!(monitor_id, "launcher preview connected"); debug!(monitor_id, "launcher preview connected");
set_shared_status(&shared, "Waiting for stream...", true); set_shared_status(&shared, "Waiting for stream...", true);
loop { loop {
if !active.load(Ordering::Relaxed) { if !session_active.load(Ordering::Relaxed)
|| active_bindings.load(Ordering::Relaxed) == 0
{
break; break;
} }
match tokio::time::timeout( match tokio::time::timeout(
@ -324,6 +432,7 @@ fn run_preview_feed(
Ok(Ok(Some(pkt))) => push_preview_packet(&appsrc, pkt), Ok(Ok(Some(pkt))) => push_preview_packet(&appsrc, pkt),
Ok(Ok(None)) => { Ok(Ok(None)) => {
set_shared_status(&shared, "Preview stream ended.", true); set_shared_status(&shared, "Preview stream ended.", true);
retry_delay = Duration::from_millis(1_500);
break; break;
} }
Ok(Err(err)) => { Ok(Err(err)) => {
@ -333,6 +442,7 @@ fn run_preview_feed(
format!("Preview stream error: {err}"), format!("Preview stream error: {err}"),
true, true,
); );
retry_delay = preview_retry_delay(retry_delay, Some(&err.to_string()));
break; break;
} }
Err(_) => continue, Err(_) => continue,
@ -340,11 +450,22 @@ fn run_preview_feed(
} }
} }
Err(err) => { Err(err) => {
warn!(monitor_id, ?err, "launcher preview rpc failed"); if preview_startup_condition(&err) {
set_shared_status(&shared, format!("Preview RPC failed: {err}"), true); debug!(
monitor_id,
?err,
"launcher preview waiting for capture pipeline"
);
set_shared_status(&shared, "Waiting for capture pipeline...", true);
retry_delay = preview_retry_delay(retry_delay, Some(err.message()));
} else {
warn!(monitor_id, ?err, "launcher preview rpc failed");
set_shared_status(&shared, format!("Preview RPC failed: {err}"), true);
retry_delay = preview_retry_delay(retry_delay, Some(err.message()));
}
} }
} }
tokio::time::sleep(Duration::from_millis(750)).await; tokio::time::sleep(retry_delay).await;
} }
#[allow(unreachable_code)] #[allow(unreachable_code)]
Ok::<(), anyhow::Error>(()) Ok::<(), anyhow::Error>(())
@ -353,6 +474,38 @@ fn run_preview_feed(
Ok(()) Ok(())
} }
#[cfg(not(coverage))]
fn preview_startup_condition(err: &tonic::Status) -> bool {
let message = err.message().to_ascii_lowercase();
err.code() == tonic::Code::Internal
&& (message.contains("starting video pipeline")
|| message.contains("failed to change its state")
|| message.contains("resource busy")
|| message.contains("device or resource busy")
|| message.contains("no signal"))
}
#[cfg(not(coverage))]
fn preview_retry_delay(current: Duration, message: Option<&str>) -> Duration {
let current_ms = current.as_millis() as u64;
let mut next_ms = if current_ms < 1_500 {
1_500
} else {
current_ms.saturating_mul(2)
};
if let Some(message) = message {
let message = message.to_ascii_lowercase();
if message.contains("too many open files")
|| message.contains("failed to change its state")
|| message.contains("resource busy")
|| message.contains("device or resource busy")
{
next_ms = next_ms.max(6_000);
}
}
Duration::from_millis(next_ms.min(30_000))
}
#[cfg(not(coverage))] #[cfg(not(coverage))]
fn set_shared_status( fn set_shared_status(
shared: &Arc<Mutex<SharedPreviewState>>, shared: &Arc<Mutex<SharedPreviewState>>,
@ -365,13 +518,18 @@ fn set_shared_status(
} }
#[cfg(not(coverage))] #[cfg(not(coverage))]
fn build_preview_pipeline() -> Result<(gst::Pipeline, gst_app::AppSrc, gst_app::AppSink)> { fn build_preview_pipeline(
profile: PreviewProfile,
) -> Result<(gst::Pipeline, gst_app::AppSrc, gst_app::AppSink)> {
let desc = format!( let desc = format!(
"appsrc name=src is-live=true format=time do-timestamp=true block=false ! \ "appsrc name=src is-live=true format=time do-timestamp=true block=false ! \
queue max-size-buffers=6 max-size-time=0 max-size-bytes=0 leaky=downstream ! \ queue max-size-buffers=6 max-size-time=0 max-size-bytes=0 leaky=downstream ! \
h264parse disable-passthrough=true ! avdec_h264 ! videoconvert ! videoscale ! \ h264parse disable-passthrough=true ! avdec_h264 ! videoconvert ! videoscale ! \
video/x-raw,format=RGBA,width={PREVIEW_WIDTH},height={PREVIEW_HEIGHT},pixel-aspect-ratio=1/1 ! \ video/x-raw,format=RGBA,width={},height={},pixel-aspect-ratio=1/1 ! \
appsink name=sink emit-signals=false sync=false max-buffers=1 drop=true" appsink name=sink emit-signals=false sync=false max-buffers=1 drop=true"
,
profile.width,
profile.height
); );
let pipeline = gst::parse::launch(&desc)? let pipeline = gst::parse::launch(&desc)?
.downcast::<gst::Pipeline>() .downcast::<gst::Pipeline>()
@ -398,8 +556,8 @@ fn build_preview_pipeline() -> Result<(gst::Pipeline, gst_app::AppSrc, gst_app::
appsink.set_caps(Some( appsink.set_caps(Some(
&gst::Caps::builder("video/x-raw") &gst::Caps::builder("video/x-raw")
.field("format", &"RGBA") .field("format", &"RGBA")
.field("width", &PREVIEW_WIDTH) .field("width", &profile.width)
.field("height", &PREVIEW_HEIGHT) .field("height", &profile.height)
.build(), .build(),
)); ));
@ -434,9 +592,39 @@ fn sample_to_frame(sample: &gst::Sample) -> Option<PreviewFrame> {
} }
#[cfg(not(coverage))] #[cfg(not(coverage))]
fn preview_max_bitrate() -> u32 { fn preview_bitrate(var: &str, default: u32) -> u32 {
std::env::var("LESAVKA_PREVIEW_MAX_KBIT") std::env::var(var)
.ok() .ok()
.and_then(|raw| raw.parse::<u32>().ok()) .and_then(|raw| raw.parse::<u32>().ok())
.unwrap_or(2_500) .unwrap_or(default)
}
#[cfg(not(coverage))]
fn preview_dimension(var: &str, default: i32) -> i32 {
std::env::var(var)
.ok()
.and_then(|raw| raw.parse::<i32>().ok())
.filter(|value| *value > 0)
.unwrap_or(default)
}
#[cfg(test)]
mod tests {
use super::{PREVIEW_HEIGHT, PREVIEW_WIDTH, PreviewSurface};
#[test]
fn inline_preview_profile_uses_existing_defaults() {
let profile = PreviewSurface::Inline.profile();
assert_eq!(profile.width, PREVIEW_WIDTH);
assert_eq!(profile.height, PREVIEW_HEIGHT);
assert_eq!(profile.max_bitrate_kbit, 2_500);
}
#[test]
fn breakout_preview_profile_defaults_to_higher_quality() {
let profile = PreviewSurface::Window.profile();
assert_eq!(profile.width, 1280);
assert_eq!(profile.height, 720);
assert_eq!(profile.max_bitrate_kbit, 8_000);
}
} }

18
client/src/launcher/ui_components.rs
View File

@ -4,7 +4,7 @@ use gtk::prelude::*;
use super::{ use super::{
devices::DeviceCatalog, devices::DeviceCatalog,
preview::{LauncherPreview, PreviewBinding}, preview::{LauncherPreview, PreviewBinding, PreviewSurface},
state::LauncherState, state::LauncherState,
}; };
@ -403,10 +403,18 @@ pub fn build_launcher_view(
let mut left_pane = left_pane; let mut left_pane = left_pane;
let mut right_pane = right_pane; let mut right_pane = right_pane;
if let Some(preview) = preview.as_ref() { if let Some(preview) = preview.as_ref() {
left_pane.preview_binding = left_pane.preview_binding = preview.install_on_picture(
preview.install_on_picture(0, &left_pane.picture, &left_pane.stream_status); 0,
right_pane.preview_binding = PreviewSurface::Inline,
preview.install_on_picture(1, &right_pane.picture, &right_pane.stream_status); &left_pane.picture,
&left_pane.stream_status,
);
right_pane.preview_binding = preview.install_on_picture(
1,
PreviewSurface::Inline,
&right_pane.picture,
&right_pane.stream_status,
);
} else { } else {
left_pane.stream_status.set_text("Preview unavailable"); left_pane.stream_status.set_text("Preview unavailable");
right_pane.stream_status.set_text("Preview unavailable"); right_pane.stream_status.set_text("Preview unavailable");

82
client/src/launcher/ui_runtime.rs
View File

@ -8,10 +8,12 @@ use std::{
}; };
use super::{ use super::{
LAUNCHER_CLIPBOARD_CONTROL_ENV,
LAUNCHER_FOCUS_SIGNAL_ENV, LAUNCHER_FOCUS_SIGNAL_ENV,
device_test::{DeviceTestController, DeviceTestKind}, device_test::{DeviceTestController, DeviceTestKind},
launcher_clipboard_control_path,
launcher_focus_signal_path, launcher_focus_signal_path,
preview::LauncherPreview, preview::{LauncherPreview, PreviewSurface},
runtime_env_vars, runtime_env_vars,
state::{CapturePowerStatus, DisplaySurface, InputRouting, LauncherState}, state::{CapturePowerStatus, DisplaySurface, InputRouting, LauncherState},
ui_components::{DisplayPaneWidgets, LauncherWidgets, PopoutWindowHandle}, ui_components::{DisplayPaneWidgets, LauncherWidgets, PopoutWindowHandle},
@ -159,7 +161,11 @@ pub fn open_popout_window(
widgets: &LauncherWidgets, widgets: &LauncherWidgets,
monitor_id: usize, monitor_id: usize,
) { ) {
if popouts.borrow()[monitor_id].is_some() { let already_open = {
let popouts = popouts.borrow();
popouts[monitor_id].is_some()
};
if already_open {
return; return;
} }
@ -201,7 +207,12 @@ pub fn open_popout_window(
root.append(&stream_status); root.append(&stream_status);
let binding = preview let binding = preview
.install_on_picture(monitor_id, &picture, &stream_status) .install_on_picture(
monitor_id,
PreviewSurface::Window,
&picture,
&stream_status,
)
.expect("preview binding for popout"); .expect("preview binding for popout");
window.set_child(Some(&root)); window.set_child(Some(&root));
@ -224,13 +235,16 @@ pub fn open_popout_window(
{ {
preview_binding.set_enabled(true); preview_binding.set_enabled(true);
} }
state_handle {
.borrow_mut() let mut state = state_handle.borrow_mut();
.set_display_surface(monitor_id, DisplaySurface::Preview); state.set_display_surface(monitor_id, DisplaySurface::Preview);
}
let child_running = child_proc_handle.borrow().is_some();
let state_snapshot = state_handle.borrow().clone();
refresh_launcher_ui( refresh_launcher_ui(
&widgets_handle, &widgets_handle,
&state_handle.borrow(), &state_snapshot,
child_proc_handle.borrow().is_some(), child_running,
); );
} else { } else {
close_binding.close(); close_binding.close();
@ -238,14 +252,20 @@ pub fn open_popout_window(
glib::Propagation::Proceed glib::Propagation::Proceed
}); });
state {
.borrow_mut() let mut state = state.borrow_mut();
.set_display_surface(monitor_id, DisplaySurface::Window); state.set_display_surface(monitor_id, DisplaySurface::Window);
popouts.borrow_mut()[monitor_id] = Some(PopoutWindowHandle { }
window: window.clone(), {
binding, let mut popouts = popouts.borrow_mut();
}); popouts[monitor_id] = Some(PopoutWindowHandle {
refresh_launcher_ui(widgets, &state.borrow(), child_proc.borrow().is_some()); window: window.clone(),
binding,
});
}
let child_running = child_proc.borrow().is_some();
let state_snapshot = state.borrow().clone();
refresh_launcher_ui(widgets, &state_snapshot, child_running);
window.present(); window.present();
} }
@ -267,10 +287,13 @@ pub fn dock_display_to_preview(
if let Some(binding) = widgets.display_panes[monitor_id].preview_binding.as_ref() { if let Some(binding) = widgets.display_panes[monitor_id].preview_binding.as_ref() {
binding.set_enabled(true); binding.set_enabled(true);
} }
state {
.borrow_mut() let mut state = state.borrow_mut();
.set_display_surface(monitor_id, DisplaySurface::Preview); state.set_display_surface(monitor_id, DisplaySurface::Preview);
refresh_launcher_ui(widgets, &state.borrow(), child_proc.borrow().is_some()); }
let child_running = child_proc.borrow().is_some();
let state_snapshot = state.borrow().clone();
refresh_launcher_ui(widgets, &state_snapshot, child_running);
} }
pub fn refresh_display_pane(pane: &DisplayPaneWidgets, surface: DisplaySurface) { pub fn refresh_display_pane(pane: &DisplayPaneWidgets, surface: DisplaySurface) {
@ -512,6 +535,19 @@ pub fn input_state_path() -> PathBuf {
.unwrap_or_else(|_| PathBuf::from(DEFAULT_INPUT_STATE_PATH)) .unwrap_or_else(|_| PathBuf::from(DEFAULT_INPUT_STATE_PATH))
} }
pub fn write_clipboard_control_request(path: &Path) -> Result<()> {
std::fs::write(
path,
format!(
"{}\n",
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)?
.as_millis()
),
)?;
Ok(())
}
pub fn write_input_routing_request(path: &Path, routing: InputRouting) -> Result<()> { pub fn write_input_routing_request(path: &Path, routing: InputRouting) -> Result<()> {
std::fs::write(path, format!("{}\n", routing_name(routing)))?; std::fs::write(path, format!("{}\n", routing_name(routing)))?;
Ok(()) Ok(())
@ -639,10 +675,14 @@ pub fn spawn_client_process(
command.env("LESAVKA_LAUNCHER_WINDOW_TITLE", "Lesavka Launcher"); command.env("LESAVKA_LAUNCHER_WINDOW_TITLE", "Lesavka Launcher");
command.env("LESAVKA_FOCUS_LAUNCHER_ON_LOCAL", "1"); command.env("LESAVKA_FOCUS_LAUNCHER_ON_LOCAL", "1");
command.env(LAUNCHER_FOCUS_SIGNAL_ENV, launcher_focus_signal_path()); command.env(LAUNCHER_FOCUS_SIGNAL_ENV, launcher_focus_signal_path());
command.env(
LAUNCHER_CLIPBOARD_CONTROL_ENV,
launcher_clipboard_control_path(),
);
command.env(INPUT_CONTROL_ENV, input_control_path); command.env(INPUT_CONTROL_ENV, input_control_path);
command.env(INPUT_STATE_ENV, input_state_path); command.env(INPUT_STATE_ENV, input_state_path);
command.env("LESAVKA_DISABLE_VIDEO_RENDER", "1"); command.env("LESAVKA_DISABLE_VIDEO_RENDER", "1");
command.env("LESAVKA_CLIPBOARD_PASTE", "0"); command.env("LESAVKA_CLIPBOARD_PASTE", "1");
for (key, value) in runtime_env_vars(state) { for (key, value) in runtime_env_vars(state) {
command.env(key, value); command.env(key, value);
} }