diff --git a/Cargo.lock b/Cargo.lock index 16a9237..8d92e79 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3711,7 +3711,7 @@ checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" [[package]] name = "pg-app" version = "0.2.0" -source = "git+https://github.com/narrrl/proton-gallery.git?rev=72d83a29ad2836c698b18e2f5189a423c60c2399#72d83a29ad2836c698b18e2f5189a423c60c2399" +source = "git+https://github.com/narrrl/proton-gallery.git?rev=b841c37ad57694470f499f575f7a956425c28ade#b841c37ad57694470f499f575f7a956425c28ade" dependencies = [ "async-trait", "hex", @@ -3731,7 +3731,7 @@ dependencies = [ [[package]] name = "pg-core" version = "0.2.0" -source = "git+https://github.com/narrrl/proton-gallery.git?rev=72d83a29ad2836c698b18e2f5189a423c60c2399#72d83a29ad2836c698b18e2f5189a423c60c2399" +source = "git+https://github.com/narrrl/proton-gallery.git?rev=b841c37ad57694470f499f575f7a956425c28ade#b841c37ad57694470f499f575f7a956425c28ade" dependencies = [ "aes-gcm 0.11.1", "async-trait", @@ -3751,7 +3751,7 @@ dependencies = [ [[package]] name = "pg-drive" version = "0.2.0" -source = "git+https://github.com/narrrl/proton-gallery.git?rev=72d83a29ad2836c698b18e2f5189a423c60c2399#72d83a29ad2836c698b18e2f5189a423c60c2399" +source = "git+https://github.com/narrrl/proton-gallery.git?rev=b841c37ad57694470f499f575f7a956425c28ade#b841c37ad57694470f499f575f7a956425c28ade" dependencies = [ "async-trait", "hex", @@ -5139,7 +5139,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" dependencies = [ "fastrand", - "getrandom 0.4.3", + "getrandom 0.3.4", "once_cell", "rustix", "windows-sys 0.61.2", diff --git a/Cargo.toml b/Cargo.toml index 1795e75..95ec75c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -17,8 +17,8 @@ categories = ["filesystem", "command-line-utilities"] [workspace.dependencies] proton-sdk = { version = "0.12.1" } proton-drive-rs = { version = "0.12.1" } -pg-app = { git = "https://github.com/narrrl/proton-gallery.git", rev = "72d83a29ad2836c698b18e2f5189a423c60c2399" } -pg-core = { git = "https://github.com/narrrl/proton-gallery.git", rev = "72d83a29ad2836c698b18e2f5189a423c60c2399" } +pg-app = { git = "https://github.com/narrrl/proton-gallery.git", rev = "b841c37ad57694470f499f575f7a956425c28ade" } +pg-core = { git = "https://github.com/narrrl/proton-gallery.git", rev = "b841c37ad57694470f499f575f7a956425c28ade" } chrono = { version = "0.4", default-features = false, features = ["std"] } # Internal crates. diff --git a/crates/pdfs-core/src/control.rs b/crates/pdfs-core/src/control.rs index d9df2aa..506c3f5 100644 --- a/crates/pdfs-core/src/control.rs +++ b/crates/pdfs-core/src/control.rs @@ -92,6 +92,12 @@ pub enum Request { PhotoGroup { uid: String, }, + /// Check the cached photo or its membership in the viewer's open album. + PhotoPresence { + uid: String, + #[serde(default)] + album: Option, + }, /// The months the timeline spans (newest first, with per-month counts) so a /// front-end can build a date scrubber without paging the whole library. /// `kind` scopes the counts to one tab when set. @@ -241,15 +247,21 @@ pub enum Request { /// Open a revision for playback in the local viewer. OpenGalleryVideo { uid: String, + #[serde(default)] + private: bool, }, OpenGalleryImage { uid: String, + #[serde(default)] + private: bool, }, CloseGalleryVideo { token: String, }, GalleryThumbnail { uid: String, + #[serde(default)] + private: bool, }, DriveGallery { action: GalleryAction, @@ -2016,6 +2028,12 @@ pub enum GalleryAction { offset: usize, limit: usize, }, + PrivateList { + album: Option, + proton: bool, + offset: usize, + limit: usize, + }, Folders { parent: Option, }, @@ -2047,6 +2065,8 @@ pub struct GalleryFolder { #[derive(Serialize, Deserialize, Debug, Clone)] pub struct GalleryAlbum { pub place: GalleryPlace, + #[serde(default)] + pub proton: bool, pub folder: GalleryFolder, pub cover: Option, pub items: u64, @@ -2549,6 +2569,9 @@ pub enum Response { #[serde(default)] summary: Option, }, + PhotoPresence { + present: bool, + }, /// The months the timeline spans (reply to [`Request::PhotoMonths`]), /// newest first. PhotoMonths { diff --git a/crates/pdfs-core/src/db/albums.rs b/crates/pdfs-core/src/db/albums.rs index 19b76c3..aa9abf0 100644 --- a/crates/pdfs-core/src/db/albums.rs +++ b/crates/pdfs-core/src/db/albums.rs @@ -31,8 +31,30 @@ pub struct StoredAlbum { impl Db { /// Replace the album listing wholesale, in the given order. pub fn albums_replace(&self, albums: &[StoredAlbum]) -> Result<()> { + self.albums_replace_impl(albums, None).map(|_| ()) + } + + pub fn albums_replace_at( + &self, + albums: &[StoredAlbum], + generation: i64, + now: i64, + ) -> Result { + self.albums_replace_impl(albums, Some((generation, now))) + } + + fn albums_replace_impl( + &self, + albums: &[StoredAlbum], + stamp: Option<(i64, i64)>, + ) -> Result { let mut conn = self.conn.lock(); let tx = conn.transaction()?; + if let Some((generation, _)) = stamp + && super::photos::photos_generation(&tx)? != generation + { + return Ok(false); + } // Contents of an album that no longer exists (unshared, deleted) go with // it — otherwise they would linger forever, keyed by an album uid no // listing mentions again. @@ -56,7 +78,11 @@ impl Db { let mut stmt = tx.prepare( "INSERT INTO albums (uid, name, photo_count, cover_uid, last_activity, shared, seq) - VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)", + SELECT ?1,?2,?3, + CASE WHEN EXISTS(SELECT 1 FROM photo_tombstones WHERE uid=?4) + THEN (SELECT uid FROM album_photos WHERE album_uid=?1 ORDER BY seq LIMIT 1) ELSE ?4 END, + ?5,?6,?7 + WHERE NOT EXISTS(SELECT 1 FROM photo_tombstones WHERE uid=?1)", )?; for (seq, album) in albums.iter().enumerate() { stmt.execute(params![ @@ -70,8 +96,11 @@ impl Db { ])?; } } + if let Some((_, now)) = stamp { + super::photos::gallery_state(&tx, "albums_synced_ms", now)?; + } tx.commit()?; - Ok(()) + Ok(true) } /// The persisted album listing, in stored order. @@ -111,15 +140,44 @@ impl Db { album_uid: &str, items: &[(String, i64, Option, Option)], ) -> Result<()> { + self.album_photos_replace_impl(album_uid, items, None) + .map(|_| ()) + } + + pub fn album_photos_replace_at( + &self, + album_uid: &str, + items: &[(String, i64, Option, Option)], + generation: i64, + now: i64, + ) -> Result { + self.album_photos_replace_impl(album_uid, items, Some((generation, now))) + } + + fn album_photos_replace_impl( + &self, + album_uid: &str, + items: &[(String, i64, Option, Option)], + stamp: Option<(i64, i64)>, + ) -> Result { let mut conn = self.conn.lock(); let tx = conn.transaction()?; - let learned: HashMap, i64, Option)> = { + if let Some((generation, _)) = stamp + && super::photos::photos_generation(&tx)? != generation + { + return Ok(false); + } + type StoredPhotoMetadata = (Option, i64, Option, Option); + let learned: HashMap = { let mut stmt = tx.prepare( - "SELECT uid, ratio, thumb_state, media_type FROM album_photos + "SELECT uid, ratio, thumb_state, media_type, name FROM album_photos WHERE album_uid = ?1", )?; let rows = stmt.query_map([album_uid], |r| { - Ok((r.get::<_, String>(0)?, (r.get(1)?, r.get(2)?, r.get(3)?))) + Ok(( + r.get::<_, String>(0)?, + (r.get(1)?, r.get(2)?, r.get(3)?, r.get(4)?), + )) })?; rows.collect::>()? }; @@ -128,15 +186,17 @@ impl Db { { let mut stmt = tx.prepare( "INSERT INTO album_photos - (album_uid, uid, capture_time, name, media_type, kind, ratio, thumb_state, seq) - VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)", + (album_uid, uid, capture_time, name, media_type, kind, ratio, thumb_state, seq, resolved) + SELECT ?1,?2,?3,?4,?5,?6,?7,?8,?9,?10 + WHERE NOT EXISTS(SELECT 1 FROM photo_tombstones WHERE uid IN (?1,?2))", )?; for (seq, (uid, capture_time, name, media_type)) in items.iter().enumerate() { - let (ratio, thumb_state, learned_media) = - learned - .get(uid) - .cloned() - .unwrap_or((None, THUMB_UNKNOWN, None)); + let (ratio, thumb_state, learned_media, learned_name) = learned + .get(uid) + .cloned() + .unwrap_or((None, THUMB_UNKNOWN, None, None)); + let resolved = name.is_some(); + let name = name.clone().or(learned_name); let media_type = media_type.clone().or(learned_media); let kind = crate::control::PhotoKind::classify(name.as_deref(), media_type.as_deref()); @@ -150,11 +210,32 @@ impl Db { ratio, thumb_state, seq as i64, + resolved, ])?; } } + if let Some((_, now)) = stamp { + super::photos::gallery_state(&tx, &format!("album_synced_ms:{album_uid}"), now)?; + } tx.commit()?; - Ok(()) + Ok(true) + } + + /// Reuse current timeline metadata and resolved album-only metadata. + pub fn album_photo_metadata( + &self, + album: &str, + ) -> Result)>> { + let conn = self.read(); + let mut stmt = conn.prepare( + "SELECT uid,name,media_type FROM album_photos + WHERE album_uid=?1 AND resolved=1 AND name IS NOT NULL + UNION ALL SELECT uid,name,media_type FROM photos + WHERE resolved_at IS NOT NULL AND name IS NOT NULL", + )?; + Ok(stmt + .query_map([album], |r| Ok((r.get(0)?, (r.get(1)?, r.get(2)?))))? + .collect::>()?) } /// One page of an album's photos, in stored order. diff --git a/crates/pdfs-core/src/db/migrations.rs b/crates/pdfs-core/src/db/migrations.rs index 0e9ac0e..e5e3c40 100644 --- a/crates/pdfs-core/src/db/migrations.rs +++ b/crates/pdfs-core/src/db/migrations.rs @@ -11,7 +11,7 @@ use super::Db; use crate::Result; /// Current schema version. Bump on every forward migration added below. -pub(super) const SCHEMA_VERSION: i64 = 45; +pub(super) const SCHEMA_VERSION: i64 = 46; impl Db { pub(super) fn migrate(&self) -> Result<()> { @@ -490,6 +490,17 @@ impl Db { } } } + if current < 46 { + tx.execute_batch(MIGRATION_V46)?; + let has_resolved: bool = tx.query_row( + "SELECT EXISTS(SELECT 1 FROM pragma_table_info('album_photos') WHERE name='resolved')", + [], + |row| row.get(0), + )?; + if !has_resolved { + tx.execute_batch(MIGRATION_V46_ALBUM_PHOTOS)?; + } + } tx.execute( "INSERT INTO sync_state (key, value) VALUES ('schema_version', ?1) ON CONFLICT(key) DO UPDATE SET value = excluded.value", @@ -1459,3 +1470,13 @@ BEGIN UPDATE mount SET kind = NEW.kind WHERE sync_folder_id = NEW.id; END; "; + +/// Keep deletion evidence across listing races and remember unresolved album metadata. +const MIGRATION_V46: &str = " +CREATE TABLE IF NOT EXISTS photo_tombstones(uid TEXT PRIMARY KEY); +"; + +const MIGRATION_V46_ALBUM_PHOTOS: &str = " +ALTER TABLE album_photos ADD COLUMN resolved INTEGER NOT NULL DEFAULT 0; +UPDATE album_photos SET resolved=1 WHERE name IS NOT NULL; +"; diff --git a/crates/pdfs-core/src/db/photos.rs b/crates/pdfs-core/src/db/photos.rs index dda2c27..6380f99 100644 --- a/crates/pdfs-core/src/db/photos.rs +++ b/crates/pdfs-core/src/db/photos.rs @@ -1,7 +1,7 @@ //! The photos timeline: a flat, date-ordered projection of the photo share, //! persisted so the gallery opens instantly instead of re-enumerating on launch. -use rusqlite::params; +use rusqlite::{Connection, OptionalExtension, Transaction, params}; use std::collections::{HashMap, HashSet}; @@ -278,15 +278,285 @@ fn stored_photo(r: &rusqlite::Row<'_>) -> rusqlite::Result { }) } +const PHOTOS_GENERATION: &str = "photos_projection_generation"; +const PHOTOS_SYNCED: &str = "photos_synced_ms"; +const PHOTOS_AVAILABLE: &str = "photos_available"; +const PHOTOS_RECONCILE: &str = "photos_reconcile"; + +pub(super) fn photos_generation(conn: &Connection) -> rusqlite::Result { + conn.query_row( + "SELECT coalesce((SELECT CAST(value AS INTEGER) FROM sync_state WHERE key=?1),0)", + [PHOTOS_GENERATION], + |row| row.get(0), + ) +} + +pub(super) fn gallery_state( + conn: &Connection, + key: &str, + value: impl rusqlite::ToSql, +) -> rusqlite::Result<()> { + conn.execute( + "INSERT INTO sync_state(key,value) VALUES (?1,?2) + ON CONFLICT(key) DO UPDATE SET value=excluded.value", + params![key, value], + )?; + Ok(()) +} + +fn photos_delete_tx(tx: &Transaction<'_>, uids: &[String]) -> Result { + let mut removed = 0; + for uid in uids { + tx.execute( + "INSERT OR IGNORE INTO photo_tombstones(uid) VALUES (?1)", + [uid], + )?; + removed += tx.execute("DELETE FROM photos WHERE uid=?1", [uid])?; + tx.execute("DELETE FROM albums WHERE uid=?1", [uid])?; + tx.execute("DELETE FROM album_photos WHERE album_uid=?1", [uid])?; + tx.execute( + "UPDATE albums SET photo_count=max(photo_count-1,0) + WHERE cover_uid=?1 OR uid IN (SELECT album_uid FROM album_photos WHERE uid=?1)", + [uid], + )?; + tx.execute("DELETE FROM album_photos WHERE uid=?1", [uid])?; + tx.execute( + "UPDATE albums SET cover_uid=(SELECT uid FROM album_photos + WHERE album_uid=albums.uid ORDER BY seq LIMIT 1) WHERE cover_uid=?1", + [uid], + )?; + } + tx.execute( + "UPDATE photos SET group_key=NULL WHERE group_key IS NOT NULL + AND group_key NOT IN (SELECT uid FROM photos)", + [], + )?; + Ok(removed) +} + impl Db { + pub fn photo_projection_generation(&self) -> Result { + Ok(photos_generation(&self.read())?) + } + + /// One transaction records the deletion, stale metadata, listing work and feed position. + pub fn photos_apply_events( + &self, + cursor_key: &str, + cursor: &str, + gone: &[String], + touched: &[String], + gap: bool, + seed: bool, + ) -> Result<()> { + let mut conn = self.conn.lock(); + let tx = conn.transaction()?; + if !gone.is_empty() { + photos_delete_tx(&tx, gone)?; + } + for uid in touched { + tx.execute("DELETE FROM photo_tombstones WHERE uid=?1", [uid])?; + tx.execute("UPDATE photos SET resolved_at=NULL WHERE uid=?1", [uid])?; + tx.execute("UPDATE album_photos SET resolved=0 WHERE uid=?1", [uid])?; + } + if gap { + tx.execute("UPDATE photos SET resolved_at=NULL", [])?; + tx.execute("UPDATE album_photos SET resolved=0", [])?; + gallery_state(&tx, PHOTOS_RECONCILE, 1)?; + } + if seed || gap || !gone.is_empty() || !touched.is_empty() { + let generation = photos_generation(&tx)?; + gallery_state(&tx, PHOTOS_GENERATION, generation + 1)?; + tx.execute( + "DELETE FROM sync_state WHERE key='albums_synced_ms' + OR key GLOB 'album_synced_ms:*'", + [], + )?; + } + if seed || gap || !touched.is_empty() { + tx.execute("DELETE FROM sync_state WHERE key=?1", [PHOTOS_SYNCED])?; + } + gallery_state(&tx, cursor_key, cursor)?; + tx.commit()?; + Ok(()) + } + + pub fn photos_invalidate(&self) -> Result<()> { + let mut conn = self.conn.lock(); + let tx = conn.transaction()?; + let generation = photos_generation(&tx)?; + gallery_state(&tx, PHOTOS_GENERATION, generation + 1)?; + tx.execute("DELETE FROM sync_state WHERE key=?1", [PHOTOS_SYNCED])?; + tx.commit()?; + Ok(()) + } + + pub fn photos_need_work(&self) -> Result { + let conn = self.read(); + Ok(conn.query_row( + "SELECT NOT EXISTS(SELECT 1 FROM sync_state WHERE key=?1) + OR EXISTS(SELECT 1 FROM photos WHERE resolved_at IS NULL)", + [PHOTOS_SYNCED], + |r| r.get(0), + )?) + } + + pub fn photos_pending(&self) -> Result> { + let conn = self.read(); + let mut stmt = + conn.prepare("SELECT uid FROM photos WHERE resolved_at IS NULL ORDER BY seq")?; + Ok(stmt + .query_map([], |r| r.get(0))? + .collect::>()?) + } + + pub fn photo_removed(&self, uid: &str) -> Result { + Ok(self.read().query_row( + "SELECT EXISTS(SELECT 1 FROM photo_tombstones WHERE uid=?1)", + [uid], + |r| r.get(0), + )?) + } + + pub fn photos_contains(&self, uid: &str, album: Option<&str>) -> Result { + let conn = self.read(); + Ok(match album { + Some(album) => conn.query_row( + "SELECT EXISTS(SELECT 1 FROM album_photos WHERE album_uid=?1 AND uid=?2)", + params![album, uid], + |r| r.get(0), + )?, + None => conn.query_row( + "SELECT EXISTS(SELECT 1 FROM photos WHERE uid=?1) + OR EXISTS(SELECT 1 FROM album_photos WHERE uid=?1)", + [uid], + |r| r.get(0), + )?, + }) + } + + /// Persist one enrichment batch. The generation check and UPDATE share the + /// writer transaction with deletion, so a stale batch cannot restore a row. + pub fn photos_resolve_at(&self, generation: i64, rows: &[TimelineRow]) -> Result { + let mut conn = self.conn.lock(); + let tx = conn.transaction()?; + if photos_generation(&tx)? != generation { + return Ok(false); + } + { + let mut update = tx.prepare( + "UPDATE photos SET name=?2, media_type=?3, kind=?4, favorite=?5, + similar_hash=CASE WHEN content_hash IS ?6 THEN similar_hash ELSE NULL END, + content_hash=?6, main_uid=?7, latitude=?8, longitude=?9, place_id=?10, + resolved_at=?11 WHERE uid=?1", + )?; + for row in rows.iter().filter(|row| row.resolved_at.is_some()) { + let kind = crate::control::PhotoKind::classify( + row.name.as_deref(), + row.media_type.as_deref(), + ); + update.execute(params![ + row.uid, + row.name, + row.media_type, + kind.as_i64(), + row.favorite.unwrap_or(false), + row.content_hash, + row.main_uid, + row.location.map(|p| p.0), + row.location.map(|p| p.1), + row.location + .and_then(|(lat, lon)| crate::places::nearest(lat, lon)) + .map(|city| city.id), + row.resolved_at + ])?; + } + } + if !rows.is_empty() { + let (entries, existing): (Vec<_>, Vec>) = { + let mut stmt = tx.prepare( + "SELECT uid,kind,main_uid,strftime('%Y-%m-%d',capture_time,'unixepoch','localtime'), + name,group_key FROM photos ORDER BY seq", + )?; + stmt.query_map([], |r| { + let name: Option = r.get(4)?; + Ok(( + Grouped { + uid: r.get(0)?, + kind: crate::control::PhotoKind::from_i64(r.get(1)?), + main_uid: r.get(2)?, + day: r.get(3)?, + stem: name_stem(name.as_deref()), + }, + r.get(5)?, + )) + })? + .collect::>>()? + .into_iter() + .unzip() + }; + let mut update = tx.prepare("UPDATE photos SET group_key=?2 WHERE uid=?1")?; + for ((entry, old), group) in entries.iter().zip(existing).zip(group_photos(&entries)) { + if old.as_deref() != Some(group.as_str()) { + update.execute(params![entry.uid, group])?; + } + } + } + tx.commit()?; + Ok(true) + } + /// Replace the timeline wholesale. A row whose `resolved_at` is `Some` was /// read from the server in this pass, so its fields are taken as they are — /// a `None` there means the server no longer reports that value. A row whose /// `resolved_at` is `None` was skipped or failed to resolve, and keeps /// whatever is already stored rather than having it silently cleared. pub fn photos_replace(&self, items: &[TimelineRow]) -> Result<()> { + self.photos_replace_impl(items, None).map(|_| ()) + } + + pub fn photos_replace_at( + &self, + items: &[TimelineRow], + generation: i64, + available: bool, + now: i64, + ) -> Result { + self.photos_replace_impl(items, Some((generation, available, now))) + } + + fn photos_replace_impl( + &self, + items: &[TimelineRow], + stamp: Option<(i64, bool, i64)>, + ) -> Result { let mut conn = self.conn.lock(); let tx = conn.transaction()?; + let mut tombstones = HashSet::new(); + if let Some((generation, _, _)) = stamp { + if photos_generation(&tx)? != generation { + return Ok(false); + } + let repairing = tx + .query_row( + "SELECT 1 FROM sync_state WHERE key=?1", + [PHOTOS_RECONCILE], + |_| Ok(()), + ) + .optional()? + .is_some(); + if repairing { + let mut remove = tx.prepare("DELETE FROM photo_tombstones WHERE uid=?1")?; + for row in items { + remove.execute([&row.uid])?; + } + tx.execute("DELETE FROM sync_state WHERE key=?1", [PHOTOS_RECONCILE])?; + } + let mut stmt = tx.prepare("SELECT uid FROM photo_tombstones")?; + tombstones = stmt + .query_map([], |r| r.get::<_, String>(0))? + .collect::>()?; + } // `name` and `media_type` are learned-and-kept like the ratio and thumb // verdict: the timeline DTO carries only the uid and capture time, so the // daemon may not know them when it replaces the timeline — because the @@ -325,6 +595,7 @@ impl Db { // Everything the insert and the grouping need, resolved once per photo. let resolved: Vec<(&TimelineRow, Learned, crate::control::PhotoKind)> = items .iter() + .filter(|row| !tombstones.contains(&row.uid)) .map(|row| { let mut carried = learned.get(&row.uid).cloned().unwrap_or(Learned { thumb_state: THUMB_UNKNOWN, @@ -414,8 +685,12 @@ impl Db { ])?; } } + if let Some((_, available, now)) = stamp { + gallery_state(&tx, PHOTOS_AVAILABLE, available as i64)?; + gallery_state(&tx, PHOTOS_SYNCED, now)?; + } tx.commit()?; - Ok(()) + Ok(true) } /// The uids whose node metadata is already resolved, so a refresh can skip @@ -458,8 +733,16 @@ impl Db { /// refresh. For a continuity loss, where the daemon cannot know what it /// missed, and for an explicit `refresh photos --full`. pub fn photos_mark_all_unresolved(&self) -> Result { - let conn = self.conn.lock(); - Ok(conn.execute("UPDATE photos SET resolved_at = NULL", [])?) + let mut conn = self.conn.lock(); + let tx = conn.transaction()?; + let marked = tx.execute("UPDATE photos SET resolved_at=NULL", [])?; + tx.execute("UPDATE album_photos SET resolved=0", [])?; + let generation = photos_generation(&tx)?; + gallery_state(&tx, PHOTOS_GENERATION, generation + 1)?; + gallery_state(&tx, PHOTOS_RECONCILE, 1)?; + tx.execute("DELETE FROM sync_state WHERE key=?1", [PHOTOS_SYNCED])?; + tx.commit()?; + Ok(marked) } /// Forget photos that have been trashed, so the gallery does not show them @@ -474,23 +757,9 @@ impl Db { } let mut conn = self.conn.lock(); let tx = conn.transaction()?; - let mut removed = 0; - { - let mut photos = tx.prepare("DELETE FROM photos WHERE uid = ?1")?; - let mut albums = tx.prepare("DELETE FROM album_photos WHERE uid = ?1")?; - for uid in uids { - removed += photos.execute([uid])?; - albums.execute([uid])?; - } - } - // A group whose representative went is left pointing at nothing, which - // drops its other files off every page. Make them stand alone until the - // next refresh groups them again. - tx.execute( - "UPDATE photos SET group_key = NULL WHERE group_key IS NOT NULL \ - AND group_key NOT IN (SELECT uid FROM photos)", - [], - )?; + let removed = photos_delete_tx(&tx, uids)?; + let generation = photos_generation(&tx)?; + gallery_state(&tx, PHOTOS_GENERATION, generation + 1)?; tx.commit()?; Ok(removed) } @@ -656,10 +925,15 @@ impl Db { None => "uid = COALESCE(group_key, uid) AND ?2 IS NULL", }; let sql = format!( - "SELECT CAST(strftime('%Y', capture_time, 'unixepoch', 'localtime') AS INTEGER) AS y, \ + "WITH hidden_groups AS ( + SELECT COALESCE(group_key, uid) FROM photos + WHERE uid IN (SELECT value FROM json_each(?1)) + ) + SELECT CAST(strftime('%Y', capture_time, 'unixepoch', 'localtime') AS INTEGER) AS y, \ CAST(strftime('%m', capture_time, 'unixepoch', 'localtime') AS INTEGER) AS m, \ COUNT(*) \ - FROM photos WHERE {filter} AND uid NOT IN (SELECT value FROM json_each(?1)) + FROM photos WHERE {filter} + AND COALESCE(group_key, uid) NOT IN (SELECT * FROM hidden_groups) GROUP BY y, m ORDER BY y DESC, m DESC" ); let mut stmt = conn.prepare(&sql)?; diff --git a/crates/pdfs-core/src/db/tests.rs b/crates/pdfs-core/src/db/tests.rs index da34435..82669f9 100644 --- a/crates/pdfs-core/src/db/tests.rs +++ b/crates/pdfs-core/src/db/tests.rs @@ -7872,3 +7872,87 @@ fn migration_v45_keeps_existing_device_folders_and_location_ids() { db.migrate().unwrap(); assert_eq!(db.mount_list().unwrap().len(), 2); } + +#[test] +fn photo_feed_failure_keeps_the_cursor_and_a_stale_listing_cannot_restore_deleted_rows() { + let db = Db::open_in_memory().unwrap(); + let rows = vec![TimelineRow::new("gone", 200), TimelineRow::new("keep", 100)]; + db.photos_replace(&rows).unwrap(); + db.albums_replace(&[StoredAlbum { + uid: "album".into(), + name: "Test album".into(), + photo_count: 2, + cover_uid: Some("gone".into()), + last_activity: None, + shared: false, + }]) + .unwrap(); + db.album_photos_replace( + "album", + &[ + ("gone".into(), 200, None, None), + ("keep".into(), 100, None, None), + ], + ) + .unwrap(); + db.set_state_str("photos-cursor-test", "old").unwrap(); + let stale = db.photo_projection_generation().unwrap(); + db.conn.lock().execute_batch( + "CREATE TEMP TRIGGER reject_cursor BEFORE INSERT ON sync_state WHEN NEW.key='photos-cursor-test' + BEGIN SELECT RAISE(ABORT, 'simulated cursor failure'); END;", + ).unwrap(); + + let gone = ["gone".into()]; + assert!( + db.photos_apply_events("photos-cursor-test", "next", &gone, &[], false, false) + .is_err() + ); + assert_eq!( + db.state_str("photos-cursor-test").unwrap().as_deref(), + Some("old") + ); + assert_eq!(db.photos_count().unwrap(), 2); + assert!(db.photos_contains("gone", Some("album")).unwrap()); + db.conn + .lock() + .execute("DROP TRIGGER reject_cursor", []) + .unwrap(); + + db.photos_apply_events("photos-cursor-test", "next", &gone, &[], false, false) + .unwrap(); + assert_eq!( + db.state_str("photos-cursor-test").unwrap().as_deref(), + Some("next") + ); + assert!(!db.photos_contains("gone", None).unwrap()); + assert_eq!( + db.albums_list().unwrap()[0].cover_uid.as_deref(), + Some("keep") + ); + assert!(!db.photos_replace_at(&rows, stale, true, 1).unwrap()); + assert!( + !db.album_photos_replace_at("album", &[("gone".into(), 200, None, None)], stale, 1) + .unwrap() + ); + assert!(!db.photos_contains("gone", None).unwrap()); + + db.photos_apply_events("photos-cursor-test", "restore", &[], &gone, false, false) + .unwrap(); + let current = db.photo_projection_generation().unwrap(); + assert!(db.photos_replace_at(&rows, current, true, 2).unwrap()); + assert!(db.photos_contains("gone", None).unwrap()); +} + +#[test] +fn warm_photo_months_exclude_hidden_groups_with_thirteen_thousand_rows() { + let db = Db::open_in_memory().unwrap(); + let mut rows: Vec<_> = (0..13_000) + .map(|i| TimelineRow::new(format!("volume~{i}"), 1_700_000_000 + i)) + .collect(); + rows[1].main_uid = Some(rows[0].uid.clone()); + db.photos_replace(&rows).unwrap(); + let started = std::time::Instant::now(); + let months = db.photos_months_visible(None, r#"["volume~1"]"#).unwrap(); + assert_eq!(months.iter().map(|month| month.2).sum::(), 12_998); + assert!(started.elapsed() < std::time::Duration::from_secs(1)); +} diff --git a/crates/pdfs-fuse/src/albums.rs b/crates/pdfs-fuse/src/albums.rs index 1c24e08..287f673 100644 --- a/crates/pdfs-fuse/src/albums.rs +++ b/crates/pdfs-fuse/src/albums.rs @@ -12,7 +12,7 @@ //! than looked up in our own timeline, where a shared album's photos never //! appear. -use std::collections::{HashMap, HashSet}; +use std::collections::HashSet; use std::sync::atomic::Ordering; use pdfs_core::control::{AlbumInfo, PhotoItem, Topic}; @@ -24,8 +24,8 @@ use proton_drive_rs::proton_sdk::ids::NodeUid; use tracing::warn; use super::{ - ALBUM_SYNCED_PREFIX, ALBUMS_SYNCED_MS, Core, PHOTOS_AVAILABLE, PHOTOS_SYNCED_MS, - TIMELINE_ENRICH_CHUNK, TIMELINE_TTL, now_ms, parse_uid, + ALBUM_SYNCED_PREFIX, ALBUMS_SYNCED_MS, Core, PHOTOS_AVAILABLE, TIMELINE_ENRICH_CHUNK, + TIMELINE_TTL, link, now_ms, parse_uid, }; impl Core { @@ -34,7 +34,13 @@ impl Core { /// [`Core::photos_timeline`] gives. pub(crate) fn albums(&self) -> CoreResult>> { let count = self.db.albums_count().map_err(CoreError::from)?; - if count == 0 { + if count == 0 + && self + .db + .state_i64(ALBUMS_SYNCED_MS) + .map_err(CoreError::from)? + .is_none() + { // Nothing on disk, so this one request waits for the fetch — unless // the account is already known to have no photos volume. let known_empty = self.db.state_i64(PHOTOS_AVAILABLE).ok().flatten() == Some(0); @@ -56,77 +62,71 @@ impl Core { /// the persisted listing. Returns false when the account has no photos /// volume. pub(crate) async fn refresh_albums(&self) -> CoreResult { + let generation = self + .db + .photo_projection_generation() + .map_err(CoreError::from)?; let photos = self.photos(); - if photos - .get_photos_root() + if link::bounded(photos.get_photos_root()) .await .map_err(|e| CoreError::from_api(&e, "photos root"))? .is_none() { - let _ = self.db.set_state_i64(PHOTOS_AVAILABLE, 0); - let _ = self.db.set_state_i64(PHOTOS_SYNCED_MS, now_ms()); - let _ = self.db.set_state_i64(ALBUMS_SYNCED_MS, now_ms()); + self.db + .albums_replace_at(&[], generation, now_ms()) + .map_err(CoreError::from)?; return Ok(false); } - - let mut uids = photos - .enumerate_album_node_uids() + let mut uids = link::bounded(photos.enumerate_album_node_uids()) .await .map_err(|e| CoreError::from_api(&e, "albums"))?; + let shared = link::bounded(photos.enumerate_shared_with_me_album_uids()) + .await + .map_err(|e| CoreError::from_api(&e, "shared albums"))?; + let shared_keys: HashSet<_> = shared.iter().map(ToString::to_string).collect(); + uids.extend(shared); + let mut unique = HashSet::new(); + uids.retain(|uid| unique.insert(uid.clone())); - // Shared-with-me albums are a separate listing on the sharer's volume. - // Best-effort: an account whose sharing listing fails still gets its own - // albums rather than an error page. - let shared: HashSet = match photos.enumerate_shared_with_me_album_uids().await { - Ok(shared) => { - let keys = shared.iter().map(|u| u.to_string()).collect(); - uids.extend(shared); - keys - } - Err(e) => { - warn!(error = %e, "enumerating shared-with-me albums failed"); - HashSet::new() - } - }; - - // The listings carry uids only; the name, photo count and cover come from - // the album nodes themselves. A chunk that fails to resolve drops those - // albums from this refresh rather than failing the whole listing. - let mut albums: Vec = Vec::with_capacity(uids.len()); + let mut albums = Vec::with_capacity(uids.len()); for chunk in uids.chunks(TIMELINE_ENRICH_CHUNK) { - match photos.enumerate_nodes(chunk).await { - Ok(nodes) => { - for node in nodes { - let key = node.uid.to_string(); - let props = node.album.as_ref(); - albums.push(StoredAlbum { - shared: shared.contains(&key), - uid: key, - name: node.name, - photo_count: props.map_or(0, |a| a.photo_count.max(0) as usize), - cover_uid: props - .and_then(|a| a.cover_photo_uid.as_ref()) - .map(|u| u.to_string()), - last_activity: props.and_then(|a| a.last_activity_time), - }); - } - } - Err(e) => warn!(error = %e, "resolving an album chunk failed"), + let nodes = link::bounded(photos.enumerate_nodes(chunk)) + .await + .map_err(|e| CoreError::from_api(&e, "album metadata"))?; + if nodes.len() != chunk.len() { + return Err(CoreError::remote( + "Some album details are still unavailable.", + )); + } + for node in nodes.into_iter().filter(|node| !node.trashed) { + let uid = node.uid.to_string(); + let props = node.album.as_ref(); + albums.push(StoredAlbum { + shared: shared_keys.contains(&uid), + uid, + name: node.name, + photo_count: props.map_or(0, |a| a.photo_count.max(0) as usize), + cover_uid: props + .and_then(|a| a.cover_photo_uid.as_ref()) + .map(ToString::to_string), + last_activity: props.and_then(|a| a.last_activity_time), + }); } } - - // Newest activity first, and albums the server gave no activity time for - // last — an album nobody has touched belongs below the ones in use. Ties - // fall back to the name so the order is stable between refreshes. albums.sort_by(|a, b| { b.last_activity .cmp(&a.last_activity) .then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase())) }); - - self.db.albums_replace(&albums).map_err(CoreError::from)?; - let _ = self.db.set_state_i64(PHOTOS_AVAILABLE, 1); - let _ = self.db.set_state_i64(ALBUMS_SYNCED_MS, now_ms()); + if !self + .db + .albums_replace_at(&albums, generation, now_ms()) + .map_err(CoreError::from)? + { + return Err(CoreError::remote( + "Photos changed during the album refresh. Try again shortly.", + )); + } Ok(true) } @@ -157,9 +157,18 @@ impl Core { excluded: &str, ) -> CoreResult> { let key = album.to_string(); + if self.db.photo_removed(&key).map_err(CoreError::from)? { + return Ok(Vec::new()); + } let stamp = format!("{ALBUM_SYNCED_PREFIX}{key}"); let count = self.db.album_photos_count(&key).map_err(CoreError::from)?; - if count == 0 { + if count == 0 + && self + .db + .state_i64(&stamp) + .map_err(CoreError::from)? + .is_none() + { self.rt.block_on(self.refresh_album(album))?; } else if self.listing_stale(&stamp, TIMELINE_TTL) { let core = self.clone(); @@ -214,47 +223,56 @@ impl Core { /// Re-enumerate one album's photos and replace its persisted contents. pub(crate) async fn refresh_album(&self, album: &NodeUid) -> CoreResult<()> { + let generation = self + .db + .photo_projection_generation() + .map_err(CoreError::from)?; let photos = self.photos(); - let items = photos - .enumerate_album(album) + let items = link::bounded(photos.enumerate_album(album)) .await .map_err(|e| CoreError::from_api(&e, "album"))?; - - // Same enrichment as the timeline: the listing carries a uid and a - // capture time, and the gallery needs a name and media type to classify - // each entry. Best-effort per chunk. - let uids: Vec = items.iter().map(|it| it.uid.clone()).collect(); - let mut meta: HashMap, Option)> = HashMap::new(); + let key = album.to_string(); + let mut meta = self + .db + .album_photo_metadata(&key) + .map_err(CoreError::from)?; + let uids: Vec = items + .iter() + .filter(|item| !meta.contains_key(&item.uid.to_string())) + .map(|item| item.uid.clone()) + .collect(); for chunk in uids.chunks(TIMELINE_ENRICH_CHUNK) { - match photos.enumerate_nodes(chunk).await { - Ok(nodes) => { - for node in nodes { - let media_type = match &node.kind { - NodeKind::File { media_type, .. } => Some(media_type.clone()), - NodeKind::Folder => None, - }; - meta.insert(node.uid.to_string(), (Some(node.name), media_type)); - } - } - Err(e) => warn!(error = %e, "resolving album photo metadata failed"), + let nodes = link::bounded(photos.enumerate_nodes(chunk)) + .await + .map_err(|e| CoreError::from_api(&e, "album photo metadata"))?; + for node in nodes.into_iter().filter(|node| !node.trashed) { + let media_type = match node.kind { + NodeKind::File { media_type, .. } => Some(media_type), + NodeKind::Folder => None, + }; + meta.insert(node.uid.to_string(), (node.name, media_type)); } } - - let rows: Vec<(String, i64, Option, Option)> = items - .iter() - .map(|it| { - let key = it.uid.to_string(); - let (name, media_type) = meta.get(&key).cloned().unwrap_or((None, None)); - (key, it.capture_time, name, media_type) + let rows: Vec<_> = items + .into_iter() + .map(|item| { + let uid = item.uid.to_string(); + let (name, media_type) = meta + .get(&uid) + .map(|(name, mime)| (Some(name.clone()), mime.clone())) + .unwrap_or_default(); + (uid, item.capture_time, name, media_type) }) .collect(); - let key = album.to_string(); - self.db - .album_photos_replace(&key, &rows) - .map_err(CoreError::from)?; - let _ = self + if !self .db - .set_state_i64(&format!("{ALBUM_SYNCED_PREFIX}{key}"), now_ms()); + .album_photos_replace_at(&key, &rows, generation, now_ms()) + .map_err(CoreError::from)? + { + return Err(CoreError::remote( + "Photos changed during the album refresh. Try again shortly.", + )); + } Ok(()) } @@ -284,7 +302,7 @@ impl Core { .block_on(self.photos().delete_album(album, delete_photos)) .map_err(|e| CoreError::from_api(&e, "delete album"))?; let key = album.to_string(); - if let Err(error) = self.db.album_photos_replace(&key, &[]) { + if let Err(error) = self.db.photos_delete(&[key]) { warn!(%album, %error, "a deleted album's photos could not be dropped"); } self.after_album_change(None); diff --git a/crates/pdfs-fuse/src/background.rs b/crates/pdfs-fuse/src/background.rs index 9364472..de5a389 100644 --- a/crates/pdfs-fuse/src/background.rs +++ b/crates/pdfs-fuse/src/background.rs @@ -517,32 +517,15 @@ pub(super) async fn run_event_sync( } } -/// The state key holding the photos volume's event cursor. Separate from the -/// Drive cursor because the two volumes have their own event streams, and one -/// cursor cannot address both. -const PHOTOS_EVENT_CURSOR: &str = "photos_event_cursor"; - -/// Poll the photos volume's event stream, so a photo deleted or added on another -/// device shows up in the gallery within one poll instead of on the timeline's -/// freshness window. -/// -/// Deliberately much smaller than [`run_event_sync`]: the photos volume is not -/// part of the FUSE mount, so there is no inode space to converge and nothing to -/// invalidate in the kernel. A trash or a delete removes the rows behind the -/// gallery; anything else only drops the timeline's freshness stamp, and the -/// next read re-enumerates. Getting that wrong costs a stale tile, not a wrong -/// file. +/// Follow the Photos volume and commit changes with its durable event cursor. pub(super) async fn run_photos_event_sync(core: Core) { let photos = core.photos(); // The photos volume only exists once the user has used Photos at all, and // the daemon may well start before the network does. let scope = loop { - match photos.get_photos_root().await { + match link::bounded(photos.get_photos_root()).await { Ok(Some(root)) => break root.tree_event_scope_id(), - Ok(None) => { - debug!("no photos volume; photo event sync not started"); - return; - } + Ok(None) => core.next_poll(POLL_INTERVAL).await, Err(error) if session_revoked(&error) => { core.mark_session_expired("read the photos root", &error); return; @@ -554,39 +537,71 @@ pub(super) async fn run_photos_event_sync(core: Core) { } }; - let mut cursor: Option = core - .db - .state_str(PHOTOS_EVENT_CURSOR) - .ok() - .flatten() - .map(DriveEventId::from); - info!(?cursor, "photo event sync started"); + let key = format!("photos_event_cursor:{}", scope.volume_id()); + let mut cursor = loop { + match core.db.state_str(&key) { + Ok(cursor) => break cursor.map(DriveEventId::from), + Err(error) => { + warn!(%error, "reading the photo event checkpoint failed"); + core.next_poll(POLL_INTERVAL).await; + } + } + }; + info!("photo event sync started"); loop { - core.next_poll(POLL_INTERVAL).await; let events = match link::bounded(photos.enumerate_events(&scope, cursor.as_ref())).await { Ok(events) => events, - Err(error) if core.lost_link(&error, "poll photo events") => continue, Err(error) => { - warn!(%error, "photo event poll failed; retrying after interval"); + if !core.lost_link(&error, "poll photo events") { + warn!(%error, "photo event poll failed; retrying after interval"); + } + core.next_poll(POLL_INTERVAL).await; continue; } }; - let Some(head) = events.last().map(|event| event.id().clone()) else { - continue; - }; - apply_photo_events(&core, &events); - core.events.publish(&[Topic::Photos]); - // One cursor write per batch, after the batch is applied: a crash in - // between replays events whose effects are idempotent. - if let Err(error) = core.db.set_state_str(PHOTOS_EVENT_CURSOR, head.as_str()) { - warn!(%error, "persisting the photo event cursor failed"); - continue; + if let Some(head) = events.last().map(|event| event.id().clone()) { + if let Err(error) = invalidate_photo_events(&core, &events).await { + warn!(%error, "invalidating photo event metadata failed"); + core.next_poll(POLL_INTERVAL).await; + continue; + } + // A failed database write must replay all changes, including echoes. + let plan = classify_photo_events(&events, |_| false); + if let Err(error) = core.db.photos_apply_events( + &key, + head.as_str(), + &plan.gone, + &plan.touched, + plan.full, + cursor.is_none(), + ) { + warn!(%error, "committing the photo event checkpoint failed"); + core.next_poll(POLL_INTERVAL).await; + continue; + } + cursor = Some(head); + if !plan.is_empty() { + core.events.publish(&[Topic::Photos]); + } } - cursor = Some(head); + if core.db.photos_need_work().unwrap_or(true) { + core.spawn_timeline_refresh(); + } + core.next_poll(POLL_INTERVAL).await; } } +async fn invalidate_photo_events( + core: &Core, + events: &[DriveEvent], +) -> proton_drive_rs::proton_sdk::error::Result<()> { + for event in events { + core.client.invalidate_caches_for_event(event).await?; + } + Ok(()) +} + /// What one batch of photos-volume events asks the gallery's tables to do. #[derive(Debug, Default, PartialEq)] pub(super) struct PhotoEventPlan { @@ -616,14 +631,22 @@ fn classify_photo_events( mut is_echo: impl FnMut(&NodeUid) -> bool, ) -> PhotoEventPlan { let mut plan = PhotoEventPlan::default(); - for event in events { + let mut seen = HashSet::new(); + for event in events.iter().rev() { match event { - DriveEvent::NodeDeleted { node_uid, .. } => plan.gone.push(node_uid.to_string()), + DriveEvent::NodeDeleted { node_uid, .. } => { + if seen.insert(node_uid) { + plan.gone.push(node_uid.to_string()); + } + } DriveEvent::NodeUpdated { node_uid, is_trashed, .. } => { + if !seen.insert(node_uid) { + continue; + } if *is_trashed { plan.gone.push(node_uid.to_string()); } else if !is_echo(node_uid) { @@ -641,47 +664,11 @@ fn classify_photo_events( DriveEvent::CursorAdvanced { .. } | DriveEvent::SharedWithMeUpdated { .. } => {} } } + plan.gone.reverse(); + plan.touched.reverse(); plan } -/// Apply one batch of photos-volume events to the gallery's tables. -fn apply_photo_events(core: &Core, events: &[DriveEvent]) { - let plan = classify_photo_events(events, |uid| core.take_self_change(uid)); - let PhotoEventPlan { - gone, - touched, - full, - } = &plan; - if !gone.is_empty() { - match core.db.photos_delete(gone) { - Ok(removed) if removed > 0 => { - debug!(removed, "photos removed by a remote event"); - } - Ok(_) => {} - Err(error) => warn!(%error, "removing remotely deleted photos failed"), - } - } - // A stale mark is what makes the next refresh cheap: it reads these photos' - // nodes and carries every other photo's metadata as it stands. - if !touched.is_empty() { - match core.db.photos_mark_unresolved(touched) { - Ok(marked) if marked > 0 => debug!(marked, "photos changed by a remote event"), - Ok(_) => {} - Err(error) => warn!(%error, "marking remotely changed photos failed"), - } - } - if *full { - match core.db.photos_mark_all_unresolved() { - Ok(marked) => debug!(marked, "the photo event stream lost continuity"), - Err(error) => warn!(%error, "marking the whole timeline unresolved failed"), - } - } - if !plan.is_empty() { - core.invalidate_photos(); - core.invalidate_albums(); - } -} - /// Keep the local-file index fresh for the launcher prompt's "This computer" /// results. Rebuilds the index whenever it is older than [`LOCAL_INDEX_TTL`], /// then sleeps; runs on its own thread for the life of the daemon. diff --git a/crates/pdfs-fuse/src/control.rs b/crates/pdfs-fuse/src/control.rs index 3878879..460a188 100644 --- a/crates/pdfs-fuse/src/control.rs +++ b/crates/pdfs-fuse/src/control.rs @@ -557,6 +557,42 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U // Registered before the request is even parsed, so a handler that wedges // inside the daemon shows up by name in `pdfs diagnostics`. let _inflight = super::diagnostics::InflightGuard::new(super::diagnostics::request_kind(&line)); + if let Ok(CtlRequest::PhotoMonths { kind }) = &request { + let started = std::time::Instant::now(); + let visibility = core.cached_gallery_visibility(); + let visibility_ms = started.elapsed().as_millis() as u64; + let mut database_ms = None; + let mut response_started = std::time::Instant::now(); + let response = match visibility { + Ok(visibility) => { + let excluded = serde_json::to_string(&visibility.media) + .expect("a set of file identifiers serializes"); + let query = std::time::Instant::now(); + let months = core.db.photos_months_visible(*kind, &excluded); + response_started = std::time::Instant::now(); + database_ms = Some(response_started.duration_since(query).as_millis() as u64); + match months { + Ok(months) => CtlResponse::PhotoMonths { + months: months + .into_iter() + .map(|(year, month, count)| PhotoMonth { year, month, count }) + .collect(), + }, + Err(error) => CtlResponse::error(error.into()), + } + } + Err(error) => CtlResponse::error(error), + }; + write_response(stream, response); + tracing::info!( + visibility_ms, + database_ms, + response_ms = response_started.elapsed().as_millis() as u64, + total_ms = started.elapsed().as_millis() as u64, + "PhotoMonths timings" + ); + return; + } let visibility = if matches!( &request, Ok(CtlRequest::PhotosTimeline { .. } @@ -569,9 +605,8 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U | CtlRequest::PhotoGroup { .. } | CtlRequest::PhotoAlbums | CtlRequest::AlbumPhotos { .. } - | CtlRequest::PhotoMonths { .. } | CtlRequest::PhotoThumbs { .. } - | CtlRequest::OpenGalleryImage { .. } + | CtlRequest::OpenGalleryImage { private: false, .. } | CtlRequest::OpenPhoto { .. }) ) { core.gallery_visibility() @@ -659,7 +694,7 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U // A full refresh is "forget what you know", not a second code // path: the ordinary refresh then finds every photo stale. if let Some(Err(e)) = full.then(|| core.db.photos_mark_all_unresolved()) { - warn!(error = %e, "marking the whole timeline unresolved failed"); + return write_response(stream, CtlResponse::error(e.into())); } // Whatever changed the timeline can just as easily have // changed an album; one scope covers the whole photos view. @@ -838,17 +873,22 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U core.remove_from_album(album, photos) }) } - Ok(CtlRequest::PhotoMonths { kind }) => { - match core.db.photos_months_visible(kind, &excluded) { - Ok(months) => CtlResponse::PhotoMonths { - months: months - .into_iter() - .map(|(year, month, count)| PhotoMonth { year, month, count }) - .collect(), - }, - Err(e) => CtlResponse::error(e.into()), + Ok(CtlRequest::PhotoPresence { uid, album }) => match core.cached_gallery_visibility() { + Ok(visibility) + if visibility.media.contains(&uid) + || album + .as_ref() + .is_some_and(|uid| visibility.albums.contains(uid)) => + { + CtlResponse::PhotoPresence { present: false } } - } + Ok(_) => match core.db.photos_contains(&uid, album.as_deref()) { + Ok(present) => CtlResponse::PhotoPresence { present }, + Err(error) => CtlResponse::error(error.into()), + }, + Err(error) => CtlResponse::error(error), + }, + Ok(CtlRequest::PhotoMonths { .. }) => unreachable!("handled before visibility requests"), Ok(CtlRequest::PhotoThumbs { uids }) => { let parsed: Vec = uids .iter() @@ -915,10 +955,16 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U Ok(CtlRequest::DriveGallery { action }) => core .drive_gallery(action) .unwrap_or_else(CtlResponse::error), - Ok(CtlRequest::OpenGalleryVideo { uid }) => core - .open_gallery_video(&uid) + Ok(CtlRequest::OpenGalleryVideo { uid, private }) => core + .open_gallery_video(&uid, private) .unwrap_or_else(CtlResponse::error), - Ok(CtlRequest::OpenGalleryImage { uid }) => match visibility + Ok(CtlRequest::OpenGalleryImage { uid, private: true }) => { + core.gallery_image(&uid).unwrap_or_else(CtlResponse::error) + } + Ok(CtlRequest::OpenGalleryImage { + uid, + private: false, + }) => match visibility .permits(&uid) .and_then(|()| core.open_shared_file(&uid)) { @@ -930,8 +976,8 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U Ok(CtlRequest::CloseGalleryVideo { token }) => core .close_gallery_video(&token) .unwrap_or_else(CtlResponse::error), - Ok(CtlRequest::GalleryThumbnail { uid }) => core - .gallery_thumbnail(&uid) + Ok(CtlRequest::GalleryThumbnail { uid, private }) => core + .gallery_thumbnail(&uid, private) .unwrap_or_else(CtlResponse::error), // The scan alone walks every archive's central directory, so even the // dry run goes to a background thread and is read back through @@ -1049,7 +1095,8 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U // timeline, and the GUI reloads the gallery the moment this // reply lands — so refresh now rather than leaving it to a // background pass that would land just after that reload. - if let Err(e) = core.rt.block_on(core.refresh_timeline()) { + core.invalidate_photos(); + if let Err(e) = core.refresh_timeline_joined() { warn!(error = %e, "timeline refresh after upload failed"); } CtlResponse::Ok { diff --git a/crates/pdfs-fuse/src/gallery.rs b/crates/pdfs-fuse/src/gallery.rs index 6ffaa1f..2ba81bb 100644 --- a/crates/pdfs-fuse/src/gallery.rs +++ b/crates/pdfs-fuse/src/gallery.rs @@ -5,8 +5,8 @@ mod video; use std::collections::HashSet; use std::path::PathBuf; use std::sync::{ - Arc, - atomic::{AtomicBool, Ordering}, + Arc, RwLock, + atomic::{AtomicU64, Ordering}, }; use std::time::{Duration, Instant}; @@ -18,7 +18,7 @@ use pg_app::{App, View}; use pg_core::CancellationToken; use pg_core::model::{AssetKey, SourceId}; use proton_drive_rs::proton_sdk::session::ProtonApiSession; -use tokio::sync::{Mutex, OnceCell}; +use tokio::sync::{Mutex, Notify, OnceCell}; use super::{Core, NodeUid, parse_uid}; @@ -27,8 +27,10 @@ pub(super) struct Gallery { session: ProtonApiSession, cancel: CancellationToken, app: OnceCell, - checked: Mutex>)>>, - unlocked: AtomicBool, + checked: Mutex>, + visibility: RwLock>>, + refresh: Notify, + access: AtomicU64, video: video::Server, } @@ -55,7 +57,9 @@ impl Gallery { cancel: CancellationToken::new(), app: OnceCell::new(), checked: Mutex::new(None), - unlocked: AtomicBool::new(false), + visibility: RwLock::default(), + refresh: Notify::new(), + access: AtomicU64::new(0), video: video::Server::default(), } } @@ -91,68 +95,236 @@ impl Gallery { } let mut checked = self.checked.lock().await; if !force - && let Some((instant, Some(visibility))) = checked.as_ref() - && instant.elapsed() < Duration::from_secs(60) + && let Some(instant) = *checked + && instant.elapsed() + < if self.snapshot().is_some() { + Duration::from_secs(60) + } else { + Duration::from_secs(5) + } { - return Ok(visibility.clone()); + return self.snapshot().ok_or_else(visibility_loading); } - let previous = checked.as_ref().map(|(_, visibility)| visibility.as_ref()); - let visibility = async { - let account = self.account()?; - app.refresh_gallery_configuration(false) - .await - .map_err(gallery_error)?; - let mut visibility = Visibility::default(); - for (volume, node) in app - .catalog - .hidden_assets(account.clone()) + if self.snapshot().is_none() + && app + .gallery_visibility_cached() .await .map_err(gallery_error)? - { - visibility - .media - .insert(NodeUid::new(volume.into(), node.into()).to_string()); - } - visibility.media.extend( - core.db - .photo_group_members_for(&visibility.media) - .map_err(CoreError::from)?, - ); - for album in app - .catalog - .hidden_configuration_albums(account) - .await - .map_err(gallery_error)? - { - visibility.albums.insert( - NodeUid::new(album.volume.as_str().into(), album.node.as_str().into()) - .to_string(), - ); - } - Ok::<_, CoreError>(Arc::new(visibility)) + { + self.publish_visibility(core, self.read_visibility(core, app).await?); } - .await; - let current = visibility.as_ref().ok(); - if previous.is_some_and(|previous| previous != current) { + let started = Instant::now(); + let result = tokio::select! { + biased; + _ = self.cancel.cancelled() => Err(CoreError::remote("The Gallery session expired")), + result = tokio::time::timeout(Duration::from_secs(20), async { + app.refresh_gallery_configuration(false).await.map_err(gallery_error)?; + self.read_visibility(core, app).await + }) => result.unwrap_or_else(|_| Err(CoreError::remote("Gallery visibility check timed out"))), + }; + tracing::debug!( + elapsed_ms = started.elapsed().as_millis() as u64, + success = result.is_ok(), + "Gallery visibility refresh" + ); + *checked = Some(Instant::now()); + if let Ok(visibility) = result { + self.publish_visibility(core, visibility.clone()); + return Ok(visibility); + } + if !force && let Some(visibility) = self.snapshot() { + return Ok(visibility); + } + result + } + + fn snapshot(&self) -> Option> { + self.visibility + .read() + .unwrap_or_else(|e| e.into_inner()) + .clone() + } + + fn publish_visibility(&self, core: &Core, visibility: Arc) { + let mut snapshot = self.visibility.write().unwrap_or_else(|e| e.into_inner()); + if snapshot.as_ref() != Some(&visibility) { + *snapshot = Some(visibility); + drop(snapshot); self.video.close_all(); core.events .publish(&[pdfs_core::control::Topic::GalleryVisibilitySynced]); } - *checked = Some((Instant::now(), current.cloned())); - visibility + } + + async fn read_visibility(&self, core: &Core, app: &App) -> CoreResult> { + let account = self.account()?; + let mut visibility = Visibility::default(); + for (volume, node) in app + .catalog + .hidden_assets(account.clone()) + .await + .map_err(gallery_error)? + { + visibility + .media + .insert(NodeUid::new(volume.into(), node.into()).to_string()); + } + visibility.media.extend( + core.db + .photo_group_members_for(&visibility.media) + .map_err(CoreError::from)?, + ); + for album in app + .catalog + .hidden_configuration_albums(account) + .await + .map_err(gallery_error)? + { + visibility.albums.insert( + NodeUid::new(album.volume.as_str().into(), album.node.as_str().into()).to_string(), + ); + } + Ok(Arc::new(visibility)) } fn account(&self) -> CoreResult { pg_core::model::AccountId::new(self.session.user_id().as_str()).map_err(gallery_error) } + async fn page( + &self, + app: &App, + album: Option, + proton: bool, + access: Option, + offset: usize, + limit: usize, + ) -> CoreResult { + let private = access.is_some(); + let parent = album + .as_ref() + .map(|a| (a.gallery.as_str(), a.album.as_str())); + let mut albums = Vec::new(); + if offset == 0 && !proton { + if private && parent.is_none() { + albums.extend( + app.photo_albums_with_hidden(true) + .await + .map_err(gallery_error)? + .into_iter() + .filter(|entry| entry.settings.hidden) + .map(|entry| gallery_album(entry, true)), + ); + albums.extend( + app.hidden_drive_albums() + .await + .map_err(gallery_error)? + .into_iter() + .map(|entry| gallery_album(entry, false)), + ); + } else { + albums.extend( + app.drive_albums(parent, private) + .await + .map_err(gallery_error)? + .into_iter() + .map(|entry| gallery_album(entry, false)), + ); + } + } + let (items, total) = if let Some(GalleryPlace { gallery, album }) = album { + let view = if proton && private { + let id = SourceId::new(&album).map_err(gallery_error)?; + if !app + .catalog + .album_settings(id) + .await + .map_err(gallery_error)? + .hidden + { + return Err(CoreError::not_found("Hidden album")); + } + View::PhotoAlbum(album) + } else { + if private + && !app + .catalog + .drive_album_is_private( + SourceId::new(&gallery).map_err(gallery_error)?, + SourceId::new(&album).map_err(gallery_error)?, + ) + .await + .map_err(gallery_error)? + { + return Err(CoreError::not_found("Hidden gallery folder")); + } + View::DriveAlbum { gallery, album } + }; + let outline = app + .outline_with_visibility(view, false, private) + .await + .map_err(gallery_error)?; + let total = outline.len(); + let items = app + .outline_items(&outline, offset.min(total), limit.clamp(1, 250)) + .await + .map_err(gallery_error)? + .into_iter() + .flatten() + .map(|item| PhotoItem { + uid: asset_uid(&item.key), + capture_time: item.sort_time, + thumb_path: None, + name: Some(item.name), + ratio: item.aspect_ratio, + no_thumb: false, + kind: if item.is_video { + PhotoKind::Video + } else { + PhotoKind::Photo + }, + favorite: item.favorite, + group_size: 1, + has_raw: false, + place_id: None, + }) + .collect(); + (items, total) + } else { + (Vec::new(), 0) + }; + self.require_access(access)?; + Ok(Response::GalleryPage { + albums, + items, + total, + }) + } + fn lock(&self) { - self.unlocked.store(false, Ordering::SeqCst); + let _ = self + .access + .try_update(Ordering::SeqCst, Ordering::SeqCst, |value| { + Some((value | 1).wrapping_add(1)) + }); self.video.close_all(); } - fn unlocked(&self) -> bool { - self.unlocked.load(Ordering::SeqCst) + fn private_access(&self) -> CoreResult { + let access = self.access.load(Ordering::SeqCst); + if access & 1 == 0 { + return Err(CoreError::invalid("Unlock hidden albums to open this item")); + } + Ok(access) + } + + fn require_access(&self, access: Option) -> CoreResult<()> { + if let Some(access) = access + && self.private_access()? != access + { + return Err(CoreError::invalid("Hidden albums were locked")); + } + Ok(()) } pub(super) async fn poll(self: Arc, core: Core) { @@ -160,9 +332,11 @@ impl Gallery { tokio::select! { biased; _ = self.cancel.cancelled() => break, + _ = self.refresh.notified() => {}, _ = tokio::time::sleep(Duration::from_secs(60)) => {} } - if let Some(app) = self.app.get() { + if let Ok(Ok(app)) = tokio::time::timeout(Duration::from_secs(5), self.app(&core)).await + { let _ = self.ensure_visibility(&core, app, false).await; } } @@ -177,6 +351,28 @@ impl Gallery { } } +fn gallery_album(entry: pg_core::library::Album, proton: bool) -> GalleryAlbum { + GalleryAlbum { + place: GalleryPlace { + gallery: entry.gallery.to_string(), + album: entry.source.id.to_string(), + }, + proton, + folder: GalleryFolder { + uid: NodeUid::new( + entry.source.volume.as_str().into(), + entry.source.root.as_str().into(), + ) + .to_string(), + name: entry.settings.title.unwrap_or(entry.source.label), + }, + cover: entry.cover.map(|asset| asset_uid(&asset.key)), + items: entry.direct_items, + folders: entry.child_albums, + hidden: entry.settings.hidden, + } +} + fn gallery_error(error: impl std::fmt::Display) -> CoreError { CoreError::remote(error.to_string()) } @@ -195,7 +391,28 @@ fn asset_uid(asset: &AssetKey) -> String { NodeUid::new(asset.volume.as_str().into(), asset.node.as_str().into()).to_string() } +fn visibility_loading() -> CoreError { + CoreError::new( + pdfs_core::control::ErrorKind::Offline, + "Gallery visibility is loading. Try again shortly.", + ) +} + impl Core { + pub(super) fn cached_gallery_visibility(&self) -> CoreResult> { + if self.gallery.is_none() { + return Ok(Arc::default()); + } + let gallery = self.gallery_host()?; + match gallery.snapshot() { + Some(snapshot) => Ok(snapshot), + None => { + gallery.refresh.notify_one(); + Err(visibility_loading()) + } + } + } + pub(super) fn gallery_visibility(&self) -> CoreResult> { if self.gallery.is_none() { return Ok(Arc::default()); @@ -203,12 +420,7 @@ impl Core { let gallery = self.gallery_host()?; self.rt.block_on(async { let app = gallery.app(self).await?; - let visibility = gallery.ensure_visibility(self, app, false).await?; - Ok(if gallery.unlocked() { - Arc::default() - } else { - visibility - }) + gallery.ensure_visibility(self, app, false).await }) } @@ -224,9 +436,13 @@ impl Core { let action = match action { GalleryAction::Unlock { passphrase } => { let passphrase = zeroize::Zeroizing::new(passphrase); + let access = gallery.access.load(Ordering::SeqCst); pdfs_core::auth::unlock_gallery(gallery.session.username(), &passphrase) .map_err(gallery_error)?; - gallery.unlocked.store(true, Ordering::SeqCst); + gallery + .access + .compare_exchange(access, access | 1, Ordering::SeqCst, Ordering::SeqCst) + .map_err(|_| CoreError::invalid("Hidden albums were locked"))?; return Ok(done()); } GalleryAction::Lock => { @@ -240,87 +456,23 @@ impl Core { gallery .ensure_visibility(self, app, matches!(action, GalleryAction::Refresh)) .await?; - let unlocked = gallery.unlocked(); match action { GalleryAction::Unlock { .. } | GalleryAction::Lock => unreachable!(), GalleryAction::List { album, offset, limit, + } => gallery.page(app, album, false, None, offset, limit).await, + GalleryAction::PrivateList { + album, + proton, + offset, + limit, } => { - let parent = album - .as_ref() - .map(|a| (a.gallery.as_str(), a.album.as_str())); - let albums = if offset == 0 { - app.drive_albums(parent, unlocked) - .await - .map_err(gallery_error)? - .into_iter() - .map(|entry| GalleryAlbum { - place: GalleryPlace { - gallery: entry.gallery.to_string(), - album: entry.source.id.to_string(), - }, - folder: GalleryFolder { - uid: NodeUid::new( - entry.source.volume.as_str().into(), - entry.source.root.as_str().into(), - ) - .to_string(), - name: entry.settings.title.unwrap_or(entry.source.label), - }, - cover: entry.cover.map(|asset| asset_uid(&asset.key)), - items: entry.direct_items, - folders: entry.child_albums, - hidden: entry.settings.hidden, - }) - .collect() - } else { - Vec::new() - }; - let (items, total) = if let Some(GalleryPlace { gallery, album }) = album { - let view = app - .outline_with_visibility( - View::DriveAlbum { gallery, album }, - false, - unlocked, - ) - .await - .map_err(gallery_error)?; - let total = view.len(); - let items = app - .outline_items(&view, offset.min(total), limit.clamp(1, 250)) - .await - .map_err(gallery_error)? - .into_iter() - .flatten() - .map(|item| PhotoItem { - uid: asset_uid(&item.key), - capture_time: item.sort_time, - thumb_path: None, - name: Some(item.name), - ratio: item.aspect_ratio, - no_thumb: false, - kind: if item.is_video { - PhotoKind::Video - } else { - PhotoKind::Photo - }, - favorite: item.favorite, - group_size: 1, - has_raw: false, - place_id: None, - }) - .collect(); - (items, total) - } else { - (Vec::new(), 0) - }; - Ok(Response::GalleryPage { - albums, - items, - total, - }) + let access = gallery.private_access()?; + gallery + .page(app, album, proton, Some(access), offset, limit) + .await } GalleryAction::Folders { parent } => { let list = app @@ -365,20 +517,29 @@ impl Core { } GalleryAction::Cover { album, uid: node } => { let id = SourceId::new(&album.album).map_err(gallery_error)?; - app.outline(View::DriveAlbum { - gallery: album.gallery, - album: album.album, - }) - .await - .map_err(gallery_error)?; + let root = SourceId::new(&album.gallery).map_err(gallery_error)?; + app.checked_album(album.gallery, album.album) + .await + .map_err(gallery_error)?; + let access = if app + .catalog + .drive_album_is_private(root.clone(), id.clone()) + .await + .map_err(gallery_error)? + { + Some(gallery.private_access()?) + } else { + None + }; let mut settings = app .catalog .album_settings(id.clone()) .await .map_err(gallery_error)?; + gallery.require_access(access)?; settings.cover = Some(gallery.asset(&uid(&node)?)?); app.catalog - .set_album_settings(id, settings) + .set_album_settings_at(Some(root), id, settings) .await .map_err(gallery_error)?; gallery.ensure_visibility(self, app, true).await?; @@ -388,20 +549,54 @@ impl Core { }) } - pub(super) fn open_gallery_video(&self, node: &str) -> CoreResult { + pub(super) fn open_gallery_video(&self, node: &str, private: bool) -> CoreResult { let gallery = self.gallery_host()?; let uid = uid(node)?; self.rt.block_on(async { let app = gallery.app(self).await?; let visibility = gallery.ensure_visibility(self, app, false).await?; - if !gallery.unlocked() { + let access = if private { + Some(gallery.private_access()?) + } else { visibility.permits(node)?; - } + None + }; let stream = app .stream_video(&gallery.asset(&uid)?) .await .map_err(gallery_error)?; - gallery.video.open(stream, &gallery.cancel).await + let response = gallery.video.open(stream, &gallery.cancel).await?; + if let Err(error) = gallery.require_access(access) { + if let Response::GalleryVideo { token, .. } = &response { + gallery.video.close(token); + } + return Err(error); + } + Ok(response) + }) + } + + pub(super) fn gallery_image(&self, node: &str) -> CoreResult { + use base64::{Engine, engine::general_purpose::STANDARD}; + let gallery = self.gallery_host()?; + let access = gallery.private_access()?; + let asset = gallery.asset(&uid(node)?)?; + self.rt.block_on(async { + let app = gallery.app(self).await?; + let bytes = tokio::time::timeout(Duration::from_secs(30), async { + if let Some(bytes) = app.preview(&asset).await? { + Ok(bytes) + } else { + app.original_in_memory(&asset, 8 * 1024 * 1024).await + } + }) + .await + .map_err(|_| CoreError::remote("Proton took too long to open this photo"))? + .map_err(gallery_error)?; + gallery.require_access(Some(access))?; + Ok(Response::GalleryThumbnail { + data: Some(STANDARD.encode(bytes)), + }) }) } @@ -410,21 +605,25 @@ impl Core { Ok(done()) } - pub(super) fn gallery_thumbnail(&self, node: &str) -> CoreResult { + pub(super) fn gallery_thumbnail(&self, node: &str, private: bool) -> CoreResult { use base64::{Engine, engine::general_purpose::STANDARD}; let gallery = self.gallery_host()?; let asset = gallery.asset(&uid(node)?)?; self.rt.block_on(async { let app = gallery.app(self).await?; let visibility = gallery.ensure_visibility(self, app, false).await?; - if !gallery.unlocked() { + let access = if private { + Some(gallery.private_access()?) + } else { visibility.permits(node)?; - } + None + }; let data = app .thumbnail(&asset) .await .map_err(gallery_error)? .map(|bytes| STANDARD.encode(bytes)); + gallery.require_access(access)?; Ok(Response::GalleryThumbnail { data }) }) } diff --git a/crates/pdfs-fuse/src/lib.rs b/crates/pdfs-fuse/src/lib.rs index 5418b08..9521400 100644 --- a/crates/pdfs-fuse/src/lib.rs +++ b/crates/pdfs-fuse/src/lib.rs @@ -5772,7 +5772,7 @@ impl Core { /// Drop the persisted photos timeline's freshness stamp, so the next timeline /// read fetches rather than serving what it already has. fn invalidate_photos(&self) { - let _ = self.db.clear_state(PHOTOS_SYNCED_MS); + let _ = self.db.photos_invalidate(); } /// Drop one folder's cached child listing (`rel` is mountpoint-relative), so diff --git a/crates/pdfs-fuse/src/photos.rs b/crates/pdfs-fuse/src/photos.rs index b8d1e16..373652a 100644 --- a/crates/pdfs-fuse/src/photos.rs +++ b/crates/pdfs-fuse/src/photos.rs @@ -32,7 +32,7 @@ use tracing::{debug, info, warn}; use super::drive::RevisionRead; use super::{ - Core, PHOTOS_AVAILABLE, PHOTOS_SYNCED_MS, TIMELINE_ENRICH_CHUNK, TIMELINE_TTL, WriteAuthority, + Core, PHOTOS_AVAILABLE, PHOTOS_SYNCED_MS, TIMELINE_ENRICH_CHUNK, WriteAuthority, link, node_size, now_ms, parse_uid, }; @@ -1144,18 +1144,6 @@ impl Drop for ProgressGuard<'_> { } } -/// What a timeline enrichment pass resolves for one photo, beyond what the -/// timeline listing already carries. -#[derive(Clone, Debug)] -struct PhotoMeta { - name: Option, - media_type: Option, - favorite: bool, - content_hash: Option, - /// Where the photo was taken, as its uploader recorded it. - location: Option<(f64, f64)>, -} - impl Core { /// [`upload_thumbnails`] for a file about to upload, staging any RAW copy /// under this cache. Blocking. @@ -1187,19 +1175,26 @@ impl Core { excluded: &str, ) -> CoreResult>> { let count = self.db.photos_count().map_err(CoreError::from)?; - if count == 0 { - // Nothing to serve, so this one request has to wait for the fetch — - // unless we already know the account has no photos volume and the - // answer is a fresh "no". - let known_empty = self.db.state_i64(PHOTOS_AVAILABLE).ok().flatten() == Some(0); - if known_empty && !self.listing_stale(PHOTOS_SYNCED_MS, TIMELINE_TTL) { - return Ok(None); + let listed = self + .db + .state_i64(PHOTOS_SYNCED_MS) + .map_err(CoreError::from)? + .is_some(); + if !listed { + if count == 0 { + if !self.refresh_timeline_joined()? { + return Ok(None); + } + } else { + self.spawn_timeline_refresh(); } - if !self.refresh_timeline_joined()? { - return Ok(None); - } - } else if self.listing_stale(PHOTOS_SYNCED_MS, TIMELINE_TTL) { - self.spawn_timeline_refresh(); + } else if self + .db + .state_i64(PHOTOS_AVAILABLE) + .map_err(CoreError::from)? + == Some(0) + { + return Ok(None); } // The filter is only as good as the album contents on disk, and those // are fetched lazily, per album opened. Fill in the missing ones before @@ -2495,162 +2490,113 @@ impl Core { } } - /// Whether the listing stamped under `key` is older than `ttl` (or was never - /// fetched). + /// Commit the lightweight listing before resolving pending nodes. The + /// feed generation fences both commits against events received in flight. pub(crate) async fn refresh_timeline(&self) -> CoreResult { let started = Instant::now(); + let generation = self + .db + .photo_projection_generation() + .map_err(CoreError::from)?; let photos = self.photos(); - if photos - .get_photos_root() - .await - .map_err(|e| CoreError::from_api(&e, "photos root"))? + if self + .db + .state_i64(PHOTOS_SYNCED_MS) + .map_err(CoreError::from)? .is_none() { - let _ = self.db.set_state_i64(PHOTOS_AVAILABLE, 0); - let _ = self.db.set_state_i64(PHOTOS_SYNCED_MS, now_ms()); + let available = link::bounded(photos.get_photos_root()) + .await + .map_err(|e| CoreError::from_api(&e, "photos root"))? + .is_some(); + let items = if available { + link::bounded_by(super::BATCH_CALL_TIMEOUT, photos.enumerate_timeline()) + .await + .map_err(|e| CoreError::from_api(&e, "timeline"))? + .into_iter() + .map(|item| db::TimelineRow::new(item.uid.to_string(), item.capture_time)) + .collect() + } else { + Vec::new() + }; + if !self + .db + .photos_replace_at(&items, generation, available, now_ms()) + .map_err(CoreError::from)? + { + return Err(CoreError::remote( + "Photos changed during the refresh. Try again shortly.", + )); + } + if !available { + return Ok(false); + } + } else if self + .db + .state_i64(PHOTOS_AVAILABLE) + .map_err(CoreError::from)? + == Some(0) + { return Ok(false); } - let items = photos - .enumerate_timeline() - .await - .map_err(|e| CoreError::from_api(&e, "timeline"))?; - // The timeline DTO carries only a uid and capture time, but the gallery - // has to split into its tabs — which needs each photo's name and media - // type. Resolve those in batches off the request path. Best-effort: a - // photo whose node we fail to resolve keeps whatever was learned before - // (or classifies from nothing, i.e. a still photo), so a partial resolve - // never blanks the timeline. - // - // Only photos the daemon has never read, and ones a remote event marked - // stale, are read. Resolving all of them every time is what made a - // 12k-photo refresh take minutes (`docs/BUGS.md` B92): this metadata does - // not change on its own, and when it does change the event feed names the - // uid that changed (`Db::photos_mark_unresolved`). - let known: HashSet = self - .db - .photos_resolved() - .map_err(CoreError::from)? - .into_iter() - .collect(); - let uids: Vec = items - .iter() - .filter(|it| !known.contains(&it.uid.to_string())) - .map(|it| it.uid.clone()) - .collect(); - let resolved_at = now_ms(); - let mut meta: HashMap = HashMap::new(); - // A main photo names its related photos rather than the other way round, - // so the relation is recorded from whichever end resolves — the two ends - // can land in different chunks, and one of them may not resolve at all. - let mut main_of: HashMap = HashMap::new(); - let mut stopped = false; - // Photos read before count as done, so the bar picks up where an - // interrupted pass left off. Cleared however the pass ends. - let skipped = items.len() - uids.len(); + let pending = self.db.photos_pending().map_err(CoreError::from)?; + let total = self.db.photos_count().map_err(CoreError::from)?; + let skipped = total.saturating_sub(pending.len()); + let mut resolved = 0; let progress = ProgressGuard(&self.timeline_progress); - if !uids.is_empty() { - *progress.0.lock() = Some((skipped, items.len())); - } - for (index, chunk) in uids.chunks(TIMELINE_ENRICH_CHUNK).enumerate() { - // Teardown cancels the runtime under this loop, and every chunk - // still in flight then fails its decrypt task — a burst of - // "skipping undecryptable photo ... task was cancelled" warnings - // that read like corruption and are only a shutdown. Stop asking - // for chunks instead. What resolved so far is kept below; the rest - // stay unresolved and are read by the next refresh. + for (index, chunk) in pending.chunks(TIMELINE_ENRICH_CHUNK).enumerate() { if self.shutdown.is_stopping() { - stopped = true; break; } - match photos.enumerate_nodes(chunk).await { - Ok(nodes) => { - for node in nodes { - let media_type = match &node.kind { - NodeKind::File { media_type, .. } => Some(media_type.clone()), - NodeKind::Folder => None, - }; - // The favorite state is a tag on the photo node, so it - // rides along with the metadata resolve rather than - // costing a listing of its own. - let favorite = node - .photo - .as_ref() - .is_some_and(|p| p.tags.contains(&PhotoTag::Favorite)); - let key = node.uid.to_string(); - let content_hash = node.photo.as_ref().and_then(|p| p.content_hash.clone()); - let location = node - .photo - .as_ref() - .and_then(|p| p.location) - .map(|l| (l.latitude, l.longitude)); - if let Some(photo) = node.photo.as_ref() { - if let Some(main) = photo.main_photo_uid.as_ref() { - main_of.insert(key.clone(), main.to_string()); - } - for related in &photo.related_photo_uids { - main_of.insert(related.to_string(), key.clone()); - } - } - meta.insert( - key, - PhotoMeta { - name: Some(node.name), - media_type, - favorite, - content_hash, - location, - }, - ); + *progress.0.lock() = Some((skipped + index * TIMELINE_ENRICH_CHUNK, total)); + let uids: Vec<_> = chunk.iter().filter_map(|uid| parse_uid(uid)).collect(); + let nodes = link::bounded(photos.enumerate_nodes(&uids)) + .await + .map_err(|e| CoreError::from_api(&e, "read photo metadata"))?; + let rows: Vec<_> = nodes + .into_iter() + .filter_map(|node| { + let NodeKind::File { media_type, .. } = node.kind else { + return None; + }; + if node.trashed { + return None; } - } - Err(e) => warn!(error = %e, "resolving photo metadata for a timeline chunk failed"), + let photo = node.photo.as_ref(); + Some(db::TimelineRow { + name: Some(node.name), + media_type: Some(media_type), + favorite: Some(photo.is_some_and(|p| p.tags.contains(&PhotoTag::Favorite))), + content_hash: photo.and_then(|p| p.content_hash.clone()), + location: photo + .and_then(|p| p.location) + .map(|l| (l.latitude, l.longitude)), + main_uid: photo + .and_then(|p| p.main_photo_uid.as_ref()) + .map(ToString::to_string), + resolved_at: Some(now_ms()), + ..db::TimelineRow::new(node.uid.to_string(), 0) + }) + }) + .collect(); + if !self + .db + .photos_resolve_at(generation, &rows) + .map_err(CoreError::from)? + { + return Err(CoreError::remote( + "Photos changed during the refresh. Try again shortly.", + )); } - let done = (skipped + (index + 1) * TIMELINE_ENRICH_CHUNK).min(items.len()); - *progress.0.lock() = Some((done, items.len())); + resolved += rows.len(); } - drop(progress); - - let rows: Vec = items - .iter() - .map(|it| { - let key = it.uid.to_string(); - let main_uid = main_of.get(&key).cloned(); - // An unresolved photo keeps whatever was learned before, for the - // favorite flag as much as for the name and media type. - match meta.get(&key).cloned() { - Some(m) => db::TimelineRow { - name: m.name, - media_type: m.media_type, - favorite: Some(m.favorite), - content_hash: m.content_hash, - location: m.location, - main_uid, - resolved_at: Some(resolved_at), - ..db::TimelineRow::new(key, it.capture_time) - }, - None => db::TimelineRow { - main_uid, - ..db::TimelineRow::new(key, it.capture_time) - }, - } - }) - .collect(); - self.db.photos_replace(&rows).map_err(CoreError::from)?; - let _ = self.db.set_state_i64(PHOTOS_AVAILABLE, 1); - let _ = self.db.set_state_i64(PHOTOS_SYNCED_MS, now_ms()); - // How long this took is the first thing to know when a refresh looks - // like it never happened, and the chunk count is what it scales with. info!( - photos = rows.len(), - // `resolved` is what came back, which is short of `wanted` when - // shutdown cut the pass off or a chunk failed. - resolved = meta.len(), - wanted = uids.len(), - skipped = rows.len().saturating_sub(uids.len()), - chunks = uids.len().div_ceil(TIMELINE_ENRICH_CHUNK), + photos = total, + resolved, + wanted = pending.len(), + skipped, elapsed_ms = started.elapsed().as_millis() as u64, - stopped, "photos timeline refreshed" ); Ok(true) @@ -2674,7 +2620,11 @@ impl Core { // A refresh that landed stamped the timeline fresh. One that failed // did not, and the caller gets this refresh's own error instead of // an empty timeline. - if !self.listing_stale(PHOTOS_SYNCED_MS, TIMELINE_TTL) + if self + .db + .state_i64(PHOTOS_SYNCED_MS) + .map_err(CoreError::from)? + .is_some() || self.timeline_refreshing.swap(true, Ordering::SeqCst) { return Ok(self.db.state_i64(PHOTOS_AVAILABLE).ok().flatten() != Some(0)); diff --git a/crates/pdfs-gui/src/app/events.rs b/crates/pdfs-gui/src/app/events.rs index 6cb1219..0df7f25 100644 --- a/crates/pdfs-gui/src/app/events.rs +++ b/crates/pdfs-gui/src/app/events.rs @@ -100,6 +100,9 @@ fn on_feed(ui: &Rc, state: &Rc, feed: Feed, hidden: bool) { follow_takeout(ui, state, &jobs); } Feed::Event(Event::Changed { topics }) if hidden => { + if topics.contains(&Topic::Photos) { + check_photo_viewer(ui); + } state.deferred.borrow_mut().extend(topics); } Feed::Event(Event::Changed { topics }) => follow_changes(ui, state, &topics), @@ -133,12 +136,10 @@ fn follow_changes(ui: &Rc, state: &FeedState, topics: &[Topic]) { refresh_file_thumbnails(ui); } let page = ui.stack.visible_child_name(); - if changed(Topic::GalleryVisibilitySynced) - && let Some(browser) = ui.drive_galleries.borrow().upgrade() - { - browser.refresh_visibility(); - } if changed(Topic::GalleryVisibility) || changed(Topic::GalleryVisibilitySynced) { + if let Some(browser) = ui.drive_galleries.borrow().upgrade() { + browser.refresh_visibility(); + } for window in gtk4::Window::list_toplevels() { if let Ok(window) = window.downcast::() && window.has_css_class("photo-viewer-window") @@ -146,23 +147,34 @@ fn follow_changes(ui: &Rc, state: &FeedState, topics: &[Topic]) { window.close(); } } + ui.gallery + .thumb_generation + .set(ui.gallery.thumb_generation.get().wrapping_add(1)); + ui.gallery.thumb_queue.borrow_mut().clear(); + ui.gallery.decode_queue.borrow_mut().clear(); + ui.gallery.thumb_wanted.borrow_mut().clear(); ui.gallery.photo_tex.borrow_mut().clear(); ui.gallery.photo_tex_order.borrow_mut().clear(); ui.gallery.model.remove_all(); ui.gallery.groups.remove_all(); + ui.gallery.row_by_photo.borrow_mut().clear(); ui.gallery.timeline_stale.set(true); if page.as_deref() == Some("gallery") { match ui.gallery.content.visible_child_name().as_deref() { Some("albums") => load_albums(ui), + Some("drive-galleries") => {} Some("places") => load_places(ui), _ => load_gallery(ui, false), } } } - // A timeline out of sight is read again when the user comes back to it; - // one on screen is left alone (below). - if changed(Topic::Photos) && (page.as_deref() != Some("gallery") || !photo_grid_shown(ui)) { - ui.gallery.timeline_stale.set(true); + if changed(Topic::Photos) { + check_photo_viewer(ui); + if page.as_deref() != Some("gallery") || !photo_grid_shown(ui) { + ui.gallery.timeline_stale.set(true); + } else { + refresh_visible_photos(ui); + } } match page.as_deref() { // A search on screen is left alone: reloading would swap its hits for @@ -170,8 +182,6 @@ fn follow_changes(ui: &Rc, state: &FeedState, topics: &[Topic]) { Some("browser") if changed(Topic::Files) && ui.browser.search.text().trim().is_empty() => { load_browser(ui) } - // The timeline is left alone: reloading it would throw away the place - // the user scrolled to. F5 reloads it on request. Some("gallery") if changed(Topic::Photos) && ui.gallery.content.visible_child_name().as_deref() == Some("albums") => diff --git a/crates/pdfs-gui/src/app/main.rs b/crates/pdfs-gui/src/app/main.rs index 55d237f..b2a5b99 100644 --- a/crates/pdfs-gui/src/app/main.rs +++ b/crates/pdfs-gui/src/app/main.rs @@ -561,6 +561,10 @@ fn build_window(app: &adw::Application) { gallery: GalleryState { model: gallery_widgets.model.clone(), groups: gallery_widgets.groups.clone(), + row_by_photo: RefCell::default(), + rendered_layout: Cell::new(None), + rendered_photos: Cell::new(0), + align_tick: RefCell::default(), row_height: Cell::new(ROW_DEFAULT), scrolling_down: Cell::new(true), scroll_offset: Cell::new(0.0), @@ -617,6 +621,10 @@ fn build_window(app: &adw::Application) { memory_cards: gallery_widgets.memory_cards.clone(), has_memories: Cell::new(false), date_suppress: Cell::new(false), + months_loading: Cell::new(false), + months_pending: Cell::new(false), + changes_pending: Cell::new(false), + viewer: RefCell::new(std::rc::Weak::new()), reload_pending: Cell::new(false), loading: Cell::new(false), has_more: Cell::new(false), @@ -628,12 +636,14 @@ fn build_window(app: &adw::Application) { photo_nothumb: RefCell::new(HashSet::new()), thumb_wanted: RefCell::new(HashMap::new()), thumb_queue: RefCell::new(VecDeque::new()), - thumb_inflight: Cell::new(false), + thumb_inflight: RefCell::default(), + thumb_generation: Cell::new(0), decode_queue: RefCell::new(VecDeque::new()), decode_idle: Cell::new(false), thumb_source: RefCell::new(None), relayout_source: RefCell::new(None), bound: RefCell::new(BTreeMap::new()), + visible_tiles_pending: Cell::new(0), tile_pools: RefCell::new(HashMap::new()), list: gallery_widgets.list.clone(), selecting: Cell::new(false), @@ -762,10 +772,6 @@ fn build_window(app: &adw::Application) { &gallery_widgets.scroll, &gallery_widgets.square_action, ); - gallery_widgets.drive_galleries.connect_clicked({ - let ui = ui.clone(); - move |_| pages::drive_galleries::open(&ui) - }); wire_gallery_empty( &ui, &gallery_widgets.empty_upload, @@ -793,6 +799,11 @@ fn build_window(app: &adw::Application) { // thumbnail generation as it paints. cancel_file_thumbnails(&ui_nav); sync_sidebar(&ui_nav); + if st.visible_child_name().as_deref() != Some("gallery") + && let Some(browser) = ui_nav.drive_galleries.borrow().upgrade() + { + browser.close(); + } match st.visible_child_name().as_deref() { Some("browser") => reload_browser_view(&ui_nav), // The Albums and Places listings are re-read in place. Loading the @@ -802,7 +813,7 @@ fn build_window(app: &adw::Application) { // sight (see `follow_changes`) or nothing is loaded yet. Some("gallery") if !ui_nav.gallery.in_collection() => { match ui_nav.gallery.view_switch.active() { - VIEW_ALBUMS => load_albums(&ui_nav), + VIEW_ALBUMS => show_albums(&ui_nav), VIEW_PLACES => load_places(&ui_nav), _ if ui_nav.gallery.timeline_stale.replace(false) || ui_nav.gallery.model.n_items() == 0 => @@ -839,6 +850,14 @@ fn build_window(app: &adw::Application) { .height_request(WindowState::MIN_HEIGHT) .content(&toasts) .build(); + pages::drive_galleries::wire( + &ui, + &window, + &gallery_widgets.drive_galleries, + &gallery_widgets.drive_status, + &gallery_widgets.add_gallery, + &gallery_widgets.hidden_albums, + ); remember_window_state(&ui, app, &window); // A wide window docks the details pane beside the files instead of laying it // over them. @@ -1679,7 +1698,9 @@ fn install_shortcuts(ui: &Rc, window: &adw::ApplicationWindow) { let on_trash = page.as_deref() == Some("trash"); let on_gallery = page.as_deref() == Some("gallery"); // Pages with a level to go back to, besides My files' own history. - let in_collection = on_gallery && ui.gallery.in_collection(); + let in_collection = on_gallery + && (ui.gallery.in_collection() + || ui.gallery.content.visible_child_name().as_deref() == Some("drive-galleries")); let in_shared_folder = page.as_deref() == Some("shared") && !ui.shared.nav.borrow().is_empty(); let in_device_folder = diff --git a/crates/pdfs-gui/src/app/pages/albums.rs b/crates/pdfs-gui/src/app/pages/albums.rs index ce9ca1b..29cf9e0 100644 --- a/crates/pdfs-gui/src/app/pages/albums.rs +++ b/crates/pdfs-gui/src/app/pages/albums.rs @@ -18,6 +18,9 @@ const COVER_EDGE: i32 = 200; pub(crate) fn show_albums(ui: &Rc) { show_album_grid(ui); load_albums(ui); + if let Some(browser) = ui.drive_galleries.borrow().upgrade() { + browser.load_root(); + } } /// Switch to the album grid as it was last filled, keeping its scroll @@ -102,7 +105,7 @@ fn fill_albums(ui: &Rc, albums: &[AlbumInfo]) { ui.gallery.albums.remove(&child); } *ui.gallery.album_list.borrow_mut() = albums.to_vec(); - if ui.gallery.album.borrow().is_none() { + if ui.gallery.content.visible_child_name().as_deref() == Some("albums") { ui.gallery.title.set_subtitle(&ngettext_f( "{n} album", "{n} albums", @@ -125,7 +128,12 @@ fn fill_albums(ui: &Rc, albums: &[AlbumInfo]) { /// One album as a clickable card: its cover, its name, and how many photos it /// holds. An album shared with us says so — it lives on someone else's volume, /// and that is worth knowing before opening it. -fn album_card(ui: &Rc, album: &AlbumInfo) -> gtk4::Button { +pub(crate) fn collection_card( + title: &str, + subtitle: &str, + icon: &str, + (width, height): (i32, i32), +) -> (gtk4::Button, gtk4::Picture) { let picture = gtk4::Picture::builder() // Fills and crops the cover square, like a timeline tile. .content_fit(gtk4::ContentFit::Cover) @@ -136,7 +144,7 @@ fn album_card(ui: &Rc, album: &AlbumInfo) -> gtk4::Button { picture.add_css_class("photo-thumb"); let placeholder = gtk4::Image::builder() - .icon_name("pdfs-album-symbolic") + .icon_name(icon) .pixel_size(32) .halign(gtk4::Align::Center) .valign(gtk4::Align::Center) @@ -146,12 +154,12 @@ fn album_card(ui: &Rc, album: &AlbumInfo) -> gtk4::Button { let cover = gtk4::Overlay::new(); cover.set_child(Some(&placeholder)); cover.add_overlay(&picture); - cover.set_size_request(COVER_EDGE, COVER_EDGE); + cover.set_size_request(width, height); cover.set_overflow(gtk4::Overflow::Hidden); cover.add_css_class("album-cover"); let name = gtk4::Label::builder() - .label(&album.name) + .label(title) .halign(gtk4::Align::Start) .xalign(0.0) .ellipsize(gtk4::pango::EllipsizeMode::End) @@ -159,7 +167,7 @@ fn album_card(ui: &Rc, album: &AlbumInfo) -> gtk4::Button { name.add_css_class("heading"); let count = gtk4::Label::builder() - .label(album_subtitle(album)) + .label(subtitle) .halign(gtk4::Align::Start) .xalign(0.0) .ellipsize(gtk4::pango::EllipsizeMode::End) @@ -175,7 +183,17 @@ fn album_card(ui: &Rc, album: &AlbumInfo) -> gtk4::Button { let button = gtk4::Button::builder().child(&card).build(); button.add_css_class("flat"); button.add_css_class("album-card"); - button.set_tooltip_text(Some(&album.name)); + button.set_tooltip_text(Some(title)); + (button, picture) +} + +fn album_card(ui: &Rc, album: &AlbumInfo) -> gtk4::Button { + let (button, picture) = collection_card( + &album.name, + &album_subtitle(album), + "pdfs-album-symbolic", + (COVER_EDGE, COVER_EDGE), + ); if let Some(uid) = album.cover_uid.clone() { want_cover(ui, uid, &picture); @@ -693,6 +711,12 @@ pub(crate) fn wire_albums(ui: &Rc) { // where it was, instead of reloading it. let ui_back = ui.clone(); ui.gallery.back.clone().connect_clicked(move |_| { + if ui_back.gallery.content.visible_child_name().as_deref() == Some("drive-galleries") { + if let Some(browser) = ui_back.drive_galleries.borrow().upgrade() { + browser.back(); + } + return; + } if ui_back.gallery.place.borrow().is_some() { show_place_grid(&ui_back); return; diff --git a/crates/pdfs-gui/src/app/pages/drive_galleries.rs b/crates/pdfs-gui/src/app/pages/drive_galleries.rs index 00fa925..97a20a6 100644 --- a/crates/pdfs-gui/src/app/pages/drive_galleries.rs +++ b/crates/pdfs-gui/src/app/pages/drive_galleries.rs @@ -1,8 +1,12 @@ use crate::*; use base64::{Engine, engine::general_purpose::STANDARD}; use pdfs_core::control::{GalleryAction, GalleryAlbum, GalleryFolder, GalleryPlace}; +use std::collections::VecDeque; const PAGE: usize = 150; +const THUMB_CACHE: usize = 256; +type ThumbnailKey = (u64, bool, String); +type ThumbnailTarget = (glib::WeakRef, glib::WeakRef); #[derive(Clone)] enum Row { @@ -19,14 +23,23 @@ struct Place { pub(crate) struct Browser { ui: Rc, - window: glib::WeakRef, + root: gtk4::FlowBox, + root_status: gtk4::Label, + root_loading: Cell, + root_loaded: Cell, + root_generation: Cell, + root_reload: Cell, + preview: glib::WeakRef, + unlock_pending: Cell, rows: gio::ListStore, scroll: gtk4::ScrolledWindow, title: adw::WindowTitle, status: gtk4::Label, choose: gtk4::Button, + unlock: gtk4::Button, + more: gtk4::Button, trail: RefCell>, - chooser: RefCell>>, + chooser: RefCell>>, cover: RefCell>, albums: RefCell>, items: RefCell>, @@ -36,21 +49,174 @@ pub(crate) struct Browser { loading: Cell, unlocked: Cell, thumbnail_slots: tokio::sync::Semaphore, + thumbnails: RefCell>, + thumb_pending: RefCell>>, } impl Browser { + pub(crate) fn reset(&self) { + self.close(); + self.root_generation + .set(self.root_generation.get().wrapping_add(1)); + self.root_loading.set(false); + self.root_loaded.set(false); + self.root_reload.set(false); + self.root.remove_all(); + self.root_status.set_label(""); + self.next_request(); + self.thumbnails.borrow_mut().clear(); + self.thumb_pending.borrow_mut().clear(); + } + pub(crate) fn close(&self) { - if let Some(window) = self.window.upgrade() { - window.close(); + if !self.active() { + return; } + self.next_request(); + self.loading.set(false); + self.total.set(0); + if self.unlocked.replace(false) || self.unlock_pending.get() { + self.lock(); + } + if let Some(preview) = self.preview.upgrade() { + preview.force_close(); + } + self.thumbnails + .borrow_mut() + .retain(|(private, _, _)| !private); + self.thumb_pending.borrow_mut().clear(); + self.trail.borrow_mut().clear(); + self.chooser.borrow_mut().take(); + self.cover.borrow_mut().take(); + self.albums.borrow_mut().clear(); + self.items.borrow_mut().clear(); + self.rows.remove_all(); + self.ui.gallery.title.set_subtitle(""); + self.ui + .gallery + .content + .set_visible_child_full("albums", gtk4::StackTransitionType::None); + sync_header(&self.ui); + } + + fn active(&self) -> bool { + self.ui.gallery.content.visible_child_name().as_deref() == Some("drive-galleries") + } + + fn enter(&self) { + self.title.set_subtitle(""); + self.ui.gallery.filters.set_visible(false); + self.ui + .gallery + .content + .set_visible_child_full("drive-galleries", gtk4::StackTransitionType::None); + sync_header(&self.ui); } pub(crate) fn refresh_visibility(self: &Rc) { - if self.chooser.borrow().is_none() { - self.trail.borrow_mut().clear(); - self.cover.borrow_mut().take(); - self.load(0, 0.0); + self.thumbnails.borrow_mut().clear(); + self.root.remove_all(); + self.load_root(); + if !self.active() || self.chooser.borrow().is_some() || self.unlock_pending.get() { + return; } + if let Some(preview) = self.preview.upgrade() { + preview.force_close(); + } + if self.unlocked.get() { + self.close(); + } else { + self.load(0, self.scroll.vadjustment().value()); + } + } + + pub(crate) fn load_root(self: &Rc) { + if self.root_loading.replace(true) { + self.root_reload.set(true); + return; + } + let generation = self.root_generation.get(); + if !self.root_loaded.get() { + self.root_status.set_label(&gettext("Loading galleries…")); + } + let rx = spawn_request( + self.ui.dirs.control_socket(), + Request::DriveGallery { + action: GalleryAction::List { + album: None, + offset: 0, + limit: PAGE, + }, + }, + ); + let browser = self.clone(); + glib::spawn_future_local(async move { + let response = rx.recv().await; + if generation != browser.root_generation.get() { + return; + } + browser.root_loading.set(false); + if browser.root_reload.replace(false) { + browser.load_root(); + } + let Ok(Ok(Response::GalleryPage { albums, .. })) = response else { + browser.root_status.set_label(&match response { + Ok(Ok(Response::Error { message, .. })) => message, + _ => gettext("Couldn’t load Drive galleries."), + }); + return; + }; + browser.root_loaded.set(true); + browser.root_status.set_label(&if albums.is_empty() { + gettext("No Drive galleries yet.") + } else { + String::new() + }); + browser.root.remove_all(); + for album in albums { + let card = browser.album_tile(&album, 185, false); + let weak = Rc::downgrade(&browser); + card.connect_clicked(move |_| { + if let Some(browser) = weak.upgrade() { + browser.enter(); + browser.trail.borrow_mut().push(Place { + album: album.clone(), + parent_offset: 0.0, + }); + browser.load(0, 0.0); + } + }); + browser.root.append(&card); + } + }); + } + + fn album_tile( + self: &Rc, + album: &GalleryAlbum, + width: i32, + private: bool, + ) -> gtk4::Button { + let items = ngettext_f("{n} item", "{n} items", album.items, &[]); + let count = if album.folders > 0 { + let folders = ngettext_f("{n} folder", "{n} folders", album.folders, &[]); + format!("{items} · {folders}") + } else { + items + }; + let (button, picture) = super::albums::collection_card( + &album.folder.name, + &count, + if album.proton { + "pdfs-album-symbolic" + } else { + "folder-symbolic" + }, + (width, width.min(200)), + ); + button.set_halign(gtk4::Align::Start); + wire_thumbnail(self, &picture, album.cover.as_deref(), private, None); + button } fn current(&self) -> Option { @@ -64,34 +230,57 @@ impl Browser { } fn load(self: &Rc, offset: usize, restore: f64) { + self.load_page(offset, restore, false); + } + + fn load_page(self: &Rc, offset: usize, restore: f64, keep: bool) { self.choose.set_visible(false); + self.unlock.set_visible(false); + self.more.set_visible(true); self.loading.set(true); let generation = if offset == 0 { - self.total.set(0); - self.albums.borrow_mut().clear(); - self.items.borrow_mut().clear(); - self.rows.remove_all(); + if !keep { + self.total.set(0); + self.albums.borrow_mut().clear(); + self.items.borrow_mut().clear(); + self.rows.remove_all(); + } self.next_request() } else { self.generation.get() }; let album = self.current(); - self.title.set_title( - album - .as_ref() - .map_or_else(|| gettext("Drive Galleries"), |a| a.folder.name.clone()) - .as_str(), - ); + let private = self.unlocked.get(); + self.title.set_title(&album.as_ref().map_or_else( + || { + if private { + gettext("Hidden albums") + } else { + gettext("Drive galleries") + } + }, + |a| a.folder.name.clone(), + )); self.status.set_label(&gettext("Loading…")); + let proton = album.as_ref().is_some_and(|a| a.proton); + let place = album.map(|a| a.place); + let action = if private { + GalleryAction::PrivateList { + album: place, + proton, + offset, + limit: PAGE, + } + } else { + GalleryAction::List { + album: place, + offset, + limit: PAGE, + } + }; let rx = spawn_request( self.ui.dirs.control_socket(), - Request::DriveGallery { - action: GalleryAction::List { - album: album.map(|a| a.place), - offset, - limit: PAGE, - }, - }, + Request::DriveGallery { action }, ); let browser = self.clone(); glib::spawn_future_local(async move { @@ -108,6 +297,7 @@ impl Browser { })) => { if offset == 0 { *browser.albums.borrow_mut() = albums; + browser.items.borrow_mut().clear(); } browser.items.borrow_mut().extend(items); browser.total.set(total); @@ -115,16 +305,17 @@ impl Browser { let message = if browser.cover.borrow().is_some() { gettext("Choose a photo or video as the album cover.") } else if empty { - gettext("This gallery is empty.") + if private && browser.current().is_none() { + gettext("No hidden albums.") + } else { + gettext("This gallery is empty.") + } } else { String::new() }; browser.status.set_label(&message); browser.rebuild(); - if restore > 0.0 { - let scroll = browser.scroll.clone(); - glib::idle_add_local_once(move || scroll.vadjustment().set_value(restore)); - } + browser.restore_offset(generation, restore); } Ok(Ok(Response::Error { message, .. })) => browser.status.set_label(&message), _ => browser @@ -134,14 +325,20 @@ impl Browser { }); } - fn browse_folders(self: &Rc) { + fn browse_folders(self: &Rc, restore: f64) { let Some(trail) = self.chooser.borrow().clone() else { return; }; let generation = self.next_request(); - let parent = trail.last().map(|folder| folder.uid.clone()); + let parent = trail.last().map(|(folder, _)| folder.uid.clone()); + self.more.set_visible(false); + self.unlock.set_visible(false); self.choose.set_visible(parent.is_some()); - self.title.set_title(&gettext("Choose a Drive Folder")); + self.title.set_title(&trail.last().map_or_else( + || gettext("Choose a Drive folder"), + |(folder, _)| folder.name.clone(), + )); + self.status.set_label(&gettext("Loading folders…")); self.rows.remove_all(); let rx = spawn_request( self.ui.dirs.control_socket(), @@ -160,11 +357,12 @@ impl Browser { browser .status .set_label(&gettext("Open a folder, then choose Add This Folder.")); - for folder in folders { - browser - .rows - .append(&BoxedAnyObject::new(Row::Folder(folder))); - } + let rows: Vec<_> = folders + .into_iter() + .map(|folder| BoxedAnyObject::new(Row::Folder(folder))) + .collect(); + browser.rows.splice(0, browser.rows.n_items(), &rows); + browser.restore_offset(generation, restore); } Ok(Ok(Response::Error { message, .. })) => browser.status.set_label(&message), _ => browser @@ -174,15 +372,30 @@ impl Browser { }); } + fn restore_offset(self: &Rc, generation: u64, restore: f64) { + let browser = Rc::downgrade(self); + glib::idle_add_local_once(move || { + if let Some(browser) = browser.upgrade() + && generation == browser.generation.get() + { + browser.scroll.vadjustment().set_value(restore); + } + }); + } + fn change(self: &Rc, action: GalleryAction) { let unlock = matches!(action, GalleryAction::Unlock { .. }); - let lock = matches!(action, GalleryAction::Lock); - if lock { - self.trail.borrow_mut().clear(); - self.cover.borrow_mut().take(); - self.items.borrow_mut().clear(); - self.rows.remove_all(); + let update_root = matches!( + action, + GalleryAction::Add { .. } + | GalleryAction::Remove { .. } + | GalleryAction::Refresh + | GalleryAction::Cover { .. } + ); + if unlock && self.unlock_pending.replace(true) { + return; } + self.unlock.set_visible(false); let generation = self.next_request(); self.status.set_label(&gettext("Updating gallery…")); let rx = spawn_request( @@ -192,6 +405,14 @@ impl Browser { let browser = self.clone(); glib::spawn_future_local(async move { let result = rx.recv().await; + if unlock { + browser.unlock_pending.set(false); + browser.unlock.set_visible( + browser.active() + && browser.generation.get() == generation + && !matches!(result, Ok(Ok(Response::Ok { .. }))), + ); + } if browser.generation.get() != generation { if unlock && matches!(result, Ok(Ok(Response::Ok { .. }))) { browser.lock(); @@ -200,11 +421,24 @@ impl Browser { } match result { Ok(Ok(Response::Ok { .. })) => { - if unlock || lock { - browser.unlocked.set(unlock); + if unlock { + browser.unlocked.set(true); + } + let added = browser.chooser.borrow().is_some(); + if update_root { + browser.load_root(); + } + if added || (!browser.unlocked.get() && browser.current().is_none()) { + browser.close(); + return; } browser.chooser.borrow_mut().take(); - browser.load(0, 0.0); + let restore = if update_root { + browser.scroll.vadjustment().value() + } else { + 0.0 + }; + browser.load_page(0, restore, update_root); } Ok(Ok(Response::Error { message, .. })) => browser.status.set_label(&message), _ => browser @@ -224,7 +458,10 @@ impl Browser { } fn prompt_unlock(self: &Rc) { - let Some(parent) = self.window.upgrade() else { + if self.unlock_pending.get() { + return; + } + let Some(parent) = ui_window(&self.ui) else { return; }; let dialog = adw::AlertDialog::builder() @@ -244,26 +481,24 @@ impl Browser { if response == "unlock" && let Some(browser) = browser.upgrade() { + browser.enter(); + browser.more.set_visible(false); + browser.title.set_title(&gettext("Hidden albums")); browser.change(GalleryAction::Unlock { passphrase }); } }); dialog.present(Some(&parent)); } - fn back(self: &Rc) { + pub(crate) fn back(self: &Rc) { let choosing = self.chooser.borrow().is_some(); if choosing { - let went_up = self - .chooser - .borrow_mut() - .as_mut() - .and_then(Vec::pop) - .is_some(); - if went_up { - self.browse_folders(); + let previous = self.chooser.borrow_mut().as_mut().and_then(Vec::pop); + if let Some((_, offset)) = previous { + self.browse_folders(offset); } else { self.chooser.borrow_mut().take(); - self.load(0, 0.0); + self.close(); } return; } @@ -279,10 +514,12 @@ impl Browser { return; } let previous = self.trail.borrow_mut().pop(); - if let Some(previous) = previous { + if let Some(previous) = previous + && (self.unlocked.get() || self.current().is_some()) + { self.load(0, previous.parent_offset); - } else if let Some(window) = self.window.upgrade() { - window.close(); + } else { + self.close(); } } @@ -323,10 +560,17 @@ impl Browser { fn preview(self: &Rc, item: PhotoItem) { let video = item.kind == PhotoKind::Video; + let private = self.unlocked.get(); let request = if video { - Request::OpenGalleryVideo { uid: item.uid } + Request::OpenGalleryVideo { + uid: item.uid, + private, + } } else { - Request::OpenGalleryImage { uid: item.uid } + Request::OpenGalleryImage { + uid: item.uid, + private, + } }; let reply = spawn_request(self.ui.dirs.control_socket(), request); let browser = self.clone(); @@ -339,31 +583,30 @@ impl Browser { Request::CloseGalleryVideo { token }, ); }; - let parent = browser - .window - .upgrade() - .filter(|_| generation == browser.generation.get()); + let parent = ui_window(&browser.ui) + .filter(|_| browser.active() && generation == browser.generation.get()); let Some(parent) = parent else { if let Ok(Ok(Response::GalleryVideo { token, .. })) = result { close(token); } return; }; - let preview = gtk4::Window::builder() - .transient_for(&parent) - .destroy_with_parent(true) + let preview = adw::Dialog::builder() .title(item.name.unwrap_or_else(|| gettext("Preview"))) - .default_width(850) - .default_height(600) + .content_width(850) + .content_height(600) .build(); - preview.add_css_class("photo-viewer-window"); + let content = gtk4::Box::new(gtk4::Orientation::Vertical, 0); + content.append(&adw::HeaderBar::new()); + preview.set_child(Some(&content)); match result { Ok(Ok(Response::GalleryVideo { url, token, .. })) => { let player = gtk4::Video::builder().autoplay(true).build(); player.set_file(Some(&gio::File::for_uri(&url))); - preview.set_child(Some(&player)); + player.set_vexpand(true); + content.append(&player); let socket = browser.ui.dirs.control_socket(); - preview.connect_close_request(move |_| { + preview.connect_closed(move |_| { player.set_media_stream(gtk4::MediaStream::NONE); let _ = spawn_request( socket.clone(), @@ -371,12 +614,23 @@ impl Browser { token: token.clone(), }, ); - glib::Propagation::Proceed }); } Ok(Ok(Response::FilePath { path })) => { let picture = gtk4::Picture::for_filename(path); - preview.set_child(Some(&picture)); + picture.set_vexpand(true); + content.append(&picture); + } + Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) if private => { + let Some(texture) = decode_thumbnail(&data) else { + browser + .status + .set_label(&gettext("Couldn't open the photo.")); + return; + }; + let picture = gtk4::Picture::for_paintable(&texture); + picture.set_vexpand(true); + content.append(&picture); } Ok(Ok(Response::Error { message, .. })) => { browser.status.set_label(&message); @@ -389,37 +643,32 @@ impl Browser { return; } } - preview.present(); + browser.preview.set(Some(&preview)); + preview.present(Some(&parent)); }); } } -pub(crate) fn open(ui: &Rc) { - if let Some(browser) = ui.drive_galleries.borrow().upgrade() - && let Some(window) = browser.window.upgrade() - { - window.present(); - return; - } - let Some(parent) = ui_window(ui) else { return }; - let window = gtk4::Window::builder() - .transient_for(&parent) - .default_width(1020) - .default_height(760) - .build(); - let title = adw::WindowTitle::new(&gettext("Drive Galleries"), ""); - let header = adw::HeaderBar::builder().title_widget(&title).build(); - let back = gtk4::Button::from_icon_name("go-previous-symbolic"); - back.set_tooltip_text(Some(&gettext("Back"))); - header.pack_start(&back); - let add = gtk4::Button::with_label(&gettext("Add Gallery")); +pub(crate) fn wire( + ui: &Rc, + window: &adw::ApplicationWindow, + root: >k4::FlowBox, + root_status: >k4::Label, + add: >k4::Button, + hidden: >k4::Button, +) { + let title = ui.gallery.title.clone(); + let header = gtk4::Box::new(gtk4::Orientation::Horizontal, 8); + header.set_halign(gtk4::Align::End); let choose = gtk4::Button::with_label(&gettext("Add This Folder")); choose.set_visible(false); - header.pack_end(&add); - header.pack_end(&choose); + header.append(&choose); let more = gtk4::Button::from_icon_name("view-more-symbolic"); more.set_tooltip_text(Some(&gettext("Gallery Options"))); - header.pack_end(&more); + let unlock = gtk4::Button::with_label(&gettext("Unlock")); + unlock.set_visible(false); + header.append(&unlock); + header.append(&more); let rows = gio::ListStore::new::(); let factory = gtk4::SignalListItemFactory::new(); let list = gtk4::ListView::builder() @@ -438,15 +687,30 @@ pub(crate) fn open(ui: &Rc) { content.append(&header); content.append(&status); content.append(&scroll); - window.set_child(Some(&content)); + ui.gallery + .content + .add_named(&content, Some("drive-galleries")); + for label in [&status, root_status] { + label.set_visible(false); + label.connect_label_notify(|label| label.set_visible(!label.label().is_empty())); + } let browser = Rc::new(Browser { ui: ui.clone(), - window: window.downgrade(), + root: root.clone(), + root_status: root_status.clone(), + root_loaded: Cell::new(false), + root_generation: Cell::new(0), + root_reload: Cell::new(false), + root_loading: Cell::new(false), + preview: glib::WeakRef::new(), + unlock_pending: Cell::new(false), rows, scroll: scroll.clone(), title, status, choose: choose.clone(), + unlock: unlock.clone(), + more: more.clone(), trail: RefCell::new(Vec::new()), chooser: RefCell::new(None), cover: RefCell::new(None), @@ -458,20 +722,39 @@ pub(crate) fn open(ui: &Rc) { loading: Cell::new(false), unlocked: Cell::new(false), thumbnail_slots: tokio::sync::Semaphore::new(8), + thumbnails: RefCell::default(), + thumb_pending: RefCell::default(), }); *ui.drive_galleries.borrow_mut() = Rc::downgrade(&browser); - window.connect_close_request({ - let browser = browser.clone(); - move |_| { - *browser.ui.drive_galleries.borrow_mut() = std::rc::Weak::new(); - browser.next_request(); - if browser.unlocked.get() { - browser.lock(); - } - glib::Propagation::Proceed + let weak = Rc::downgrade(&browser); + window.connect_is_active_notify(move |window| { + if !window.is_active() + && let Some(browser) = weak.upgrade() + && (browser.unlocked.get() || browser.unlock_pending.get()) + { + browser.close(); } }); let weak = Rc::downgrade(&browser); + window.connect_close_request(move |_| { + if let Some(browser) = weak.upgrade() { + browser.close(); + } + glib::Propagation::Proceed + }); + unlock.connect_clicked({ + let weak = Rc::downgrade(&browser); + move |_| { + if let Some(browser) = weak.upgrade() { + browser.prompt_unlock(); + } + } + }); + hidden.connect_clicked({ + let browser = browser.clone(); + move |_| browser.prompt_unlock() + }); + let weak = Rc::downgrade(&browser); factory.connect_bind(move |_, item| { let Some(browser) = weak.upgrade() else { return; @@ -502,9 +785,9 @@ pub(crate) fn open(ui: &Rc) { move |_| { if let Some(browser) = weak.upgrade() { if let Some(trail) = browser.chooser.borrow_mut().as_mut() { - trail.push(folder.clone()); + trail.push((folder.clone(), browser.scroll.vadjustment().value())); } - browser.browse_folders(); + browser.browse_folders(0.0); } } }); @@ -512,25 +795,7 @@ pub(crate) fn open(ui: &Rc) { } Row::Albums(albums, width) => { for album in albums { - let items = ngettext_f("{n} item", "{n} items", album.items, &[]); - let mut detail = if album.folders > 0 { - let folders = ngettext_f("{n} folder", "{n} folders", album.folders, &[]); - format!("{items} · {folders}") - } else { - items - }; - if album.hidden { - detail = format!("{detail} · {}", gettext("Hidden")); - } - let button = tile( - &browser, - &album.folder.name, - album.cover.as_deref(), - *width, - 130, - Some(&detail), - false, - ); + let button = browser.album_tile(album, *width, browser.unlocked.get()); button.connect_clicked({ let weak = Rc::downgrade(&browser); let album = album.clone(); @@ -554,10 +819,9 @@ pub(crate) fn open(ui: &Rc) { &browser, item.name.as_deref().unwrap_or(""), Some(&item.uid), - *width, - *height, - None, + (*width, *height), item.kind == PhotoKind::Video, + browser.unlocked.get(), ); button.connect_clicked({ let weak = Rc::downgrade(&browser); @@ -587,23 +851,12 @@ pub(crate) fn open(ui: &Rc) { item.set_child(gtk4::Widget::NONE); } }); - back.connect_clicked({ - let weak = Rc::downgrade(&browser); - move |_| { - if let Some(browser) = weak.upgrade() { - browser.back(); - } - } - }); add.connect_clicked({ - let weak = Rc::downgrade(&browser); - let choose = choose.clone(); + let browser = browser.clone(); move |_| { - if let Some(browser) = weak.upgrade() { - choose.set_visible(true); - *browser.chooser.borrow_mut() = Some(Vec::new()); - browser.browse_folders(); - } + browser.enter(); + *browser.chooser.borrow_mut() = Some(Vec::new()); + browser.browse_folders(0.0); } }); choose.connect_clicked({ @@ -615,7 +868,7 @@ pub(crate) fn open(ui: &Rc) { .borrow() .as_ref() .and_then(|trail| trail.last()) - .map(|f| f.uid.clone()); + .map(|(folder, _)| folder.uid.clone()); if let Some(uid) = uid { button.set_visible(false); browser.change(GalleryAction::Add { uid }); @@ -635,15 +888,15 @@ pub(crate) fn open(ui: &Rc) { if browser.unlocked.get() { menu.item(&gettext("Lock Hidden Albums"), { let browser = browser.clone(); - move || browser.change(GalleryAction::Lock) + move || browser.close() }); } else { - menu.item(&gettext("Unlock Hidden Albums"), { + menu.item(&gettext("Refresh galleries"), { let browser = browser.clone(); - move || browser.prompt_unlock() + move || browser.change(GalleryAction::Refresh) }); } - if let Some(album) = browser.current() { + if let Some(album) = browser.current().filter(|album| !album.proton) { menu.item(&gettext("Choose Cover"), { let browser = browser.clone(); let place = album.place.clone(); @@ -654,33 +907,40 @@ pub(crate) fn open(ui: &Rc) { )); } }); - menu.item(&gettext("Public Link"), { - let browser = browser.clone(); - let folder = album.folder.clone(); - move || { - open_share_dialog_over( - &browser.ui, - &DirEntry { - uid: folder.uid.clone(), - name: folder.name.clone(), - is_dir: true, - ..DirEntry::default() - }, - browser.window.upgrade(), - ) - } - }); - if browser.trail.borrow().len() == 1 { - menu.item(&gettext("Remove Gallery"), { + if !browser.unlocked.get() { + menu.item(&gettext("Public Link"), { let browser = browser.clone(); + let folder = album.folder.clone(); move || { - browser.trail.borrow_mut().clear(); - browser.change(GalleryAction::Remove { - gallery: album.place.gallery.clone(), - }); + open_share_dialog_over( + &browser.ui, + &DirEntry { + uid: folder.uid.clone(), + name: folder.name.clone(), + is_dir: true, + ..DirEntry::default() + }, + ui_window(&browser.ui), + ) } }); + if album.place.gallery == album.place.album { + menu.item(&gettext("Remove Gallery"), { + let browser = browser.clone(); + move || { + browser.trail.borrow_mut().clear(); + browser.change(GalleryAction::Remove { + gallery: album.place.gallery.clone(), + }); + } + }); + } } + } else if !browser.unlocked.get() && browser.chooser.borrow().is_none() { + menu.item(&gettext("Unlock Hidden Albums"), { + let browser = browser.clone(); + move || browser.prompt_unlock() + }); } menu.popup_at( button, @@ -718,105 +978,177 @@ pub(crate) fn open(ui: &Rc) { glib::ControlFlow::Continue } }); - window.present(); - browser.load(0, 0.0); } fn tile( browser: &Rc, title: &str, uid: Option<&str>, - width: i32, - height: i32, - detail: Option<&str>, + (width, height): (i32, i32), video: bool, + private: bool, ) -> gtk4::Button { let picture = gtk4::Picture::builder() .content_fit(gtk4::ContentFit::Cover) .can_shrink(true) - .width_request(if detail.is_some() { - (width - 24).max(1) - } else { - width - }) - .height_request(height) .build(); let label = gtk4::Label::new(Some(title)); label.set_ellipsize(gtk4::pango::EllipsizeMode::End); label.set_max_width_chars((width / 9).max(1)); - let box_ = gtk4::Box::new(gtk4::Orientation::Vertical, 4); - let cover = gtk4::Overlay::new(); - cover.set_child(Some(&picture)); - let icon = gtk4::Image::from_icon_name(if detail.is_some() { - "folder-symbolic" - } else { - "image-x-generic-symbolic" - }); - icon.set_halign(gtk4::Align::Center); - icon.set_valign(gtk4::Align::Center); - icon.set_pixel_size(32); + label.add_css_class("photo-caption"); + label.set_valign(gtk4::Align::End); + let icon = gtk4::Image::builder() + .icon_name(if video { + "video-x-generic-symbolic" + } else { + "image-x-generic-symbolic" + }) + .halign(gtk4::Align::Center) + .valign(gtk4::Align::Center) + .pixel_size(32) + .build(); icon.add_css_class("dim-label"); - cover.add_overlay(&icon); + let cover = gtk4::Overlay::new(); + cover.set_child(Some(&icon)); + cover.set_size_request(width, height); + cover.add_overlay(&picture); + cover.add_overlay(&label); + cover.add_css_class("photo-placeholder"); cover.set_overflow(gtk4::Overflow::Hidden); - let button = gtk4::Button::builder().tooltip_text(title).build(); - if let Some(detail) = detail { - box_.append(&cover); - box_.append(&label); - let caption = gtk4::Label::new(Some(detail)); - caption.add_css_class("dim-label"); - caption.add_css_class("caption"); - caption.set_ellipsize(gtk4::pango::EllipsizeMode::End); - box_.append(&caption); - button.set_width_request(width); - button.set_child(Some(&box_)); - } else { - button.add_css_class("photo-tile"); - cover.add_css_class("photo-placeholder"); - label.add_css_class("photo-caption"); - label.set_valign(gtk4::Align::End); - cover.add_overlay(&label); - if video { - let play = gtk4::Image::from_icon_name("media-playback-start-symbolic"); - play.add_css_class("photo-video-badge"); - play.add_css_class("photo-video-badge-small"); - play.set_halign(gtk4::Align::End); - play.set_valign(gtk4::Align::Start); - play.set_margin_end(8); - play.set_margin_top(8); - cover.add_overlay(&play); - } - button.set_child(Some(&cover)); + if video { + let play = gtk4::Image::from_icon_name("media-playback-start-symbolic"); + play.add_css_class("photo-video-badge"); + play.add_css_class("photo-video-badge-small"); + play.set_halign(gtk4::Align::End); + play.set_valign(gtk4::Align::Start); + play.set_margin_end(8); + play.set_margin_top(8); + cover.add_overlay(&play); } - if let Some(uid) = uid { - let browser = browser.clone(); - let generation = browser.generation.get(); - let uid = uid.to_owned(); - let picture = picture.downgrade(); - let icon = icon.downgrade(); + let button = gtk4::Button::builder() + .tooltip_text(title) + .child(&cover) + .build(); + button.add_css_class("photo-tile"); + wire_thumbnail(browser, &picture, uid, private, Some(&icon)); + button +} + +fn wire_thumbnail( + browser: &Rc, + picture: >k4::Picture, + uid: Option<&str>, + private: bool, + icon: Option<>k4::Image>, +) { + let Some(uid) = uid else { + return; + }; + let browser = Rc::downgrade(browser); + let uid = uid.to_owned(); + let icon = icon.map_or_else(glib::WeakRef::new, ObjectExt::downgrade); + picture.connect_map(move |picture| { + if picture.paintable().is_none() + && let Some(browser) = browser.upgrade() + { + browser.want_thumbnail(&uid, private, picture, &icon); + } + }); +} + +fn decode_thumbnail(data: &str) -> Option { + let bytes = STANDARD.decode(data).ok()?; + gtk4::gdk::Texture::from_bytes(&glib::Bytes::from_owned(bytes)).ok() +} + +impl Browser { + fn want_thumbnail( + self: &Rc, + uid: &str, + private: bool, + picture: >k4::Picture, + icon: &glib::WeakRef, + ) { + if private && !self.unlocked.get() { + return; + } + { + let mut cache = self.thumbnails.borrow_mut(); + if let Some(index) = cache + .iter() + .position(|(p, id, _)| *p == private && id == uid) + { + let cached = cache.remove(index).unwrap(); + picture.set_paintable(Some(&cached.2)); + if let Some(icon) = icon.upgrade() { + icon.set_visible(false); + } + cache.push_back(cached); + return; + } + } + let key = (self.generation.get(), private, uid.to_owned()); + { + let mut pending = self.thumb_pending.borrow_mut(); + let started = pending.contains_key(&key); + let targets = pending.entry(key.clone()).or_default(); + targets.retain(|(target, _)| target.upgrade().is_some_and(|seen| seen != *picture)); + targets.push((picture.downgrade(), icon.clone())); + if started { + return; + } + } + let browser = self.clone(); glib::spawn_future_local(async move { let Ok(_permit) = browser.thumbnail_slots.acquire().await else { return; }; - if picture.upgrade().is_none() || generation != browser.generation.get() { + let visible = browser + .thumb_pending + .borrow() + .get(&key) + .is_some_and(|targets| { + targets + .iter() + .any(|(picture, _)| picture.upgrade().is_some_and(|p| p.is_mapped())) + }); + if !visible || key.0 != browser.generation.get() { + browser.thumb_pending.borrow_mut().remove(&key); return; } let request = spawn_request( browser.ui.dirs.control_socket(), - Request::GalleryThumbnail { uid }, + Request::GalleryThumbnail { + uid: key.2.clone(), + private, + }, ); let response = request.recv().await; - if generation == browser.generation.get() - && let (Some(picture), Ok(Ok(Response::GalleryThumbnail { data: Some(data) }))) = - (picture.upgrade(), response) - && let Ok(bytes) = STANDARD.decode(data) - && let Ok(texture) = gtk4::gdk::Texture::from_bytes(&glib::Bytes::from_owned(bytes)) + let targets = browser + .thumb_pending + .borrow_mut() + .remove(&key) + .unwrap_or_default(); + if key.0 != browser.generation.get() || private && !browser.unlocked.get() { + return; + } + if let Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) = response + && let Some(texture) = decode_thumbnail(&data) { - picture.set_paintable(Some(&texture)); - if let Some(icon) = icon.upgrade() { - icon.set_visible(false); + for (picture, icon) in targets { + if let Some(picture) = picture.upgrade() { + picture.set_paintable(Some(&texture)); + } + if let Some(icon) = icon.upgrade() { + icon.set_visible(false); + } } + let mut cache = browser.thumbnails.borrow_mut(); + if cache.len() >= THUMB_CACHE { + cache.pop_front(); + } + cache.push_back((private, key.2, texture)); } }); } - button } diff --git a/crates/pdfs-gui/src/app/pages/login.rs b/crates/pdfs-gui/src/app/pages/login.rs index b8c4122..cc24e30 100644 --- a/crates/pdfs-gui/src/app/pages/login.rs +++ b/crates/pdfs-gui/src/app/pages/login.rs @@ -685,7 +685,7 @@ pub(crate) fn sign_out(ui: &Rc) { move || { let galleries = ui.drive_galleries.borrow().upgrade(); if let Some(galleries) = galleries { - galleries.close(); + galleries.reset(); } // systemctl and the keyring both block, so run them on a worker. let ui = ui.clone(); diff --git a/crates/pdfs-gui/src/app/pages/photo_viewer.rs b/crates/pdfs-gui/src/app/pages/photo_viewer.rs index c857bde..834788e 100644 --- a/crates/pdfs-gui/src/app/pages/photo_viewer.rs +++ b/crates/pdfs-gui/src/app/pages/photo_viewer.rs @@ -33,6 +33,9 @@ pub(crate) struct Viewer { pub(crate) video: gtk4::Video, video_token: RefCell>, load_generation: Cell, + presence_loading: Cell, + presence_pending: Cell, + album: Option, pub(crate) spinner: Spinner, pub(crate) status: gtk4::Label, pub(crate) title: gtk4::Label, @@ -307,7 +310,10 @@ pub(crate) fn load_photo(ui: &Rc, viewer: &Rc, uid: String) { } let request = if is_video { - Request::OpenGalleryVideo { uid: uid.clone() } + Request::OpenGalleryVideo { + uid: uid.clone(), + private: false, + } } else { Request::OpenPhoto { uid: uid.clone() } }; @@ -1237,6 +1243,43 @@ fn build_strip(ui: &Rc) -> (gtk4::ListView, gtk4::SingleSelection) { /// /// Returns the lightbox's window, for a caller that has to put the page /// behind it back once it closes. +pub(crate) fn check_photo_viewer(ui: &Rc) { + let Some(viewer) = ui.gallery.viewer.borrow().upgrade() else { + return; + }; + if !viewer.window.is_visible() { + return; + } + if viewer.presence_loading.replace(true) { + viewer.presence_pending.set(true); + return; + } + let uid = viewer.uid.borrow().clone(); + let rx = spawn_request( + ui.dirs.control_socket(), + Request::PhotoPresence { + uid: uid.clone(), + album: viewer.album.clone(), + }, + ); + let ui = ui.clone(); + let viewer = Rc::downgrade(&viewer); + glib::spawn_future_local(async move { + let result = rx.recv().await; + let Some(viewer) = viewer.upgrade() else { + return; + }; + viewer.presence_loading.set(false); + if *viewer.uid.borrow() == uid + && matches!(result, Ok(Ok(Response::PhotoPresence { present: false }))) + { + viewer.window.close(); + } else if viewer.presence_pending.replace(false) { + check_photo_viewer(&ui); + } + }); +} + pub(crate) fn open_photo_viewer(ui: &Rc, initial_uid: String) -> gtk4::Window { let parent = ui.stack.root().and_downcast::().unwrap(); @@ -1502,6 +1545,14 @@ pub(crate) fn open_photo_viewer(ui: &Rc, initial_uid: String) -> gtk4::Windo video, video_token: RefCell::new(None), load_generation: Cell::new(0), + presence_loading: Cell::new(false), + presence_pending: Cell::new(false), + album: ui + .gallery + .album + .borrow() + .as_ref() + .map(|album| album.uid.clone()), spinner, status: status_label, title: title_label, @@ -1544,6 +1595,7 @@ pub(crate) fn open_photo_viewer(ui: &Rc, initial_uid: String) -> gtk4::Windo toasts, }); + *ui.gallery.viewer.borrow_mut() = Rc::downgrade(&viewer); let initial_idx = find_photo_index(&ui.gallery.model, &initial_uid).unwrap_or(0); let capture_time = viewer_item(ui, &viewer, &initial_uid).map_or(0, |item| item.capture_time); show_photo_position(ui, &viewer, initial_idx, capture_time); diff --git a/crates/pdfs-gui/src/app/pages/photos.rs b/crates/pdfs-gui/src/app/pages/photos.rs index 3b39453..d6a534e 100644 --- a/crates/pdfs-gui/src/app/pages/photos.rs +++ b/crates/pdfs-gui/src/app/pages/photos.rs @@ -12,6 +12,10 @@ pub(crate) struct GalleryState { /// 1,600 photos (a Takeout import lands one) would otherwise be 1,600 /// widgets built in a single bind. pub(crate) groups: gio::ListStore, + pub(crate) row_by_photo: RefCell>, + pub(crate) rendered_layout: Cell>, + pub(crate) rendered_photos: Cell, + pub(crate) align_tick: RefCell>, /// Target row height in px, retuned by Ctrl+scroll / Ctrl+± (see /// [`zoom_gallery`]). Each row is filled with photos at their own aspect /// ratios and then scaled to the content width, so this is the height a row @@ -28,6 +32,10 @@ pub(crate) struct GalleryState { /// spans (newest first). pub(crate) scrubber: Scrubber, pub(crate) months: RefCell>, + pub(crate) months_loading: Cell, + pub(crate) months_pending: Cell, + pub(crate) changes_pending: Cell, + pub(crate) viewer: RefCell>, /// The pending jump the scrubber debounces to. pub(crate) scrub_source: RefCell>, /// A scrubber jump in progress: the end of the month it is headed for. @@ -175,7 +183,8 @@ pub(crate) struct GalleryState { pub(crate) scrolling_down: Cell, /// The scroll offset the direction was last decided at. pub(crate) scroll_offset: Cell, - pub(crate) thumb_inflight: Cell, + pub(crate) thumb_inflight: RefCell>, + pub(crate) thumb_generation: Cell, /// Thumbnails on disk waiting to be turned into textures, as `(uid, path)`. /// Decoding happens on the GTK thread (textures are not `Send`), so it is fed /// a few at a time from an idle callback rather than in one blocking burst @@ -193,7 +202,8 @@ pub(crate) struct GalleryState { /// model has to be rebuilt — this is what lets the rebuild put the user /// back where they were. The ListView realises rows beyond both edges of /// the viewport, so the widget is what tells which of them is on screen. - pub(crate) bound: RefCell, gtk4::Box)>>, + pub(crate) bound: RefCell>, + pub(crate) visible_tiles_pending: Cell, /// The tile widgets each row box has built, rebound to new photos as the /// ListView recycles the row rather than built afresh on every bind. pub(crate) tile_pools: RefCell>>, @@ -397,6 +407,12 @@ pub(crate) enum GalleryRow { }, } +pub(crate) struct BoundRow { + anchor: Option, + widget: gtk4::Box, + item: glib::WeakRef, +} + /// A section heading row. #[derive(Clone, PartialEq)] pub(crate) struct SectionHeading { @@ -452,6 +468,15 @@ impl GalleryRow { && a.len() == b.len() && a.iter().zip(b).all(|(x, y)| { x.photo.uid == y.photo.uid + && x.photo.capture_time == y.photo.capture_time + && x.photo.name == y.photo.name + && x.photo.thumb_path == y.photo.thumb_path + && x.photo.no_thumb == y.photo.no_thumb + && x.photo.kind == y.photo.kind + && x.photo.group_size == y.photo.group_size + && x.photo.has_raw == y.photo.has_raw + && x.photo.ratio == y.photo.ratio + && x.photo.place_id == y.photo.place_id && x.width == y.width && x.height == y.height && x.selecting == y.selecting @@ -467,7 +492,10 @@ impl GalleryRow { /// The widgets [`build_gallery_page`] hands back to [`build_window`]. pub(crate) struct GalleryWidgets { - pub(crate) drive_galleries: gtk4::Button, + pub(crate) drive_galleries: gtk4::FlowBox, + pub(crate) drive_status: gtk4::Label, + pub(crate) add_gallery: gtk4::Button, + pub(crate) hidden_albums: gtk4::Button, /// Flat, newest-first list of every loaded photo. Backs the lightbox's /// prev/next navigation; the visible sections are derived from it. pub(crate) model: gio::ListStore, @@ -738,8 +766,9 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) { let filters = gtk4::Box::new(gtk4::Orientation::Horizontal, 8); filters.set_hexpand(true); let tabs_scroll = scroll_sideways(&tabs.widget()); - tabs_scroll.set_hexpand(true); - tabs_scroll.set_propagate_natural_width(false); + filters.set_halign(gtk4::Align::Start); + tabs_scroll.set_propagate_natural_width(true); + tabs_scroll.set_max_content_width(520); filters.append(&tabs_scroll); filters.append(&filter_btn); @@ -816,11 +845,6 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) { .max_children_per_line(8) .valign(gtk4::Align::Start) .build(); - let albums_scroll = gtk4::ScrolledWindow::builder() - .vexpand(true) - .hscrollbar_policy(gtk4::PolicyType::Never) - .child(&albums) - .build(); let albums_status = adw::StatusPage::builder() .icon_name("pdfs-album-symbolic") .vexpand(true) @@ -828,7 +852,7 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) { albums_status.add_css_class("compact"); let albums_stack = gtk4::Stack::new(); albums_stack.set_vexpand(true); - albums_stack.add_named(&albums_scroll, Some("grid")); + albums_stack.add_named(&albums, Some("grid")); albums_stack.add_named(&albums_status, Some("status")); let new_album = gtk4::Button::builder() .child( @@ -841,9 +865,46 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) { .action_name("win.new-album") .build(); new_album.add_css_class("pill"); - let albums_page = gtk4::Box::new(gtk4::Orientation::Vertical, 12); - albums_page.append(&new_album); - albums_page.append(&albums_stack); + let drive_galleries = gtk4::FlowBox::builder() + .selection_mode(gtk4::SelectionMode::None) + .homogeneous(true) + .row_spacing(12) + .column_spacing(12) + .min_children_per_line(1) + .max_children_per_line(8) + .valign(gtk4::Align::Start) + .build(); + let drive_status = gtk4::Label::builder().xalign(0.0).wrap(true).build(); + drive_status.add_css_class("dim-label"); + let add_gallery = gtk4::Button::with_label(&gettext("Add gallery")); + add_gallery.add_css_class("pill"); + let hidden_albums = gtk4::Button::builder() + .child( + &adw::ButtonContent::builder() + .icon_name("changes-prevent-symbolic") + .label(gettext("Hidden albums")) + .build(), + ) + .halign(gtk4::Align::Start) + .build(); + hidden_albums.add_css_class("flat"); + let album_sections = gtk4::Box::new(gtk4::Orientation::Vertical, 16); + album_sections.append(&hidden_albums); + album_sections.append(&album_section_header(&gettext("Proton albums"), &new_album)); + album_sections.append(&albums_stack); + album_sections.append(>k4::Separator::new(gtk4::Orientation::Horizontal)); + album_sections.append(&album_section_header( + &gettext("Drive galleries"), + &add_gallery, + )); + album_sections.append(&drive_status); + album_sections.append(&drive_galleries); + albums_stack.set_vexpand(false); + let albums_page = gtk4::ScrolledWindow::builder() + .vexpand(true) + .hscrollbar_policy(gtk4::PolicyType::Never) + .child(&album_sections) + .build(); // The place grid: the same cards, one per town the photos were taken in. let places = gtk4::FlowBox::builder() @@ -941,13 +1002,14 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) { header.pack_end(&more); header.pack_end(&select_btn); header.pack_end(&selection.cancel); - let drive_galleries = gtk4::Button::with_label(&gettext("Drive Galleries")); - header.pack_end(&drive_galleries); ( frame.upcast(), GalleryWidgets { drive_galleries, + drive_status, + add_gallery, + hidden_albums, model, groups, content, @@ -998,6 +1060,19 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) { ) } +fn album_section_header(title: &str, action: >k4::Button) -> gtk4::Box { + let header = gtk4::Box::new(gtk4::Orientation::Horizontal, 8); + let heading = gtk4::Label::builder() + .label(title) + .xalign(0.0) + .hexpand(true) + .build(); + heading.add_css_class("title-3"); + header.append(&heading); + header.append(action); + header +} + /// Selection mode's controls, hidden until it starts: the count and Cancel /// for the header, and the actions along the bottom of the page. fn build_selection_bar() -> SelectionBar { @@ -1053,8 +1128,9 @@ fn build_selection_bar() -> SelectionBar { pub(crate) fn sync_header(ui: &Rc) { let gallery = &ui.gallery; let selecting = gallery.selecting.get(); - let collection = gallery.in_collection(); - let timeline = collection || gallery.view_switch.active() == VIEW_TIMELINE; + let galleries = gallery.content.visible_child_name().as_deref() == Some("drive-galleries"); + let collection = gallery.in_collection() || galleries; + let timeline = !galleries && (collection || gallery.view_switch.active() == VIEW_TIMELINE); gallery .view_switch .widget() @@ -1062,7 +1138,7 @@ pub(crate) fn sync_header(ui: &Rc) { gallery.title.set_visible(!selecting && collection); gallery.back.set_visible(!selecting && collection); gallery.upload.set_visible(!selecting && !collection); - gallery.more.set_visible(!selecting); + gallery.more.set_visible(!selecting && !galleries); gallery.select_btn.set_visible(!selecting && timeline); gallery.selection.title.set_visible(selecting); gallery.selection.cancel.set_visible(selecting); @@ -1152,15 +1228,24 @@ fn sync_filter_badge(ui: &Rc) { /// caller pairs this with a fresh timeline load. Off the UI thread; a failure /// just leaves the dropdown as it was. pub(crate) fn refresh_photo_months(ui: &Rc) { - let rx = spawn_request( - ui.dirs.control_socket(), - Request::PhotoMonths { - kind: ui.gallery.kind.get(), - }, - ); + if ui.gallery.months_loading.replace(true) { + ui.gallery.months_pending.set(true); + return; + } + let kind = ui.gallery.kind.get(); + let rx = spawn_request(ui.dirs.control_socket(), Request::PhotoMonths { kind }); let ui = ui.clone(); glib::spawn_future_local(async move { - let Ok(Ok(Response::PhotoMonths { months })) = rx.recv().await else { + let reply = rx.recv().await; + ui.gallery.months_loading.set(false); + let kind_changed = ui.gallery.kind.get() != kind; + if ui.gallery.months_pending.replace(false) || kind_changed { + refresh_photo_months(&ui); + } + if kind_changed { + return; + } + let Ok(Ok(Response::PhotoMonths { months })) = reply else { return; }; let mut labels = vec![gettext("All dates")]; @@ -1254,6 +1339,71 @@ pub(crate) fn wire_gallery_empty(ui: &Rc, upload: >k4::Button, import: > import.connect_clicked(move |_| ui_import.stack.set_visible_child_name("takeout")); } +/// GTK binds a large window of list rows to estimate the scroll range. Give +/// those rows their height up front and build tile widgets near the viewport. +fn schedule_visible_tiles(ui: &Rc) { + // Keep checking through allocations triggered by zoom and anchor restore. + if ui.gallery.visible_tiles_pending.replace(3) > 0 { + return; + } + let weak = Rc::downgrade(ui); + ui.gallery.list.add_tick_callback(move |list, _| { + let Some(ui) = weak.upgrade() else { + return glib::ControlFlow::Break; + }; + let height = list.height() as f32; + let rows: Vec<_> = ui + .gallery + .bound + .borrow() + .values() + .filter_map(|row| { + if row.anchor.is_none() + || row.widget.first_child().is_some() + || !row.widget.is_mapped() + { + return None; + } + let bounds = row.widget.compute_bounds(list)?; + let near = bounds.height() > 0.0 + && bounds.y() < height + 180.0 + && bounds.y() + bounds.height() > -180.0; + near.then(|| (row.widget.clone(), row.item.upgrade())) + .and_then(|(widget, item)| { + let row = item?.item()?.downcast::().ok()?; + Some((widget, row)) + }) + }) + .collect(); + if !rows.is_empty() { + let mut pools = ui.gallery.tile_pools.borrow_mut(); + for (widget, row) in rows { + let row = row.borrow::(); + let GalleryRow::Tiles { tiles, .. } = &*row else { + continue; + }; + let pool = pools.entry(widget.clone()).or_default(); + while pool.len() < tiles.len() { + pool.push(TileWidget::new(&ui)); + } + for (tile_widget, tile) in pool.iter().zip(tiles) { + tile_widget.bind(&ui, tile); + widget.append(&tile_widget.button); + } + } + schedule_thumbs(&ui); + } + let pending = &ui.gallery.visible_tiles_pending; + let remaining = pending.get().saturating_sub(1); + pending.set(remaining); + if remaining == 0 { + glib::ControlFlow::Break + } else { + glib::ControlFlow::Continue + } + }); +} + pub(crate) fn wire_gallery( ui: &Rc, list: >k4::ListView, @@ -1283,6 +1433,10 @@ pub(crate) fn wire_gallery( row_box.remove(&child); } row_box.set_halign(gtk4::Align::Start); + row_box.set_height_request(match &*row { + GalleryRow::Tiles { tiles, .. } => tiles.first().map_or(1, |tile| tile.height), + _ => -1, + }); match &*row { GalleryRow::Memories => { // One strip widget, moved into whichever row box shows it. @@ -1300,31 +1454,21 @@ pub(crate) fn wire_gallery( row_box.set_margin_bottom(0); row_box.append(§ion_heading_widget(&ui_bind, heading)); } - GalleryRow::Tiles { tiles, last, .. } => { + GalleryRow::Tiles { last, .. } => { row_box.set_margin_top(0); // The last row of a day carries the gap to the next heading. row_box.set_margin_bottom(if *last { 4 } else { TILE_GAP }); - let mut pools = ui_bind.gallery.tile_pools.borrow_mut(); - let pool = pools.entry(row_box.clone()).or_default(); - for widget in pool.iter() { - widget.release(&ui_bind); - } - while pool.len() < tiles.len() { - pool.push(TileWidget::new(&ui_bind)); - } - for (widget, tile) in pool.iter().zip(tiles) { - widget.bind(&ui_bind, tile); - row_box.append(&widget.button); - } - drop(pools); - schedule_thumbs(&ui_bind); + schedule_visible_tiles(&ui_bind); } } - ui_bind - .gallery - .bound - .borrow_mut() - .insert(item.position(), (row.anchor(), row_box.clone())); + ui_bind.gallery.bound.borrow_mut().insert( + item.position(), + BoundRow { + anchor: row.anchor(), + widget: row_box, + item: item.downgrade(), + }, + ); }); // ListView recycles row widgets, so a scrolled-away row must give up its @@ -1338,22 +1482,18 @@ pub(crate) fn wire_gallery( let Some(row_box) = item.child() else { return; }; + ui_unbind + .gallery + .bound + .borrow_mut() + .retain(|_, row| row.widget.upcast_ref::() != &row_box); + let pools = ui_unbind.gallery.tile_pools.borrow(); + if let Some(pool) = row_box + .downcast_ref::() + .and_then(|row| pools.get(row)) { - let mut bound = ui_unbind.gallery.bound.borrow_mut(); - if bound - .get(&item.position()) - .is_some_and(|(_, row)| row.upcast_ref::() == &row_box) - { - bound.remove(&item.position()); - } - } - if let Some(obj) = item.item().and_downcast::() - && let GalleryRow::Tiles { tiles, .. } = &*obj.borrow::() - { - for tile in tiles { - ui_unbind - .gallery - .release_thumb(&tile.photo.uid, |picture| picture.is_ancestor(&row_box)); + for widget in pool { + widget.release(&ui_unbind); } } }); @@ -1386,6 +1526,7 @@ pub(crate) fn wire_gallery( // end, so scrolling at a normal pace never reaches it. let ui_scroll = ui.clone(); scroll.vadjustment().connect_value_changed(move |adj| { + schedule_visible_tiles(&ui_scroll); let last = ui_scroll.gallery.scroll_offset.replace(adj.value()); if (adj.value() - last).abs() > 1.0 { ui_scroll.gallery.scrolling_down.set(adj.value() > last); @@ -1402,9 +1543,10 @@ pub(crate) fn wire_gallery( // one screen. Nothing scrolls then, so the scrolling above never asks for // the next page: ask whenever the content shrinks under the viewport. let ui_fill = ui.clone(); - scroll - .vadjustment() - .connect_changed(move |_| fill_viewport(&ui_fill)); + scroll.vadjustment().connect_changed(move |_| { + schedule_visible_tiles(&ui_fill); + fill_viewport(&ui_fill); + }); wire_scrubber(ui); wire_drag_select(ui); @@ -1714,7 +1856,8 @@ fn sync_float_heading(ui: &Rc) { let top = scrolled .then(|| { let bound = ui.gallery.bound.borrow(); - bound.iter().find_map(|(position, (_, row))| { + bound.iter().find_map(|(position, row)| { + let row = &row.widget; let rect = row.compute_bounds(list)?; (row.is_mapped() && rect.y() + rect.height() > 0.0).then_some(*position) }) @@ -2804,17 +2947,19 @@ fn drag_scroll_speed(ui: &Rc, y: f64) -> f64 { /// a heading or a gap between rows. fn tile_at(ui: &Rc, x: f64, y: f64) -> Option { let list = &ui.gallery.list; - let (position, row) = - ui.gallery - .bound - .borrow() - .iter() - .find_map(|(position, (anchor, row))| { - anchor.as_ref()?; - let rect = row.compute_bounds(list)?; - let (top, bottom) = (f64::from(rect.y()), f64::from(rect.y() + rect.height())); - (row.is_mapped() && y >= top && y < bottom).then(|| (*position, row.clone())) - })?; + let (position, row) = ui + .gallery + .bound + .borrow() + .iter() + .find_map(|(position, bound)| { + let anchor = &bound.anchor; + let row = &bound.widget; + anchor.as_ref()?; + let rect = row.compute_bounds(list)?; + let (top, bottom) = (f64::from(rect.y()), f64::from(rect.y() + rect.height())); + (row.is_mapped() && y >= top && y < bottom).then(|| (*position, row.clone())) + })?; let mut index = 0; let mut child = row.first_child(); let mut i = 0; @@ -3098,19 +3243,20 @@ pub(crate) fn want_thumb(ui: &Rc, photo: &PhotoItem, picture: >k4::Picture ui.gallery.await_thumb(&photo.uid, picture); - match photo.thumb_path.as_deref() { - Some(path) => { - ui.gallery - .decode_queue - .borrow_mut() - .push_back((photo.uid.clone(), path.to_string())); - schedule_decode(ui); - } - None => { - let mut queue = ui.gallery.thumb_queue.borrow_mut(); - if !queue.contains(&photo.uid) { - queue.push_back(photo.uid.clone()); - } + let mut decode = ui.gallery.decode_queue.borrow_mut(); + if decode.iter().any(|(uid, _)| uid == &photo.uid) + || ui.gallery.thumb_inflight.borrow().contains(&photo.uid) + { + return; + } + if let Some(path) = &photo.thumb_path { + decode.push_back((photo.uid.clone(), path.clone())); + drop(decode); + schedule_decode(ui); + } else { + let mut queue = ui.gallery.thumb_queue.borrow_mut(); + if !queue.contains(&photo.uid) { + queue.push_back(photo.uid.clone()); } } } @@ -3121,7 +3267,11 @@ pub(crate) fn want_thumb(ui: &Rc, photo: &PhotoItem, picture: >k4::Picture /// dropped by [`flush_thumbs`] like any other queued uid. pub(crate) fn retry_pending_thumbs(ui: &Rc, uids: Vec) { let ui = ui.clone(); + let generation = ui.gallery.thumb_generation.get(); glib::timeout_add_local_once(THUMB_RETRY, move || { + if generation != ui.gallery.thumb_generation.get() { + return; + } { let mut queue = ui.gallery.thumb_queue.borrow_mut(); for uid in uids { @@ -3137,7 +3287,8 @@ pub(crate) fn retry_pending_thumbs(ui: &Rc, uids: Vec) { /// Ask the daemon for the queued thumbnails after a short pause, so a fast scroll /// coalesces into one batch per settle rather than one per row it flew past. pub(crate) fn schedule_thumbs(ui: &Rc) { - if ui.gallery.thumb_queue.borrow().is_empty() || ui.gallery.thumb_inflight.get() { + if ui.gallery.thumb_queue.borrow().is_empty() || !ui.gallery.thumb_inflight.borrow().is_empty() + { return; } if let Some(id) = ui.gallery.thumb_source.borrow_mut().take() { @@ -3154,48 +3305,44 @@ pub(crate) fn schedule_thumbs(ui: &Rc) { /// Send one [`Request::PhotoThumbs`] batch for the tiles on screen, topped up /// with the tiles just beyond them. /// -/// A queued uid whose tile has scrolled away is dropped while the queue is long, -/// because during a fast scroll what the user is looking at *now* is the only -/// thing worth the round trip. Once the queue is short the scroll has settled, -/// and those near misses are the tiles one flick away — fetching them costs one -/// batch and saves a blank tile, and the reply lands in the texture cache -/// whether or not a widget still wants it. +/// Drop queued tiles that are offscreen. The prefetch step then fills spare +/// room in a visible batch with tiles ahead of the viewport. pub(crate) fn flush_thumbs(ui: &Rc) { - if ui.gallery.thumb_inflight.get() { + if !ui.gallery.thumb_inflight.borrow().is_empty() { return; } let uids: Vec = { let mut queue = ui.gallery.thumb_queue.borrow_mut(); let wanted = ui.gallery.thumb_wanted.borrow(); - let settled = queue.len() <= THUMB_BATCH * 2; - let mut batch = Vec::new(); - let mut skipped = VecDeque::new(); - while batch.len() < THUMB_BATCH { - let Some(uid) = queue.pop_front() else { break }; - if wanted.contains_key(&uid) || settled { - batch.push(uid); - } else { - skipped.push_back(uid); - } - } - // Anything skipped over stays queued behind what was taken: the scroll - // may still come back to it. - for uid in skipped.into_iter().rev() { - queue.push_front(uid); - } - batch + let cached = ui.gallery.photo_tex.borrow(); + queue.retain(|uid| { + wanted + .get(uid) + .is_some_and(|tiles| tiles.iter().any(WidgetExt::is_mapped)) + && !cached.contains_key(uid) + }); + let take = queue.len().min(THUMB_BATCH); + queue.drain(..take).collect() }; let uids = prefetch_thumbs(ui, uids); if uids.is_empty() { return; } - ui.gallery.thumb_inflight.set(true); + ui.gallery + .thumb_inflight + .borrow_mut() + .extend(uids.iter().cloned()); + let generation = ui.gallery.thumb_generation.get(); let rx = spawn_request(ui.dirs.control_socket(), Request::PhotoThumbs { uids }); let ui = ui.clone(); glib::spawn_future_local(async move { let result = rx.recv().await; - ui.gallery.thumb_inflight.set(false); + ui.gallery.thumb_inflight.borrow_mut().clear(); + if generation != ui.gallery.thumb_generation.get() { + schedule_thumbs(&ui); + return; + } match result { Ok(Ok(Response::Thumbs { items })) => { let mut decode = ui.gallery.decode_queue.borrow_mut(); @@ -3256,7 +3403,7 @@ fn prefetch_thumbs(ui: &Rc, mut batch: Vec) -> Vec { let cached = ui.gallery.photo_tex.borrow(); let nothumb = ui.gallery.photo_nothumb.borrow(); - let mut queue = ui.gallery.thumb_queue.borrow_mut(); + let queue = ui.gallery.thumb_queue.borrow(); let mut warmed = 0; for index in ahead { if warmed >= THUMB_PREFETCH || batch.len() >= THUMB_BATCH { @@ -3280,11 +3427,10 @@ fn prefetch_thumbs(ui: &Rc, mut batch: Vec) -> Vec { continue; } warmed += 1; - if batch.len() < THUMB_BATCH { - batch.push(uid.clone()); - } else { - queue.push_back(uid.clone()); + if batch.len() == THUMB_BATCH { + break; } + batch.push(uid.clone()); } } batch @@ -3303,9 +3449,37 @@ pub(crate) fn schedule_decode(ui: &Rc) { glib::idle_add_local(move || { let batch: Vec<(String, String)> = { let mut queue = ui.gallery.decode_queue.borrow_mut(); - (0..4).filter_map(|_| queue.pop_front()).collect() + let wanted = ui.gallery.thumb_wanted.borrow(); + let list = &ui.gallery.list; + let visible = |uid: &str| { + wanted.get(uid).is_some_and(|pictures| { + pictures.iter().any(|picture| { + if !picture.is_mapped() { + return false; + } + !picture.is_ancestor(list) + || picture.compute_bounds(list).is_some_and(|bounds| { + bounds.y() + bounds.height() > 0.0 + && bounds.y() < list.height() as f32 + }) + }) + }) + }; + queue.retain(|(uid, _)| wanted.contains_key(uid)); + (0..4) + .filter_map(|_| { + queue + .iter() + .position(|(uid, _)| visible(uid)) + .and_then(|index| queue.remove(index)) + .or_else(|| queue.pop_front()) + }) + .collect() }; for (uid, path) in batch { + if ui.gallery.photo_tex.borrow().contains_key(&uid) { + continue; + } let texture = match gtk4::gdk::Texture::from_filename(&path) { Ok(texture) => texture, Err(e) => { @@ -3354,19 +3528,19 @@ pub(crate) fn schedule_relayout(ui: &Rc) { pub(crate) fn relayout_gallery(ui: &Rc) { // At the very top there is nothing to hold on to: the first photo row sits // under a heading, and anchoring on it would scroll that heading away. - let at_top = ui - .gallery - .list - .vadjustment() - .is_none_or(|adj| adj.value() < 1.0); - let anchor = if at_top { None } else { top_anchor(ui) }; + if let Some(tick) = ui.gallery.align_tick.borrow_mut().take() { + tick.remove(); + } + let scroll = ui.gallery.list.vadjustment().map_or(0.0, |adj| adj.value()); + let anchor = (scroll >= 1.0).then(|| top_anchor(ui)).flatten(); repaint_gallery(ui); let Some((anchor, offset)) = anchor else { return; }; - let Some(row) = row_of_photo(&ui.gallery.groups, &anchor) else { + let Some(row) = row_of_photo(&ui.gallery, &anchor) else { return; }; + tracing::debug!(scroll, row, offset, "Restore Photos zoom anchor"); // Scrolling to a row only brings it into view, anywhere in it; the rows // are laid out over the next frames, so the fine alignment follows them. ui.gallery @@ -3382,59 +3556,76 @@ const ALIGN_FRAMES: u32 = 4; /// Scroll so the top of row `position` sits `offset` px below the top of the /// viewport, re-checking for a few frames while the rows around it settle. fn align_row(ui: &Rc, position: u32, offset: f32) { + if let Some(tick) = ui.gallery.align_tick.borrow_mut().take() { + tick.remove(); + } let ui = ui.clone(); let frames = Cell::new(0); - ui.gallery.list.clone().add_tick_callback(move |list, _| { + let during_tick = ui.clone(); + let tick = ui.gallery.list.add_tick_callback(move |list, _| { + let ui = &during_tick; frames.set(frames.get() + 1); let top = ui .gallery .bound .borrow() .get(&position) - .filter(|(_, row)| row.is_mapped()) - .and_then(|(_, row)| row.compute_bounds(list)) - .map(|rect| rect.y()); - if let (Some(top), Some(adjustment)) = (top, list.vadjustment()) { + .filter(|row| { + row.item + .upgrade() + .is_some_and(|item| item.position() == position) + }) + .filter(|row| row.widget.is_mapped()) + .and_then(|row| row.widget.compute_bounds(list)) + .filter(|rect| rect.y() + rect.height() >= 0.0 && rect.y() <= list.height() as f32) + .map(|rect| (rect.y(), rect.height())); + if let (Some((top, height)), Some(adjustment)) = (top, list.vadjustment()) { + let offset = offset.max(16.0_f32.min(height) - height); let delta = f64::from(top - offset); if delta.abs() >= 1.0 { adjustment.set_value(adjustment.value() + delta); } + } else if frames.get() < ALIGN_FRAMES { + list.scroll_to(position, gtk4::ListScrollFlags::NONE, None); } if frames.get() >= ALIGN_FRAMES { + ui.gallery.align_tick.borrow_mut().take(); + schedule_visible_tiles(ui); glib::ControlFlow::Break } else { glib::ControlFlow::Continue } }); + *ui.gallery.align_tick.borrow_mut() = Some(tick); } -/// The first photo of the topmost photo row that reaches into the viewport, -/// and how far below the top of the viewport that row starts (negative when it -/// is partly scrolled off). -/// -/// Not simply the first bound row: the ListView keeps rows bound well outside -/// the viewport (unmapped, with their last allocation), and scrolling one of -/// those "back" to the top is a jump. Falls back to the first bound photo row -/// while the list isn't on screen. +/// Find the first photo row GTK actually hit-tests in the viewport. It can +/// keep other rows bound at an old allocation during scrolling or rebinding. fn top_anchor(ui: &Rc) -> Option<(String, f32)> { let list = &ui.gallery.list; - let bound = ui.gallery.bound.borrow(); - let mut photo_rows = bound - .values() - .filter_map(|(uid, row)| uid.as_ref().map(|uid| (uid, row))); - let first = photo_rows.clone().next().map(|(uid, _)| (uid.clone(), 0.0)); - photo_rows - .find_map(|(uid, row)| { - let rect = row.compute_bounds(list)?; - (row.is_mapped() && rect.y() + rect.height() > 0.0).then(|| (uid.clone(), rect.y())) - }) - .or(first) + let rows = ui.gallery.bound.borrow(); + let flags = gtk4::PickFlags::NON_TARGETABLE | gtk4::PickFlags::INSENSITIVE; + for y in (1..list.height()).step_by(16) { + let Some(hit) = list.pick(6.0, f64::from(y), flags) else { + continue; + }; + let row = rows.values().find(|row| { + row.anchor.is_some() + && (hit.is_ancestor(&row.widget) || row.widget.parent().as_ref() == Some(&hit)) + }); + if let Some(row) = row + && let Some(rect) = row.widget.compute_bounds(list) + { + return row.anchor.clone().map(|uid| (uid, rect.y())); + } + } + None } /// Scroll the grid just far enough to show photo `uid`, as the lightbox /// closes: paging with the arrow keys may have left the grid far behind. pub(crate) fn reveal_photo(ui: &Rc, uid: &str) { - if let Some(row) = row_of_photo(&ui.gallery.groups, uid) { + if let Some(row) = row_of_photo(&ui.gallery, uid) { ui.gallery .list .scroll_to(row, gtk4::ListScrollFlags::NONE, None); @@ -3442,16 +3633,19 @@ pub(crate) fn reveal_photo(ui: &Rc, uid: &str) { } /// Which row of the rendered model holds `uid`, if any. -fn row_of_photo(store: &gio::ListStore, uid: &str) -> Option { - (0..store.n_items()).find(|i| { +fn row_of_photo(gallery: &GalleryState, uid: &str) -> Option { + let (row, _) = *gallery.row_by_photo.borrow().get(uid)?; + let position = row + memory_prefix(&gallery.groups); + (position < gallery.groups.n_items()).then_some(position) +} + +fn memory_prefix(store: &gio::ListStore) -> u32 { + u32::from( store - .item(*i) + .item(0) .and_downcast::() - .is_some_and(|obj| match &*obj.borrow::() { - GalleryRow::Memories | GalleryRow::Heading(_) => false, - GalleryRow::Tiles { tiles, .. } => tiles.iter().any(|t| t.photo.uid == uid), - }) - }) + .is_some_and(|row| matches!(*row.borrow::(), GalleryRow::Memories)), + ) } /// Step the target row height by `delta` px and re-flow, clamped to the zoom @@ -3471,52 +3665,119 @@ pub(crate) fn set_gallery_tile(ui: &Rc, tile: i32) { schedule_relayout(ui); } -/// Rebuild the ListView's row model from the flat photo model: each day becomes -/// a heading row followed by its grid rows, laid out to the current width and -/// zoom. -/// -/// The rows are diffed into the existing store rather than replacing it: a "load -/// more" only really changes the last day (the one the new page continues) and -/// appends after it, and clearing the store instead would scroll the user back -/// to the top of the timeline at the exact moment they asked for more. +/// Publish one model update, keeping the existing GTK objects for equal rows. pub(crate) fn repaint_gallery(ui: &Rc) { - let rows = build_rows(ui); - let store = &ui.gallery.groups; - - for (i, row) in rows.iter().enumerate() { - let i = i as u32; - let unchanged = store - .item(i) - .and_downcast::() - .is_some_and(|old| row.same_as(&old.borrow::())); - if unchanged { - continue; - } - let boxed = BoxedAnyObject::new(clone_row(row)); - if i < store.n_items() { - store.splice(i, 1, &[boxed]); - } else { - store.append(&boxed); - } - } - if store.n_items() > rows.len() as u32 { - let len = rows.len() as u32; - store.splice(len, store.n_items() - len, &[] as &[BoxedAnyObject]); - } - - update_gallery_subtitle(ui); + repaint_rows(ui, None); } -/// Flatten the loaded photos into the rows the ListView renders. -fn build_rows(ui: &Rc) -> Vec { +fn repaint_rows(ui: &Rc, append_from: Option) { + let started = std::time::Instant::now(); + let gallery = &ui.gallery; + let store = &gallery.groups; let width = gallery_width(ui); + let layout = (width, gallery.row_height.get(), gallery.square.get()); + let memories = u32::from(shows_memories(ui)); + let tail = append_from + .filter(|offset| { + *offset == gallery.rendered_photos.get() + && gallery.rendered_layout.get() == Some(layout) + }) + .filter(|_| memory_prefix(store) == memories) + .and_then(|offset| { + (0..store.n_items()).rev().find_map(|index| { + let item = store.item(index).and_downcast::()?; + match &*item.borrow::() { + GalleryRow::Heading(heading) => { + Some((index, offset.saturating_sub(heading.uids.len() as u32))) + } + _ => None, + } + }) + }); + let (first_row, first_photo) = tail.unwrap_or((0, 0)); + let mut rows = build_rows(ui, width, first_photo); + if tail.is_none() && memories == 1 { + rows.insert(0, GalleryRow::Memories); + } + gallery.rendered_layout.set(Some(layout)); + gallery.rendered_photos.set(gallery.model.n_items()); + + { + let mut index = gallery.row_by_photo.borrow_mut(); + if tail.is_none() { + index.clear(); + } + for (position, row) in rows.iter().enumerate() { + if let GalleryRow::Tiles { tiles, .. } = row { + let position = first_row + position as u32 - memories; + index.extend( + tiles + .iter() + .map(|tile| (tile.photo.uid.clone(), (position, tile.photo.capture_time))), + ); + } + } + } + + let before = store.n_items() - first_row; + let after = rows.len() as u32; + let mut matched = 0; + let objects: Vec<_> = rows + .into_iter() + .enumerate() + .map(|(index, row)| { + if let Some(old) = store + .item(first_row + index as u32) + .and_downcast::() + && row.same_as(&old.borrow::()) + { + matched += 1; + return (true, old); + } + (false, BoxedAnyObject::new(row)) + }) + .collect(); + if before != after || matched != after { + let prefix = objects.iter().take_while(|(same, _)| *same).count(); + let suffix = if before == after { + objects[prefix..] + .iter() + .rev() + .take_while(|(same, _)| *same) + .count() + } else { + 0 + }; + let update: Vec<_> = objects + .into_iter() + .skip(prefix) + .take(after as usize - prefix - suffix) + .map(|(_, row)| row) + .collect(); + let planning_ms = started.elapsed().as_millis() as u64; + store.splice( + first_row + prefix as u32, + before - (prefix + suffix) as u32, + &update, + ); + tracing::debug!( + photos = gallery.rendered_photos.get(), + layout_ms = started.elapsed().as_millis() as u64, + planning_ms, + bound_rows = gallery.bound.borrow().len(), + first_photo, + rows_before = before, + rows_after = after, + "Updated Photos rows" + ); + } +} + +fn build_rows(ui: &Rc, width: i32, first: u32) -> Vec { let mut rows = Vec::new(); let grouping = grouping_for(ui.gallery.row_height.get()); - if shows_memories(ui) { - rows.push(GalleryRow::Memories); - } let selecting = ui.gallery.selecting.get(); - for group in group_photos(&ui.gallery.model, grouping) { + for group in group_photos_from(&ui.gallery.model, grouping, first) { let uids: Vec = group.photos.iter().map(|photo| photo.uid.clone()).collect(); let selected = selecting && { let picked = ui.gallery.selected.borrow(); @@ -3541,22 +3802,6 @@ fn build_rows(ui: &Rc) -> Vec { rows } -fn clone_row(row: &GalleryRow) -> GalleryRow { - match row { - GalleryRow::Memories => GalleryRow::Memories, - GalleryRow::Heading(heading) => GalleryRow::Heading(heading.clone()), - GalleryRow::Tiles { - section, - tiles, - last, - } => GalleryRow::Tiles { - section: section.clone(), - tiles: tiles.clone(), - last: *last, - }, - } -} - /// "1,204 photos" under the page title. pub(crate) fn update_gallery_subtitle(ui: &Rc) { let loaded = ui.gallery.model.n_items() as usize; @@ -3602,21 +3847,32 @@ pub(crate) fn update_gallery_subtitle(ui: &Rc) { }); } -pub(crate) fn group_photos(model: &gio::ListStore, grouping: Grouping) -> Vec { +fn group_photos_from(model: &gio::ListStore, grouping: Grouping, first: u32) -> Vec { let mut groups: Vec = Vec::new(); - for i in 0..model.n_items() { + let mut previous = None; + let timezone = glib::TimeZone::local(); + for i in first..model.n_items() { let Some(obj) = model.item(i) else { continue }; let Some(boxed) = obj.downcast_ref::() else { continue; }; let photo = boxed.borrow::().clone(); - let heading = section_heading(photo.capture_time, grouping); - match groups.last_mut() { - Some(group) if group.heading == heading => group.photos.push(photo), - _ => groups.push(PhotoGroup { - heading, + let day = glib::DateTime::from_unix_utc(photo.capture_time) + .and_then(|timestamp| timestamp.to_timezone(&timezone)) + .ok(); + let period = day.as_ref().map(|date| match grouping { + Grouping::Day => (date.year(), date.month(), date.day_of_month()), + Grouping::Month => (date.year(), date.month(), 0), + Grouping::Year => (date.year(), 0, 0), + }); + if let Some(group) = groups.last_mut().filter(|_| previous == period) { + group.photos.push(photo); + } else { + groups.push(PhotoGroup { + heading: section_heading(photo.capture_time, grouping), photos: vec![photo], - }), + }); + previous = period; } } groups @@ -3792,8 +4048,8 @@ pub(crate) fn sync_scrubber(ui: &Rc) { const MEMORIES_LIMIT: usize = 200; /// Size of an "On this day" card's cover, in px. -const MEMORY_CARD_WIDTH: i32 = 180; -const MEMORY_CARD_HEIGHT: i32 = 120; +const MEMORY_CARD_WIDTH: i32 = 144; +const MEMORY_CARD_HEIGHT: i32 = 92; /// Ask the daemon for photos taken on today's date in earlier years, and fill /// the "On this day" strip with a card per year. A failure leaves the strip @@ -3925,10 +4181,7 @@ fn shows_memories(ui: &Rc) -> bool { /// one row changes, so the rest of the list keeps its widgets and position. fn sync_memories(ui: &Rc) { let store = &ui.gallery.groups; - let shown = store - .item(0) - .and_downcast::() - .is_some_and(|obj| matches!(*obj.borrow::(), GalleryRow::Memories)); + let shown = memory_prefix(store) == 1; match (shown, shows_memories(ui)) { (false, true) => store.insert(0, &BoxedAnyObject::new(GalleryRow::Memories)), (true, false) => store.remove(0), @@ -3952,11 +4205,7 @@ fn sync_scrubber_position(ui: &Rc) { let Some((uid, _)) = top_anchor(ui) else { return; }; - let Some(capture_time) = find_photo_index(&ui.gallery.model, &uid) - .and_then(|idx| ui.gallery.model.item(idx)) - .and_downcast::() - .map(|boxed| boxed.borrow::().capture_time) - else { + let Some((_, capture_time)) = ui.gallery.row_by_photo.borrow().get(&uid).copied() else { return; }; let months = ui.gallery.months.borrow(); @@ -4046,7 +4295,7 @@ fn continue_jump(ui: &Rc) { else { return; }; - let Some(row) = row_of_photo(&ui.gallery.groups, &uid) else { + let Some(row) = row_of_photo(&ui.gallery, &uid) else { return; }; // Land on the day heading above the photo when it opens a day. @@ -4228,6 +4477,27 @@ pub(crate) fn photo_grid_shown(ui: &Ui) -> bool { } pub(crate) fn load_gallery(ui: &Rc, append: bool) { + load_gallery_page(ui, append, None); +} + +pub(crate) fn refresh_visible_photos(ui: &Rc) { + if ui.gallery.loading.get() { + ui.gallery.changes_pending.set(true); + return; + } + if !photo_grid_shown(ui) { + ui.gallery.timeline_stale.set(true); + return; + } + let scroll = ui + .gallery + .list + .vadjustment() + .map_or(0.0, |adjustment| adjustment.value()); + load_gallery_page(ui, false, Some(scroll)); +} + +fn load_gallery_page(ui: &Rc, append: bool, keep_scroll: Option) { sync_filter_badge(ui); // A load would put the grid, or its status page, on screen in place of // the Albums or Places view the user is looking at. Leave the timeline to @@ -4252,7 +4522,7 @@ pub(crate) fn load_gallery(ui: &Rc, append: bool) { let album = ui.gallery.album.borrow().as_ref().map(|a| a.uid.clone()); let place = ui.gallery.place.borrow().as_ref().map(|p| p.id); let collection = album.is_some() || place.is_some(); - if !append { + if !append && keep_scroll.is_none() { // A scrubber jump looks for a month of the listing being replaced: // another filter, album or place has its own months, if any. ui.gallery.jump.set(None); @@ -4278,8 +4548,17 @@ pub(crate) fn load_gallery(ui: &Rc, append: bool) { } sync_memories(ui); } - let offset = ui.gallery.model.n_items() as usize; - let limit = if ui.gallery.burst.replace(false) { + if keep_scroll.is_some() && !collection && ui.gallery.range.get().is_none() { + refresh_photo_months(ui); + } + let offset = if append { + ui.gallery.model.n_items() as usize + } else { + 0 + }; + let limit = if keep_scroll.is_some() { + (ui.gallery.model.n_items() as usize).clamp(PHOTOS_PAGE, 1000) + } else if ui.gallery.burst.replace(false) { JUMP_PAGE } else { PHOTOS_PAGE @@ -4311,6 +4590,10 @@ pub(crate) fn load_gallery(ui: &Rc, append: bool) { load_gallery(&ui, false); return; } + if ui.gallery.changes_pending.replace(false) { + refresh_visible_photos(&ui); + return; + } // Whoever waited on this page runs once the reply below has put it in // the model, whichever way that goes. let waiters = std::mem::take(&mut *ui.gallery.page_waiters.borrow_mut()); @@ -4359,14 +4642,24 @@ pub(crate) fn load_gallery(ui: &Rc, append: bool) { nothumb.insert(item.uid.clone()); } } - for item in &items { - ui.gallery.model.append(&BoxedAnyObject::new(item.clone())); + let items: Vec<_> = items.into_iter().map(BoxedAnyObject::new).collect(); + let old = if append { + 0 + } else { + ui.gallery.model.n_items() + }; + ui.gallery.model.splice(offset as u32, old, &items); + repaint_rows(&ui, append.then_some(offset as u32)); + if let (Some(scroll), Some(adjustment)) = + (keep_scroll, ui.gallery.list.vadjustment()) + { + glib::idle_add_local_once(move || adjustment.set_value(scroll)); } - repaint_gallery(&ui); // The rows are swapped in place, which keeps the old scroll // offset; a fresh load (another kind, month, album or place) // reads from its newest photo. if !append + && keep_scroll.is_none() && ui .gallery .list @@ -4424,6 +4717,7 @@ pub(crate) fn load_gallery(ui: &Rc, append: bool) { ui.gallery.content.set_visible_child_name("timeline"); fill_viewport(&ui); } + _ if keep_scroll.is_some() && ui.gallery.model.n_items() > 0 => {} // A failed *next* page keeps the photos already on screen — the failure // goes to a toast rather than wiping the timeline for a status page. Ok(Ok(Response::Error { message, .. })) if append => { diff --git a/crates/pdfs-gui/tests/icon_names.rs b/crates/pdfs-gui/tests/icon_names.rs index be37f59..dc6790c 100644 --- a/crates/pdfs-gui/tests/icon_names.rs +++ b/crates/pdfs-gui/tests/icon_names.rs @@ -26,6 +26,7 @@ const STOCK: &[&str] = &[ // Adwaita "application-x-executable-symbolic", "audio-x-generic-symbolic", + "changes-prevent-symbolic", "checkbox-checked-symbolic", "checkbox-symbolic", "computer-symbolic", diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md index 4ccd367..2608287 100644 --- a/docs/CHANGELOG.md +++ b/docs/CHANGELOG.md @@ -13,7 +13,7 @@ scratch (user data in `staging/` and `recovery/` is never touched by this). ### Added -- Open **Drive Galleries** from Photos to browse saved My files folders and their +- Open **Drive galleries** in Photos → Albums to browse saved My files folders and their subfolders, choose album covers, and manage public links. Saved galleries and covers sync with Proton Gallery on desktop and Android. diff --git a/docs/PHOTOS.md b/docs/PHOTOS.md index 80be461..f64643c 100644 --- a/docs/PHOTOS.md +++ b/docs/PHOTOS.md @@ -1,5 +1,30 @@ # Photos +## How Photos is organized + +Timeline, Albums, and Places share the same Photos workspace. The Timeline opens +with the media type, Filters, and, where available, **On this day**. Albums +contains the two collections **Proton albums** and **Drive galleries**. Add a +gallery by choosing a folder from **My files**. Opening it or any subfolder +keeps you in Photos. Back or Escape returns to the parent and its scroll +position. + +**Hidden albums** opens with the Gallery passphrase stored for this account in +your Linux keyring. It includes hidden Proton albums and hidden Drive gallery +folders, including folders inside public galleries. Leaving Hidden albums or +switching away from the window locks it and closes its previews. + +GTK pages Timeline, Proton albums, and Places through the Drive daemon's Photos +control requests backed by its SQLite database. Saved Drive galleries come from +the shared Proton Gallery catalog, which the daemon hosts for the signed-in +account. Photos applies that catalog's visibility rules to public queries. +Hidden albums use separate, unlock-gated requests. Thumbnails in the hidden +view are kept in memory and cleared on lock. + +Ctrl+mousewheel changes timeline tile size. GTK updates only the changed row +range and keeps the visible photo in place. As you scroll, each new page +updates the last affected section and adds new sections below it. + The **Photos** page of the app shows your Proton Photos library. Photos are stored apart from My files, so they do not appear in `~/ProtonDrive`.