485 lines
18 KiB
Rust
485 lines
18 KiB
Rust
//! Native chat image presentation. Network/decode work runs away from the event loop.
|
|
use super::{chat_images, slint::MainWindow};
|
|
use slint::{ComponentHandle, Model, SharedPixelBuffer};
|
|
use std::{cell::RefCell, collections::HashMap, rc::Rc, sync::mpsc, time::Instant};
|
|
use vnox_client::net::NetCommand;
|
|
|
|
struct Animation {
|
|
frames: Vec<(slint::Image, u32)>,
|
|
ratio: f32,
|
|
started: Instant,
|
|
bytes: usize,
|
|
}
|
|
impl Animation {
|
|
fn new(image: chat_images::DecodedImage) -> Self {
|
|
let bytes = image.frames.iter().map(|f| f.rgba.len()).sum();
|
|
Self {
|
|
frames: image
|
|
.frames
|
|
.into_iter()
|
|
.map(|f| {
|
|
(
|
|
slint::Image::from_rgba8(SharedPixelBuffer::clone_from_slice(
|
|
&f.rgba,
|
|
image.width,
|
|
image.height,
|
|
)),
|
|
f.delay_ms.max(20),
|
|
)
|
|
})
|
|
.collect(),
|
|
ratio: image.width as f32 / image.height as f32,
|
|
started: Instant::now(),
|
|
bytes,
|
|
}
|
|
}
|
|
fn frame(&self) -> slint::Image {
|
|
let duration: u128 = self.frames.iter().map(|f| u128::from(f.1)).sum();
|
|
let mut position = self.started.elapsed().as_millis() % duration.max(1);
|
|
for (image, delay) in &self.frames {
|
|
if position < u128::from(*delay) {
|
|
return image.clone();
|
|
}
|
|
position -= u128::from(*delay);
|
|
}
|
|
self.frames[0].0.clone()
|
|
}
|
|
}
|
|
struct Entry {
|
|
image: Option<Animation>,
|
|
error: String,
|
|
started: Instant,
|
|
}
|
|
struct Ready {
|
|
key: String,
|
|
result: Result<chat_images::DecodedImage, String>,
|
|
clipboard: Option<Vec<u8>>,
|
|
}
|
|
struct Pending {
|
|
bytes: Vec<u8>,
|
|
image: Animation,
|
|
channel: String,
|
|
generation: u64,
|
|
request: Option<String>,
|
|
started: Instant,
|
|
}
|
|
struct Media {
|
|
cache: HashMap<String, Entry>,
|
|
tx: mpsc::Sender<Ready>,
|
|
rx: mpsc::Receiver<Ready>,
|
|
pending: Option<Pending>,
|
|
clipboard_key: Option<String>,
|
|
generation: u64,
|
|
workers: usize,
|
|
}
|
|
impl Default for Media {
|
|
fn default() -> Self {
|
|
let (tx, rx) = mpsc::channel();
|
|
Self {
|
|
cache: HashMap::new(),
|
|
tx,
|
|
rx,
|
|
pending: None,
|
|
clipboard_key: None,
|
|
generation: 0,
|
|
workers: 0,
|
|
}
|
|
}
|
|
}
|
|
thread_local! { static MEDIA: RefCell<Media> = RefCell::new(Media::default()); }
|
|
|
|
pub fn wire(window: &MainWindow, state: &Rc<RefCell<crate::AppState>>) {
|
|
let weak = window.as_weak();
|
|
let paste_state = state.clone();
|
|
window.on_paste_image(move || {
|
|
let Some(win)=weak.upgrade() else { return false };
|
|
let s=paste_state.borrow();
|
|
// A failed image lookup must leave normal text paste to TextInput.
|
|
let Ok(clipboard)=chat_images::clipboard_image() else { return false };
|
|
if MEDIA.with(|m| {let m=m.borrow();m.workers+m.cache.iter().filter(|(key,entry)|key.starts_with("attachment:") && entry.error=="Loading image…").count()>=3 || m.pending.as_ref().is_some_and(|p|p.request.is_some())}) {win.set_image_status("Wait for the current image operation to finish.".into());return true;}
|
|
if s.ui.active_dm_id.is_some() || s.ui.active_channel.is_none() { win.set_image_status("Image attachments are available in channels. You can send an HTTPS image link here.".into()); return true; }
|
|
let channel=s.ui.active_channel.clone().unwrap_or_default(); let generation=s.connection_generation;
|
|
MEDIA.with(|m| { let mut m=m.borrow_mut(); if m.pending.as_ref().is_some_and(|p|p.request.is_some()) {return} let tx=m.tx.clone(); m.workers+=1;let clipboard_key=format!("clipboard:{generation}:{channel}:{}",uuid::Uuid::new_v4());m.clipboard_key=Some(clipboard_key.clone());
|
|
tokio::task::spawn_blocking(move || { let result=chat_images::encode_clipboard_png(clipboard).and_then(|bytes|chat_images::decode(&bytes).map(|image|(bytes,image))); match result {Ok((bytes,image))=>{let _=tx.send(Ready {key:clipboard_key,result:Ok(image),clipboard:Some(bytes)});},Err(error)=>{let _=tx.send(Ready {key:clipboard_key,result:Err(error.to_string()),clipboard:Some(Vec::new())});}} });
|
|
});
|
|
win.set_image_status("Preparing image…".into()); true
|
|
});
|
|
let weak = window.as_weak();
|
|
window.on_cancel_image(move || {
|
|
let cancelled = MEDIA.with(|m| {
|
|
let mut m = m.borrow_mut();
|
|
if m.pending.as_ref().is_some_and(|p| p.request.is_some()) {
|
|
return false;
|
|
}
|
|
m.pending = None;
|
|
m.clipboard_key = None;
|
|
true
|
|
});
|
|
if !cancelled {
|
|
return;
|
|
}
|
|
if let Some(w) = weak.upgrade() {
|
|
w.set_has_pending_image(false);
|
|
w.set_image_status("".into());
|
|
}
|
|
});
|
|
let state = state.clone();
|
|
let weak = window.as_weak();
|
|
window.on_send_image(move || {
|
|
let s = state.borrow();
|
|
let net = s.net.clone();
|
|
MEDIA.with(|m| {
|
|
let mut m = m.borrow_mut();
|
|
let Some(p) = m.pending.as_mut() else { return };
|
|
if p.request.is_some() {
|
|
return;
|
|
}
|
|
if p.generation != s.connection_generation
|
|
|| s.ui.active_dm_id.is_some()
|
|
|| s.ui.active_channel.as_deref() != Some(&p.channel)
|
|
|| !matches!(s.ui.conn, super::state::ConnState::Connected { .. })
|
|
{
|
|
if let Some(w) = weak.upgrade() {
|
|
w.set_image_status(
|
|
"Select the original channel and connect before sending this image.".into(),
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
let request_id = uuid::Uuid::new_v4().to_string();
|
|
p.request = Some(request_id.clone());
|
|
p.started = Instant::now();
|
|
let channel_id = p.channel.clone();
|
|
let data = p.bytes.clone();
|
|
tokio::spawn(async move {
|
|
net.send(NetCommand::AttachmentUpload {
|
|
request_id,
|
|
channel_id,
|
|
data,
|
|
})
|
|
.await;
|
|
});
|
|
if let Some(w) = weak.upgrade() {
|
|
w.set_image_uploading(true);
|
|
w.set_image_status("Sending image…".into());
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
pub fn receive(result: vnox_client::net::wire::AttachmentResult) {
|
|
MEDIA.with(|m| {
|
|
let mut m = m.borrow_mut();
|
|
if let Some(p) = m.pending.as_mut()
|
|
&& p.request.as_deref() == Some(&result.request_id)
|
|
{
|
|
if result.error.is_empty() {
|
|
m.pending = None;
|
|
} else {
|
|
p.request = None;
|
|
}
|
|
// Display delivery state on the next UI tick.
|
|
let _ = m.tx.send(Ready {
|
|
key: "upload-status".into(),
|
|
result: Err(if result.error.is_empty() {
|
|
String::new()
|
|
} else {
|
|
result.error
|
|
}),
|
|
clipboard: None,
|
|
});
|
|
return;
|
|
}
|
|
let key = result.request_id;
|
|
let expected = format!(
|
|
"attachment:{}:{}:{}",
|
|
m.generation, result.channel_id, result.attachment_id
|
|
);
|
|
if key != expected
|
|
|| !m
|
|
.cache
|
|
.get(&key)
|
|
.is_some_and(|entry| entry.error == "Loading image…")
|
|
{
|
|
return;
|
|
}
|
|
|
|
if !result.error.is_empty() {
|
|
if let Some(e) = m.cache.get_mut(&key) {
|
|
e.error = result.error;
|
|
}
|
|
return;
|
|
}
|
|
if let Some(entry) = m.cache.get_mut(&key) {
|
|
entry.error = "Decoding image…".into();
|
|
}
|
|
let tx = m.tx.clone();
|
|
m.workers += 1;
|
|
tokio::task::spawn_blocking(move || {
|
|
let decoded = chat_images::decode(&result.data).map_err(|e| e.to_string());
|
|
let _ = tx.send(Ready {
|
|
key,
|
|
result: decoded,
|
|
clipboard: None,
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
pub fn tick(window: &MainWindow, state: &crate::AppState) {
|
|
MEDIA.with(|m| {
|
|
let mut m = m.borrow_mut();
|
|
if m.generation != state.connection_generation {
|
|
m.cache.clear();
|
|
m.pending = None;
|
|
m.clipboard_key = None;
|
|
m.generation = state.connection_generation;
|
|
window.set_has_pending_image(false);
|
|
window.set_image_uploading(false);
|
|
window.set_image_status("".into());
|
|
}
|
|
let visible_model = if window.get_show_forum() {
|
|
window.get_forum_replies()
|
|
} else {
|
|
window.get_messages()
|
|
};
|
|
let visible: Vec<String> = visible_model
|
|
.iter()
|
|
.filter_map(|item| source_key(&item.media_source, state))
|
|
.collect();
|
|
m.cache.retain(|key, _| visible.contains(key));
|
|
while let Ok(ready) = m.rx.try_recv() {
|
|
if ready.key == "upload-status" {
|
|
window.set_image_uploading(false);
|
|
window.set_image_status(ready.result.err().unwrap_or_default().into());
|
|
window.set_has_pending_image(m.pending.is_some());
|
|
continue;
|
|
}
|
|
m.workers = m.workers.saturating_sub(1);
|
|
if let Some(bytes) = ready.clipboard {
|
|
let expected = format!(
|
|
"clipboard:{}:{}",
|
|
state.connection_generation,
|
|
state.ui.active_channel.as_deref().unwrap_or("")
|
|
);
|
|
if m.clipboard_key.as_deref() != Some(&ready.key)
|
|
|| !ready.key.starts_with(&format!("{expected}:"))
|
|
|| state.ui.active_dm_id.is_some()
|
|
{
|
|
continue;
|
|
}
|
|
m.clipboard_key = None;
|
|
match ready.result {
|
|
Ok(image) => {
|
|
let image = Animation::new(image);
|
|
window.set_pending_image(image.frame());
|
|
window.set_has_pending_image(true);
|
|
window.set_image_status(
|
|
"Image ready. Send it to this channel or cancel.".into(),
|
|
);
|
|
m.pending = Some(Pending {
|
|
bytes,
|
|
image,
|
|
channel: state.ui.active_channel.clone().unwrap_or_default(),
|
|
generation: state.connection_generation,
|
|
request: None,
|
|
started: Instant::now(),
|
|
});
|
|
}
|
|
Err(e) => window.set_image_status(format!("Cannot paste image: {e}").into()),
|
|
}
|
|
continue;
|
|
}
|
|
if !m.cache.contains_key(&ready.key) {
|
|
continue;
|
|
}
|
|
match ready.result {
|
|
Ok(image) => {
|
|
let image = Animation::new(image);
|
|
let total: usize = m
|
|
.cache
|
|
.values()
|
|
.filter_map(|e| e.image.as_ref())
|
|
.map(|a| a.bytes)
|
|
.sum();
|
|
if total + image.bytes > 64 * 1024 * 1024 {
|
|
m.cache.insert(
|
|
ready.key,
|
|
Entry {
|
|
image: None,
|
|
error:
|
|
"Preview cache is full. Open another channel to release images."
|
|
.into(),
|
|
started: Instant::now(),
|
|
},
|
|
);
|
|
continue;
|
|
}
|
|
m.cache.insert(
|
|
ready.key,
|
|
Entry {
|
|
image: Some(image),
|
|
error: String::new(),
|
|
started: Instant::now(),
|
|
},
|
|
);
|
|
}
|
|
Err(e) => {
|
|
m.cache.insert(
|
|
ready.key,
|
|
Entry {
|
|
image: None,
|
|
error: format!("Image unavailable: {e}"),
|
|
started: Instant::now(),
|
|
},
|
|
);
|
|
}
|
|
}
|
|
}
|
|
if let Some(p) = m.pending.as_mut() {
|
|
if p.request.is_some() && p.started.elapsed().as_secs() > 35 {
|
|
p.request = None;
|
|
window.set_image_uploading(false);
|
|
window.set_image_status(
|
|
"Image delivery could not be confirmed. Check the channel before retrying."
|
|
.into(),
|
|
);
|
|
}
|
|
window.set_pending_image(p.image.frame());
|
|
}
|
|
for entry in m.cache.values_mut() {
|
|
if entry.image.is_none()
|
|
&& entry.error == "Loading image…"
|
|
&& entry.started.elapsed().as_secs() > 35
|
|
{
|
|
entry.error = "Image request timed out".into();
|
|
}
|
|
}
|
|
let pending_fetches = m
|
|
.cache
|
|
.iter()
|
|
.filter(|(k, e)| {
|
|
k.starts_with("attachment:") && e.image.is_none() && e.error == "Loading image…"
|
|
})
|
|
.count();
|
|
let model = if window.get_show_forum() {
|
|
window.get_forum_replies()
|
|
} else {
|
|
window.get_messages()
|
|
};
|
|
let mut slots = 3usize.saturating_sub(m.workers + pending_fetches);
|
|
for row in 0..model.row_count() {
|
|
let Some(mut item) = model.row_data(row) else {
|
|
continue;
|
|
};
|
|
let previous = item.clone();
|
|
let body = item.media_source.to_string();
|
|
let source = body.as_str();
|
|
let attachment = if window.get_show_forum() {
|
|
None
|
|
} else {
|
|
source
|
|
.strip_prefix("vnox-attachment:")
|
|
.filter(|id| uuid::Uuid::parse_str(id).is_ok())
|
|
};
|
|
let remote = chat_images::image_url(source);
|
|
let key = if let Some(id) = attachment {
|
|
format!(
|
|
"attachment:{}:{}:{}",
|
|
state.connection_generation,
|
|
state.ui.active_channel.as_deref().unwrap_or(""),
|
|
id
|
|
)
|
|
} else if let Some(url) = &remote {
|
|
format!("url:{url}")
|
|
} else {
|
|
continue;
|
|
};
|
|
if !m.cache.contains_key(&key) && slots > 0 && m.cache.len() < 24 {
|
|
slots -= 1;
|
|
m.cache.insert(
|
|
key.clone(),
|
|
Entry {
|
|
image: None,
|
|
error: "Loading image…".into(),
|
|
started: Instant::now(),
|
|
},
|
|
);
|
|
if let Some(attachment_id) = attachment {
|
|
let net = state.net.clone();
|
|
let channel_id = state.ui.active_channel.clone().unwrap_or_default();
|
|
let attachment_id = attachment_id.to_string();
|
|
let request_id = key.clone();
|
|
tokio::spawn(async move {
|
|
net.send(NetCommand::AttachmentFetch {
|
|
request_id,
|
|
channel_id,
|
|
attachment_id,
|
|
})
|
|
.await;
|
|
});
|
|
} else if let Some(url) = remote {
|
|
m.workers += 1;
|
|
let tx = m.tx.clone();
|
|
let request = key.clone();
|
|
tokio::spawn(async move {
|
|
let result = async {
|
|
let bytes = chat_images::fetch(&url).await?;
|
|
tokio::task::spawn_blocking(move || chat_images::decode(&bytes)).await?
|
|
}
|
|
.await
|
|
.map_err(|e: anyhow::Error| e.to_string());
|
|
let _ = tx.send(Ready {
|
|
key: request,
|
|
result,
|
|
clipboard: None,
|
|
});
|
|
});
|
|
}
|
|
}
|
|
item.media_ready = false;
|
|
item.media_image = Default::default();
|
|
item.media_status = "Image queue is full".into();
|
|
if let Some(entry) = m.cache.get(&key) {
|
|
if let Some(image) = &entry.image {
|
|
item.media_image = image.frame();
|
|
item.media_ready = true;
|
|
item.media_ratio = image.ratio;
|
|
item.media_status = "".into();
|
|
} else {
|
|
item.media_status = entry.error.as_str().into();
|
|
}
|
|
}
|
|
if attachment.is_some() {
|
|
item.content = "".into();
|
|
}
|
|
if item.media_ready != previous.media_ready
|
|
|| item.media_image != previous.media_image
|
|
|| item.media_status != previous.media_status
|
|
|| item.media_ratio != previous.media_ratio
|
|
|| item.content != previous.content
|
|
{
|
|
model.set_row_data(row, item);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
fn source_key(source: &str, state: &crate::AppState) -> Option<String> {
|
|
if super::forum::visible(&state.ui) && source.starts_with("vnox-attachment:") {
|
|
return None;
|
|
}
|
|
if let Some(id) = source
|
|
.strip_prefix("vnox-attachment:")
|
|
.filter(|id| uuid::Uuid::parse_str(id).is_ok())
|
|
{
|
|
Some(format!(
|
|
"attachment:{}:{}:{}",
|
|
state.connection_generation,
|
|
state.ui.active_channel.as_deref().unwrap_or(""),
|
|
id
|
|
))
|
|
} else {
|
|
chat_images::image_url(source).map(|url| format!("url:{url}"))
|
|
}
|
|
}
|