From cb5ff8b8da122736e7f2af1ab965556eb179f349 Mon Sep 17 00:00:00 2001 From: Nils Pukropp Date: Thu, 19 Nov 2026 11:42:47 +0100 Subject: [PATCH 1/5] feat(photos): integrate the shared Gallery engine Share gallery settings and layout with Proton Gallery. Preserve Git source mappings so COPR can resolve the dependency offline. --- .github/workflows/release.yml | 8 +- Cargo.lock | 81 ++ Cargo.toml | 2 + crates/pdfs-cli/src/main.rs | 1 + crates/pdfs-core/Cargo.toml | 1 + crates/pdfs-core/src/auth.rs | 42 + crates/pdfs-core/src/control.rs | 490 +++++++++-- crates/pdfs-core/src/db/albums.rs | 56 +- crates/pdfs-core/src/db/photos.rs | 121 ++- crates/pdfs-core/src/db/tests.rs | 27 + crates/pdfs-fuse/Cargo.toml | 7 + crates/pdfs-fuse/src/albums.rs | 3 +- crates/pdfs-fuse/src/control.rs | 132 ++- crates/pdfs-fuse/src/gallery.rs | 431 +++++++++ crates/pdfs-fuse/src/gallery/video.rs | 205 +++++ crates/pdfs-fuse/src/lib.rs | 2 + crates/pdfs-fuse/src/link.rs | 3 + crates/pdfs-fuse/src/mount.rs | 12 + crates/pdfs-fuse/src/photos.rs | 30 +- crates/pdfs-fuse/src/sim/daemon.rs | 1 + crates/pdfs-gui/Cargo.toml | 2 + crates/pdfs-gui/resources/style.css | 1 + crates/pdfs-gui/src/app/events.rs | 26 + crates/pdfs-gui/src/app/main.rs | 6 + .../pdfs-gui/src/app/pages/drive_galleries.rs | 822 ++++++++++++++++++ crates/pdfs-gui/src/app/pages/login.rs | 4 + crates/pdfs-gui/src/app/pages/mod.rs | 1 + crates/pdfs-gui/src/app/pages/photo_viewer.rs | 92 +- crates/pdfs-gui/src/app/pages/photos.rs | 98 +-- docs/CHANGELOG.md | 13 + packaging/copr/README.md | 2 +- packaging/nix/package.nix | 5 +- packaging/proton-drive-linux.spec | 11 +- po/POTFILES.in | 1 + 34 files changed, 2492 insertions(+), 247 deletions(-) create mode 100644 crates/pdfs-fuse/src/gallery.rs create mode 100644 crates/pdfs-fuse/src/gallery/video.rs create mode 100644 crates/pdfs-gui/src/app/pages/drive_galleries.rs diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index d96d82a..b314769 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -129,8 +129,12 @@ jobs: # Every crate the build needs, so COPR can build the spec without network. - name: Package vendored crates (.tar.xz) run: | - cargo vendor --locked dist/vendor > /dev/null - tar -cJf proton-drive-linux-vendor-${{ env.VERSION }}.tar.xz -C dist vendor + mkdir -p dist/.cargo + ( + cd dist + cargo vendor --locked --manifest-path ../Cargo.toml vendor > .cargo/config.toml + ) + tar -cJf proton-drive-linux-vendor-${{ env.VERSION }}.tar.xz -C dist vendor .cargo/config.toml - name: Package Debian package (.deb) run: | diff --git a/Cargo.lock b/Cargo.lock index cdb2d44..16a9237 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -49,6 +49,7 @@ dependencies = [ "cipher 0.5.2", "cpubits", "cpufeatures 0.3.1", + "zeroize", ] [[package]] @@ -77,6 +78,7 @@ dependencies = [ "ctr 0.10.1", "ctutils", "ghash 0.6.0", + "zeroize", ] [[package]] @@ -1878,6 +1880,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2eecf2d5dc9b66b732b97707a0210906b1d30523eb773193ab777c0c84b3e8d5" dependencies = [ "polyval 0.7.3", + "zeroize", ] [[package]] @@ -2237,6 +2240,12 @@ version = "1.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" +[[package]] +name = "httpdate" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9" + [[package]] name = "hybrid-array" version = "0.4.15" @@ -2260,6 +2269,7 @@ dependencies = [ "http", "http-body", "httparse", + "httpdate", "itoa", "pin-project-lite", "smallvec", @@ -3601,6 +3611,7 @@ dependencies = [ name = "pdfs-core" version = "3.8.1" dependencies = [ + "argon2", "async-trait", "base64 0.23.1", "chrono", @@ -3635,12 +3646,18 @@ dependencies = [ "base64 0.23.1", "fuser", "futures", + "getrandom 0.4.3", + "http-body-util", + "hyper", + "hyper-util", "image", "libc", "lofty", "notify", "parking_lot 0.13.0", "pdfs-core", + "pg-app", + "pg-core", "proton-drive-rs", "serde", "serde_json", @@ -3648,6 +3665,7 @@ dependencies = [ "tokio", "tracing", "tracing-subscriber", + "zeroize", "zip", ] @@ -3657,6 +3675,7 @@ version = "3.8.1" dependencies = [ "anyhow", "async-channel", + "base64 0.23.1", "gettext-rs", "gtk4", "kamadak-exif", @@ -3664,6 +3683,7 @@ dependencies = [ "libadwaita", "pangocairo", "pdfs-core", + "pg-core", "reqwest", "serde", "serde_json", @@ -3688,6 +3708,65 @@ version = "2.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" +[[package]] +name = "pg-app" +version = "0.2.0" +source = "git+https://github.com/narrrl/proton-gallery.git?rev=72d83a29ad2836c698b18e2f5189a423c60c2399#72d83a29ad2836c698b18e2f5189a423c60c2399" +dependencies = [ + "async-trait", + "hex", + "pg-core", + "pg-drive", + "proton-drive-rs", + "proton-sdk", + "serde_json", + "sha2 0.11.1", + "tempfile", + "thiserror 2.0.21", + "tokio", + "tracing", + "zeroize", +] + +[[package]] +name = "pg-core" +version = "0.2.0" +source = "git+https://github.com/narrrl/proton-gallery.git?rev=72d83a29ad2836c698b18e2f5189a423c60c2399#72d83a29ad2836c698b18e2f5189a423c60c2399" +dependencies = [ + "aes-gcm 0.11.1", + "async-trait", + "getrandom 0.4.3", + "hex", + "rusqlite", + "serde", + "serde_json", + "sha2 0.11.1", + "tempfile", + "thiserror 2.0.21", + "tokio", + "tokio-util", + "zeroize", +] + +[[package]] +name = "pg-drive" +version = "0.2.0" +source = "git+https://github.com/narrrl/proton-gallery.git?rev=72d83a29ad2836c698b18e2f5189a423c60c2399#72d83a29ad2836c698b18e2f5189a423c60c2399" +dependencies = [ + "async-trait", + "hex", + "pg-core", + "proton-drive-rs", + "proton-sdk", + "serde", + "serde_json", + "sha2 0.11.1", + "thiserror 2.0.21", + "tokio", + "tracing", + "zeroize", +] + [[package]] name = "pgp" version = "0.21.0" @@ -3825,6 +3904,7 @@ dependencies = [ "cpubits", "cpufeatures 0.3.1", "universal-hash 0.6.1", + "zeroize", ] [[package]] @@ -5191,6 +5271,7 @@ dependencies = [ "bytes", "futures-core", "futures-sink", + "futures-util", "libc", "pin-project-lite", "tokio", diff --git a/Cargo.toml b/Cargo.toml index bcd827d..1795e75 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -17,6 +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" } chrono = { version = "0.4", default-features = false, features = ["std"] } # Internal crates. diff --git a/crates/pdfs-cli/src/main.rs b/crates/pdfs-cli/src/main.rs index f6692ed..52fb31b 100644 --- a/crates/pdfs-cli/src/main.rs +++ b/crates/pdfs-cli/src/main.rs @@ -2696,6 +2696,7 @@ fn mount_once(mountpoint: Option) -> Result { db, pdfs_fuse::MountOptions { username, + gallery_session: Some(session.clone()), sweep_mode: config.resolved_conflict_sweep(), upload_limit: config.upload_limit.unwrap_or(0), download_limit: config.download_limit.unwrap_or(0), diff --git a/crates/pdfs-core/Cargo.toml b/crates/pdfs-core/Cargo.toml index 9deceea..46a80a3 100644 --- a/crates/pdfs-core/Cargo.toml +++ b/crates/pdfs-core/Cargo.toml @@ -10,6 +10,7 @@ homepage.workspace = true description = "Core auth/session/config for the Proton Drive Linux client" [dependencies] +argon2 = "0.5" proton-sdk.workspace = true proton-drive-rs.workspace = true chrono.workspace = true diff --git a/crates/pdfs-core/src/auth.rs b/crates/pdfs-core/src/auth.rs index fe57852..b22dd6d 100644 --- a/crates/pdfs-core/src/auth.rs +++ b/crates/pdfs-core/src/auth.rs @@ -128,6 +128,48 @@ fn with_keyring(op: impl Fn(&Entry) -> keyring_core::Result) -> Result with_keyring_entry(KEYRING_SERVICE, KEYRING_USER, op) } +/// Verify the machine-local Gallery passphrase, setting it on first use. +pub fn unlock_gallery(username: &str, passphrase: &str) -> std::result::Result<(), String> { + use argon2::password_hash::{PasswordHash, PasswordHasher, PasswordVerifier, SaltString}; + use std::io::Read; + + if passphrase.is_empty() || passphrase.len() > 1024 { + return Err("Enter your Gallery passphrase.".into()); + } + static VERIFY: parking_lot::Mutex<()> = parking_lot::Mutex::new(()); + let _verify = VERIFY.lock(); + let service = "io.narl.protongallery"; + let user = format!("hidden-albums:{username}"); + let argon = argon2::Argon2::default(); + match with_keyring_entry(service, &user, Entry::get_password) { + Ok(stored) => { + let hash = PasswordHash::new(&stored) + .map_err(|_| "The saved Gallery passphrase is unreadable.")?; + argon + .verify_password(passphrase.as_bytes(), &hash) + .map_err(|_| "The Gallery passphrase is incorrect.".into()) + } + Err(Error::Keyring(keyring_core::Error::NoEntry)) => { + if passphrase.chars().count() < 12 { + return Err("Choose a Gallery passphrase with at least 12 characters.".into()); + } + let mut bytes = [0; 16]; + std::fs::File::open("/dev/urandom") + .and_then(|mut file| file.read_exact(&mut bytes)) + .map_err(|_| "Couldn’t generate the passphrase salt.")?; + let salt = SaltString::encode_b64(&bytes) + .map_err(|_| "Couldn’t generate the passphrase salt.")?; + let hash = argon + .hash_password(passphrase.as_bytes(), &salt) + .map_err(|_| "Couldn’t protect the Gallery passphrase.")? + .to_string(); + with_keyring_entry(service, &user, |entry| entry.set_password(&hash)) + .map_err(|_| "Couldn’t save the Gallery passphrase in the system keyring.".into()) + } + Err(_) => Err("The system keyring is locked or unavailable.".into()), + } +} + /// Run `op` on the entry `service`/`user`, reconnecting once if the Secret /// Service fails the call. /// diff --git a/crates/pdfs-core/src/control.rs b/crates/pdfs-core/src/control.rs index e82fd9e..d9df2aa 100644 --- a/crates/pdfs-core/src/control.rs +++ b/crates/pdfs-core/src/control.rs @@ -44,14 +44,20 @@ pub enum Request { /// Report mount status (account, mountpoint, pin count). Status, /// Pin a file (path relative to the mountpoint, or absolute under it). - Pin { path: String }, + Pin { + path: String, + }, /// Unpin a file, evicting its cached content. - Unpin { path: String }, + Unpin { + path: String, + }, /// List pinned files. ListPins, /// List a directory for the in-app file browser. `path` is /// mountpoint-relative (empty or "." = the mount root). - ListDir { path: String }, + ListDir { + path: String, + }, /// Fetch a page of the photos timeline, newest first. Returns metadata only: /// a thumbnail path comes back only for photos already in the cache, so the /// reply never waits on the network. Front-ends ask for the thumbnails they @@ -83,7 +89,9 @@ pub enum Request { /// live photo and its clip. Replies with [`Response::Photos`], holding one /// item per file in server order; a photo that stands alone comes back as a /// single item. The lightbox uses it to switch between a shot's files. - PhotoGroup { uid: String }, + PhotoGroup { + uid: String, + }, /// 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. @@ -94,7 +102,9 @@ pub enum Request { /// Photos taken on today's date in earlier years, newest first, at most /// `limit` of them — the "On this day" strip above the timeline. Replies /// with [`Response::Photos`]; a front-end groups them by year itself. - PhotosOnThisDay { limit: usize }, + PhotosOnThisDay { + limit: usize, + }, /// Sets of photos that are byte-identical copies of each other, going by /// the server's content hash. Replies with [`Response::PhotoDuplicates`]. PhotoDuplicates, @@ -118,7 +128,9 @@ pub enum Request { }, /// Every photo taken in one town with where exactly it was taken, for the /// map's close-up. Replies with [`Response::PhotoLocations`]. - PlaceLocations { id: u32 }, + PlaceLocations { + id: u32, + }, /// List the account's photo albums, newest activity first, including the /// albums other people share with us. Metadata only — an album's cover /// thumbnail is fetched with [`Request::PhotoThumbs`] like any other photo. @@ -134,9 +146,14 @@ pub enum Request { limit: usize, }, /// Create an album named `name`. Replies with [`Response::AlbumCreated`]. - CreateAlbum { name: String }, + CreateAlbum { + name: String, + }, /// Rename the album `uid`. Replies with [`Response::Ok`]. - RenameAlbum { uid: String, name: String }, + RenameAlbum { + uid: String, + name: String, + }, /// Delete the album `uid`. Its photos stay in the timeline; with /// `delete_photos` set, photos that exist only in the album (saved from a /// shared album) are deleted with it, which the server otherwise refuses. @@ -148,14 +165,22 @@ pub enum Request { }, /// Add timeline photos to the album `uid`. Replies with /// [`Response::AlbumChanged`]. - AddToAlbum { uid: String, photos: Vec }, + AddToAlbum { + uid: String, + photos: Vec, + }, /// Take photos out of the album `uid`. They stay in the timeline: this is /// not a trash. Replies with [`Response::AlbumChanged`]. - RemoveFromAlbum { uid: String, photos: Vec }, + RemoveFromAlbum { + uid: String, + photos: Vec, + }, /// Fetch thumbnails for the given photo uids, downloading the ones not /// already cached (one batched round-trip) and replying with their on-disk /// paths. Keep the batch small — it is served on demand, as tiles scroll in. - PhotoThumbs { uids: Vec }, + PhotoThumbs { + uids: Vec, + }, /// Trash photos by node uid, answered with [`Response::Trashed`]. /// /// Uid-addressed rather than path-addressed because the photos volume is not @@ -190,11 +215,15 @@ pub enum Request { ReserveFileThumbGeneration, /// Stop ordinary-file thumbnail work belonging to older listings. Photos /// timeline work and an explicit recursive build are deliberately separate. - CancelFileThumbs { generation: u64 }, + CancelFileThumbs { + generation: u64, + }, /// Start building local thumbnails for every supported image below `path`. /// The request returns immediately; progress is read with /// [`Request::ThumbnailBuildStatus`]. - StartThumbnailBuild { path: String }, + StartThumbnailBuild { + path: String, + }, /// Stop the current recursive ordinary-file thumbnail build, if any. CancelThumbnailBuild, /// Read progress for the recursive ordinary-file thumbnail build. @@ -206,7 +235,25 @@ pub enum Request { /// is how a front-end knows when the refreshed timeline is worth re-reading. PhotosRefreshStatus, /// Download a photo's full content into the cache; replies with its path. - OpenPhoto { uid: String }, + OpenPhoto { + uid: String, + }, + /// Open a revision for playback in the local viewer. + OpenGalleryVideo { + uid: String, + }, + OpenGalleryImage { + uid: String, + }, + CloseGalleryVideo { + token: String, + }, + GalleryThumbnail { + uid: String, + }, + DriveGallery { + action: GalleryAction, + }, /// Add or remove Proton's `Favorite` tag on a photo. Replies with /// [`Response::Ok`]. /// @@ -214,7 +261,10 @@ pub enum Request { /// one shared with us, or one that lives only in an album — needs it /// re-encrypted for our timeline, which the SDK does not implement yet; the /// daemon reports that as an error rather than silently doing nothing. - SetPhotoFavorite { uid: String, favorite: bool }, + SetPhotoFavorite { + uid: String, + favorite: bool, + }, /// Import Google Photos **Takeout** archives into Proton Photos. /// /// `archives` are absolute paths to the export's `.zip` parts on the @@ -326,7 +376,10 @@ pub enum Request { /// Search the daemon's index of *local* (non-Drive) files on this machine. /// Independent of [`Request::Search`] so a front-end can fire both at once and /// render whichever lands first. Replies with [`Response::LocalResults`]. - SearchLocal { query: String, limit: usize }, + SearchLocal { + query: String, + limit: usize, + }, /// Search both the Drive metadata index and the local-file index in one /// round-trip. This is the preferred prompt API; the two legacy search /// requests remain available for older clients. `limit` applies to each @@ -342,30 +395,48 @@ pub enum Request { }, /// Rename a file or folder. `path` is mountpoint-relative; `new_name` is a /// single path component (no separators). Replies with [`Response::Ok`]. - Rename { path: String, new_name: String }, + Rename { + path: String, + new_name: String, + }, /// Move a file or folder into a new parent folder. Both `path` and /// `new_parent` are mountpoint-relative, or both absolute local paths; two /// absolute paths may lie in different locations (My files, an on-demand /// or a mirror synced folder), and the move is still made on Proton Drive /// without transferring content. Replies with [`Response::Ok`]. - Move { path: String, new_parent: String }, + Move { + path: String, + new_parent: String, + }, /// Copy a file or folder into a folder on Proton Drive, without /// downloading or uploading it. Both `path` and `new_parent` are /// mountpoint-relative, or absolute paths inside My files. A name already /// taken in `new_parent` gets the next free ` (n)` suffix. Replies with /// [`Response::Ok`]. - Copy { path: String, new_parent: String }, + Copy { + path: String, + new_parent: String, + }, /// Ask Proton Drive how much the folder at mountpoint-relative `path` /// holds. Replies with [`Response::FolderSize`]. - FolderSize { path: String }, + FolderSize { + path: String, + }, /// The by-uid twin of [`Request::FolderSize`]. - FolderSizeByUid { uid: String }, + FolderSizeByUid { + uid: String, + }, /// Trash a file or folder. `path` is mountpoint-relative. Replies with /// [`Response::Ok`]. - Delete { path: String }, + Delete { + path: String, + }, /// Create a new folder named `name` under the mountpoint-relative `parent`. /// Replies with [`Response::Ok`]. - CreateFolder { parent: String, name: String }, + CreateFolder { + parent: String, + name: String, + }, // There is deliberately no bytes-carrying single-file upload: it was // `UploadFile { parent, name, bytes }`, and it OOMed on anything large for // the reason described on `UploadPhoto`. `UploadPaths` covers the same case @@ -388,11 +459,16 @@ pub enum Request { /// Retune the on-disk cache's soft byte cap at runtime (`0` = unlimited) and /// persist it to config so the next mount keeps it. Replies with /// [`Response::Ok`]. - SetCacheBudget { bytes: u64 }, + SetCacheBudget { + bytes: u64, + }, /// Cap uploads and downloads at these bytes per second (`0` = no cap), /// live for running transfers, and persist both to config so the next /// mount keeps them. Replies with [`Response::Ok`]. - SetBandwidthLimits { upload: u64, download: u64 }, + SetBandwidthLimits { + upload: u64, + download: u64, + }, /// Report on the health of the metadata database and content cache: sizes, /// row counts, and — when `deep` — SQLite's own integrity check. Replies /// with [`Response::CacheReport`]. @@ -429,10 +505,14 @@ pub enum Request { ListTrash, /// Restore trashed nodes, by uid, to the folders they were trashed from. /// Replies with [`Response::Ok`]. - Restore { uids: Vec }, + Restore { + uids: Vec, + }, /// Permanently delete trashed nodes by uid. Irreversible: the content is /// gone from Proton Drive, not moved. Replies with [`Response::Ok`]. - DeleteForever { uids: Vec }, + DeleteForever { + uids: Vec, + }, /// Permanently delete everything in the trash. Irreversible. /// Replies with [`Response::Ok`]. EmptyTrash, @@ -443,7 +523,9 @@ pub enum Request { /// only notices another client's changes when its TTL lapses, so a user who /// knows the cache is stale needs a way to say so. Cheap and idempotent — /// it invalidates, it does not fetch. - Refresh { scope: RefreshScope }, + Refresh { + scope: RefreshScope, + }, // ---- locations -------------------------------------------------------- /// List every local Proton Drive location. Replies with @@ -454,26 +536,37 @@ pub enum Request { /// List the account's registered devices. Replies with [`Response::Devices`]. ListDevices, /// Rename a device by its uid. Replies with [`Response::Ok`]. - RenameDevice { uid: String, name: String }, + RenameDevice { + uid: String, + name: String, + }, /// Delete (deregister) a device by its uid. Replies with [`Response::Ok`]. - DeleteDevice { uid: String }, + DeleteDevice { + uid: String, + }, /// Adopt an existing device as this machine's, pinning its uid in /// `config.json` so a hostname change or reinstall re-attaches to it instead /// of registering a duplicate. `uid: None` clears the pin. /// Replies with [`Response::Ok`]. - AdoptDevice { uid: Option }, + AdoptDevice { + uid: Option, + }, /// Move every folder another device backs up into this machine's own /// device, as server-side moves on the main volume. The other device stays /// registered, without those folders. Sync folders here that already track /// one of them follow it to its new share. Nothing is downloaded: the moved /// folders are then offered by [`Request::ListRestorableFolders`]. /// Replies with [`Response::Ok`]. - MigrateDevice { uid: String }, + MigrateDevice { + uid: String, + }, // ---- device folder sync ---------------------------------- /// Add a local folder to this machine's device, uploading its tree and /// registering the device on first use. Replies with [`Response::Ok`]. - AddSyncFolder { local_path: String }, + AddSyncFolder { + local_path: String, + }, /// Keep a real local directory in step with an existing folder in My files. /// First sync unions one-sided files and preserves differing versions. /// Replies with [`Response::Ok`]; no device backup is created. @@ -485,42 +578,65 @@ pub enum Request { ListSyncFolders, /// Remove a synced folder by id; `delete_remote` also trashes its cloud copy. /// Replies with [`Response::Ok`]. - RemoveSyncFolder { id: i64, delete_remote: bool }, + RemoveSyncFolder { + id: i64, + delete_remote: bool, + }, /// Switch a synced folder between `mirror` and `ondemand` (Phase 3). Replies /// with [`Response::Ok`]. - SetSyncFolderMode { id: i64, mode: String }, + SetSyncFolderMode { + id: i64, + mode: String, + }, /// Pause or resume one mirror folder's reconcile, independent of the /// global pause. Persisted until resumed. Replies with [`Response::Ok`]. - SetSyncFolderPaused { id: i64, paused: bool }, + SetSyncFolderPaused { + id: i64, + paused: bool, + }, /// Forget what a mirror folder synced before, so its next pass compares /// both sides afresh: what is on one side only is copied to the other, and /// a file that differs keeps both versions. Nothing is deleted. Replies /// with [`Response::Ok`]. - ResetSyncFolder { id: i64 }, + ResetSyncFolder { + id: i64, + }, /// Force a reconcile pass: one folder by id, or all when `id` is `None`. /// Replies with [`Response::Ok`]. - SyncNow { id: Option }, + SyncNow { + id: Option, + }, /// Pause or resume syncing: queued uploads and changes stop draining and /// mirror folders stop reconciling, while reads through the mount keep /// working. `until` is the Unix second a pause ends by itself; `None` /// pauses until resumed. Ignored when resuming. Replies with /// [`Response::Ok`]. - SetSyncPaused { paused: bool, until: Option }, + SetSyncPaused { + paused: bool, + until: Option, + }, /// List the queue of uploads and changes not yet on the remote. Replies /// with [`Response::PendingOps`]. ListPendingOps, /// Retry a backed-off queued op now instead of waiting out its backoff; /// every failed op when `id` is `None`. Replies with [`Response::Ok`]. - RetryPendingOp { id: Option }, + RetryPendingOp { + id: Option, + }, /// Copy the content of a queued upload (`id` from /// [`Request::ListPendingOps`]) to `dest`, an absolute path that must not /// exist yet. The op stays queued. Replies with [`Response::Ok`]. - ExportPendingOp { id: i64, dest: String }, + ExportPendingOp { + id: i64, + dest: String, + }, /// Drop a queued change (`id` from [`Request::ListPendingOps`]) and undo /// it locally: a node made here goes, a node Drive has goes back to what /// Drive has, along with every other change queued on it. Its content is /// lost unless it was exported first. Replies with [`Response::Ok`]. - DiscardPendingOp { id: i64 }, + DiscardPendingOp { + id: i64, + }, /// List the `(sync-conflict …)` copies under My Files and in synced /// folders. Replies with /// [`Response::Conflicts`]. @@ -529,18 +645,25 @@ pub enum Request { /// copy in a synced folder). /// Everything removed goes to the Proton trash. Replies with /// [`Response::Ok`]. - ResolveConflict { path: String, keep: ConflictKeep }, + ResolveConflict { + path: String, + keep: ConflictKeep, + }, /// List the folders under this machine's device that can be synced here, /// each with a proposed local path. Replies with /// [`Response::RestorableFolders`]. ListRestorableFolders, /// Attach the given remote device folders to local paths and sync them down. /// Replies with [`Response::Ok`]. - RestoreSyncFolders { items: Vec }, + RestoreSyncFolders { + items: Vec, + }, /// [`Request::ListRestorableFolders`] for another registered device, by /// uid, so its folders can be synced down to this machine. Replies with /// [`Response::RestorableFolders`]. - ListDeviceRestorableFolders { device: String }, + ListDeviceRestorableFolders { + device: String, + }, /// [`Request::RestoreSyncFolders`] for folders under another device. A /// separate variant rather than an optional field: an older daemon that /// ignored the field would attach the folders under this machine's device @@ -571,9 +694,13 @@ pub enum Request { }, /// List the members, pending invitations and public link of the node at /// mountpoint-relative `path`. Replies with [`Response::Share`]. - ListShare { path: String }, + ListShare { + path: String, + }, /// The by-uid twin of [`Request::ListShare`]. - ListShareByUid { uid: String }, + ListShareByUid { + uid: String, + }, /// Change the role of a share entry (member or pending invitation) on the node /// at `path`. `id` and `kind` identify the entry (from [`Response::Share`]). /// Replies with [`Response::Ok`]. @@ -621,9 +748,15 @@ pub enum Request { }, /// Remove the public link `id` from the node at `path`. Replies with /// [`Response::Ok`]. - RemovePublicLink { path: String, id: String }, + RemovePublicLink { + path: String, + id: String, + }, /// The by-uid twin of [`Request::RemovePublicLink`]. - RemovePublicLinkByUid { uid: String, id: String }, + RemovePublicLinkByUid { + uid: String, + id: String, + }, /// Change the public link `id` on the node at `path`, keeping its URL. /// `role` is "viewer" or "editor", or `None` to keep the current one. /// Replies with [`Response::PublicLink`]. @@ -646,28 +779,48 @@ pub enum Request { /// invitation and every member. Each removal is attempted even if an /// earlier one fails. Replies with [`Response::Ok`], or an error naming /// what is still shared. - StopSharing { path: String }, + StopSharing { + path: String, + }, /// The by-uid twin of [`Request::StopSharing`]. - StopSharingByUid { uid: String }, + StopSharingByUid { + uid: String, + }, // ---- revisions -------------------------------------------------------- /// List the version history of the file at mountpoint-relative `path`, /// newest first. Replies with [`Response::Revisions`]. - ListRevisions { path: String }, + ListRevisions { + path: String, + }, /// The by-uid twin of [`Request::ListRevisions`]. - ListRevisionsByUid { uid: String }, + ListRevisionsByUid { + uid: String, + }, /// Make revision `revision_id` of the file at `path` current again. The /// server applies this asynchronously, so the restored content may take a /// moment to appear. Replies with [`Response::Ok`]. - RestoreRevision { path: String, revision_id: String }, + RestoreRevision { + path: String, + revision_id: String, + }, /// The by-uid twin of [`Request::RestoreRevision`]. - RestoreRevisionByUid { uid: String, revision_id: String }, + RestoreRevisionByUid { + uid: String, + revision_id: String, + }, /// Permanently delete revision `revision_id` of the file at `path`. The /// content is unrecoverable, and the server refuses to delete the revision /// that is currently active. Replies with [`Response::Ok`]. - DeleteRevision { path: String, revision_id: String }, + DeleteRevision { + path: String, + revision_id: String, + }, /// The by-uid twin of [`Request::DeleteRevision`]. - DeleteRevisionByUid { uid: String, revision_id: String }, + DeleteRevisionByUid { + uid: String, + revision_id: String, + }, /// Write revision `revision_id` of the file at `path` to the absolute local /// path `dest`, leaving the file's current content untouched. Replies with /// [`Response::Ok`]. @@ -699,15 +852,21 @@ pub enum Request { /// with [`Response::Entries`]; like [`Request::ListSharedWithMe`] the entries /// carry a `uid` and an empty `path`, since the subtree lives outside the /// mount. Lets a front-end browse into a shared folder. - ListSharedFolder { uid: String }, + ListSharedFolder { + uid: String, + }, /// Download a file shared with me into the content cache, addressed by `uid`. /// Replies with [`Response::FilePath`] so the front-end can open it with the /// default app. The by-uid twin of [`Request::OpenFile`], which can only /// address nodes inside the mount. - OpenSharedFile { uid: String }, + OpenSharedFile { + uid: String, + }, /// Leave a shared node by its `uid`, giving up my access. Replies with /// [`Response::Ok`]. - LeaveShared { uid: String }, + LeaveShared { + uid: String, + }, // ---- incoming invitations --------------------------------------------- /// List invitations addressed to me, pending accept or reject. Replies with @@ -715,9 +874,13 @@ pub enum Request { ListInvitations, /// Accept the invitation `id`, gaining access to the shared node. Replies with /// [`Response::Ok`]. - AcceptInvitation { id: String }, + AcceptInvitation { + id: String, + }, /// Reject the invitation `id`, declining access. Replies with [`Response::Ok`]. - RejectInvitation { id: String }, + RejectInvitation { + id: String, + }, // ---- bookmarks -------------------------------------------------------- /// List public links saved to my account. Replies with [`Response::Bookmarks`]. @@ -729,7 +892,9 @@ pub enum Request { password: Option, }, /// Remove a saved bookmark by its `token`. Replies with [`Response::Ok`]. - DeleteBookmark { token: String }, + DeleteBookmark { + token: String, + }, // ---- account ---------------------------------------------------------- /// Total account storage usage (used/total, all Proton products, not just @@ -743,7 +908,9 @@ pub enum Request { /// daemon performs (uploads, downloads, deletes, renames, shares, sync /// passes, …), so a front-end can show a running "what happened" feed /// without re-deriving it from anywhere. - ListActivity { limit: usize }, + ListActivity { + limit: usize, + }, // ---- push ------------------------------------------------------------- /// Keep the connection open and stream [`Event`] lines instead of one @@ -761,6 +928,10 @@ pub enum Topic { Files, /// The photos timeline or albums. Photos, + /// The visible set of gallery media changed. + GalleryVisibility, + /// A remote Gallery visibility update arrived or its state became unavailable. + GalleryVisibilitySynced, Trash, /// Shares, links, invitations and saved links, in either direction. Shares, @@ -785,9 +956,11 @@ impl Topic { /// Every topic a front-end can act on. A new subscription is told all of /// them have changed, so it catches up on whatever happened while it was /// not connected. - pub const ALL: [Topic; 10] = [ + pub const ALL: [Topic; 12] = [ Topic::Files, Topic::Photos, + Topic::GalleryVisibility, + Topic::GalleryVisibilitySynced, Topic::Trash, Topic::Shares, Topic::Devices, @@ -1831,6 +2004,56 @@ pub struct MappingProgress { pub total: usize, } +/// Actions on saved Drive folder galleries. +#[derive(Serialize, Deserialize, Debug, Clone)] +pub enum GalleryAction { + Unlock { + passphrase: String, + }, + Lock, + List { + album: Option, + offset: usize, + limit: usize, + }, + Folders { + parent: Option, + }, + Add { + uid: String, + }, + Remove { + gallery: String, + }, + Refresh, + Cover { + album: GalleryPlace, + uid: String, + }, +} + +#[derive(Serialize, Deserialize, Debug, Clone)] +pub struct GalleryPlace { + pub gallery: String, + pub album: String, +} + +#[derive(Serialize, Deserialize, Debug, Clone)] +pub struct GalleryFolder { + pub uid: String, + pub name: String, +} + +#[derive(Serialize, Deserialize, Debug, Clone)] +pub struct GalleryAlbum { + pub place: GalleryPlace, + pub folder: GalleryFolder, + pub cover: Option, + pub items: u64, + pub folders: u64, + pub hidden: bool, +} + /// One photo in a [`Request::PhotosTimeline`] page. #[derive(Serialize, Deserialize, Debug, Clone)] pub struct PhotoItem { @@ -2222,7 +2445,9 @@ pub enum Response { version: String, }, /// A human-readable success message. - Ok { message: String }, + Ok { + message: String, + }, /// Health report for the metadata database and content cache (reply to /// [`Request::CacheInspect`]). CacheReport { @@ -2252,10 +2477,14 @@ pub enum Response { integrity_running: bool, }, /// The pin registry. - Pins { pins: Vec }, + Pins { + pins: Vec, + }, /// A directory listing (reply to [`Request::ListDir`]) or a trash listing /// (reply to [`Request::ListTrash`]). - Entries { entries: Vec }, + Entries { + entries: Vec, + }, /// A page of the photos timeline. `available` is false when the account /// has no photos volume. Photos { @@ -2268,6 +2497,22 @@ pub enum Response { #[serde(default)] counts: Option<(usize, usize, usize)>, }, + GalleryFolders { + folders: Vec, + }, + GalleryPage { + albums: Vec, + items: Vec, + total: usize, + }, + GalleryVideo { + url: String, + token: String, + size: u64, + }, + GalleryThumbnail { + data: Option, + }, /// The account's photo albums (reply to [`Request::PhotoAlbums`]). /// `available` is false when the account has no photos volume, matching /// [`Response::Photos`]. @@ -2276,7 +2521,9 @@ pub enum Response { items: Vec, }, /// What the daemon is doing right now (reply to [`Request::Diagnostics`]). - Diagnostics { diagnostics: Diagnostics }, + Diagnostics { + diagnostics: Diagnostics, + }, /// How the Takeout import is doing (reply to [`Request::ImportStatus`]). /// `running` is false once it has finished, when `summary` is the final /// report; `summary` is `None` when no import has run this session. @@ -2304,10 +2551,14 @@ pub enum Response { }, /// The months the timeline spans (reply to [`Request::PhotoMonths`]), /// newest first. - PhotoMonths { months: Vec }, + PhotoMonths { + months: Vec, + }, /// The duplicate sets (reply to [`Request::PhotoDuplicates`]), newest /// first. Each set lists the copy worth keeping first. - PhotoDuplicates { sets: Vec> }, + PhotoDuplicates { + sets: Vec>, + }, /// The sets of alike shots (reply to [`Request::PhotoSimilar`]), newest /// first, each in capture order; and how far hashing has got, `None` /// once no pass is running. `uncompared` counts the shots left out @@ -2329,9 +2580,13 @@ pub enum Response { }, /// The photos of one town, each with its location (reply to /// [`Request::PlaceLocations`]). - PhotoLocations { items: Vec }, + PhotoLocations { + items: Vec, + }, /// Thumbnails for a [`Request::PhotoThumbs`] batch. - Thumbs { items: Vec }, + Thumbs { + items: Vec, + }, /// Per-node outcome of a [`Request::TrashNodes`] batch. Reported per uid /// rather than as one verdict: the server answers each node separately, and /// a front-end that removed all of them on a partial success would show a @@ -2341,7 +2596,9 @@ pub enum Response { failed: Vec, }, /// The album a [`Request::CreateAlbum`] made. - AlbumCreated { uid: String }, + AlbumCreated { + uid: String, + }, /// Outcome of a [`Request::AddToAlbum`] or [`Request::RemoveFromAlbum`], /// per photo like [`Response::Trashed`]: `changed` photos were added or /// removed, `failed` ones were not. @@ -2355,20 +2612,33 @@ pub enum Response { FileThumbsStale, /// Daemon-issued generation reserved by /// [`Request::ReserveFileThumbGeneration`]. - FileThumbGeneration { generation: u64 }, + FileThumbGeneration { + generation: u64, + }, /// Current recursive thumbnail-build progress. - ThumbnailBuild { status: ThumbnailBuildStatus }, + ThumbnailBuild { + status: ThumbnailBuildStatus, + }, /// Whether a photos-timeline refresh is still running (reply to /// [`Request::PhotosRefreshStatus`]). - PhotosRefresh { running: bool }, + PhotosRefresh { + running: bool, + }, /// An on-disk path the front-end can open (e.g. a downloaded photo). - FilePath { path: String }, + FilePath { + path: String, + }, /// Full-text search results (reply to [`Request::Search`]). - SearchResults { hits: Vec }, + SearchResults { + hits: Vec, + }, /// Local-file search results (reply to [`Request::SearchLocal`]). `indexing` /// is true while a scan of the machine is still running, so a front-end can /// say "still indexing" instead of "no matches" on a cold first launch. - LocalResults { hits: Vec, indexing: bool }, + LocalResults { + hits: Vec, + indexing: bool, + }, /// Drive and local-file search results returned together (reply to /// [`Request::SearchV2`]). `local_indexing` distinguishes a genuinely empty /// local result set from one observed while the initial scan is running. @@ -2387,17 +2657,29 @@ pub enum Response { jobs: Vec, }, /// The account's devices (reply to [`Request::ListDevices`]). - Devices { items: Vec }, + Devices { + items: Vec, + }, /// Every local Proton Drive location (reply to [`Request::ListLocations`]). - Locations { items: Vec }, + Locations { + items: Vec, + }, /// This device's synced folders (reply to [`Request::ListSyncFolders`]). - SyncFolders { items: Vec }, + SyncFolders { + items: Vec, + }, /// The upload/change queue (reply to [`Request::ListPendingOps`]). - PendingOps { items: Vec }, + PendingOps { + items: Vec, + }, /// Conflict copies (reply to [`Request::ListConflicts`]). - Conflicts { items: Vec }, + Conflicts { + items: Vec, + }, /// Folders offered for restore (reply to [`Request::ListRestorableFolders`]). - RestorableFolders { items: Vec }, + RestorableFolders { + items: Vec, + }, /// A node's share: members + pending invitations, and its public link if any /// (reply to [`Request::ListShare`]). Share { @@ -2407,28 +2689,46 @@ pub enum Response { /// A freshly created or changed public link, carrying the shareable URL /// (reply to [`Request::CreatePublicLink`] and /// [`Request::UpdatePublicLink`]). - PublicLink { link: PublicLinkInfo }, + PublicLink { + link: PublicLinkInfo, + }, /// What a folder holds on Proton Drive (reply to [`Request::FolderSize`]): /// the bytes on storage and the number of items below it, folders and /// trashed items included. - FolderSize { size: u64, items: u64 }, + FolderSize { + size: u64, + items: u64, + }, /// Invitations addressed to me (reply to [`Request::ListInvitations`]). - Invitations { items: Vec }, + Invitations { + items: Vec, + }, /// Saved public links (reply to [`Request::ListBookmarks`]). - Bookmarks { items: Vec }, + Bookmarks { + items: Vec, + }, /// Account storage usage in bytes (reply to [`Request::AccountQuota`]). /// `max_space` is the total; `used_space` what is consumed. `max_space == 0` /// means the total is unknown, which a front-end shows as a plain used figure /// rather than a full bar. - AccountQuota { max_space: i64, used_space: i64 }, + AccountQuota { + max_space: i64, + used_space: i64, + }, /// Nodes I have shared with others (reply to [`Request::ListSharedByMe`]). - SharedByMe { items: Vec }, + SharedByMe { + items: Vec, + }, /// A file's version history, newest first (reply to /// [`Request::ListRevisions`]). - Revisions { items: Vec }, + Revisions { + items: Vec, + }, /// The daemon's recent activity, newest first (reply to /// [`Request::ListActivity`]). - Activity { items: Vec }, + Activity { + items: Vec, + }, /// The request failed. `message` is for the user; `kind` is for the code — /// a front-end decides its copy and whether to offer a retry from `kind`, /// never by matching on the text. @@ -2527,6 +2827,8 @@ impl Request { pub fn read_timeout(&self) -> Duration { if self.is_poll() { POLL_READ_TIMEOUT + } else if matches!(self, Request::DriveGallery { .. }) { + Duration::from_secs(300) } else { READ_TIMEOUT } diff --git a/crates/pdfs-core/src/db/albums.rs b/crates/pdfs-core/src/db/albums.rs index f41c01c..19b76c3 100644 --- a/crates/pdfs-core/src/db/albums.rs +++ b/crates/pdfs-core/src/db/albums.rs @@ -163,33 +163,47 @@ impl Db { album_uid: &str, offset: usize, limit: usize, + ) -> Result> { + self.album_photos_page_visible(album_uid, offset, limit, "[]") + } + + pub fn album_photos_page_visible( + &self, + album_uid: &str, + offset: usize, + limit: usize, + excluded: &str, ) -> Result> { let conn = self.read(); let mut stmt = conn.prepare( "SELECT uid, capture_time, name, ratio, thumb_state, kind FROM album_photos - WHERE album_uid = ?1 ORDER BY seq LIMIT ?2 OFFSET ?3", + WHERE album_uid = ?1 AND uid NOT IN (SELECT value FROM json_each(?4)) + ORDER BY seq LIMIT ?2 OFFSET ?3", )?; let rows = stmt - .query_map(params![album_uid, limit as i64, offset as i64], |r| { - Ok(StoredPhoto { - uid: r.get(0)?, - capture_time: r.get(1)?, - name: r.get(2)?, - ratio: r.get(3)?, - thumb_state: r.get(4)?, - kind: crate::control::PhotoKind::from_i64(r.get(5)?), - // Album rows have no favorite state of their own: an album - // photo on someone else's volume is not in our timeline, and - // favouriting one is not supported yet anyway. - favorite: false, - // Nor are album rows grouped: an album is a list the user - // made, and it shows exactly what they put in it. - group_size: 1, - has_raw: false, - // Album rows carry no location. - place_id: None, - }) - })? + .query_map( + params![album_uid, limit as i64, offset as i64, excluded], + |r| { + Ok(StoredPhoto { + uid: r.get(0)?, + capture_time: r.get(1)?, + name: r.get(2)?, + ratio: r.get(3)?, + thumb_state: r.get(4)?, + kind: crate::control::PhotoKind::from_i64(r.get(5)?), + // Album rows have no favorite state of their own: an album + // photo on someone else's volume is not in our timeline, and + // favouriting one is not supported yet anyway. + favorite: false, + // Nor are album rows grouped: an album is a list the user + // made, and it shows exactly what they put in it. + group_size: 1, + has_raw: false, + // Album rows carry no location. + place_id: None, + }) + }, + )? .collect::>()?; Ok(rows) } diff --git a/crates/pdfs-core/src/db/photos.rs b/crates/pdfs-core/src/db/photos.rs index d2562c7..dda2c27 100644 --- a/crates/pdfs-core/src/db/photos.rs +++ b/crates/pdfs-core/src/db/photos.rs @@ -513,24 +513,42 @@ impl Db { range: Option<(i64, i64)>, favorites: bool, not_in_album: bool, + ) -> Result> { + self.photos_page_visible(offset, limit, kind, range, favorites, not_in_album, "[]") + } + + #[allow(clippy::too_many_arguments)] + pub fn photos_page_visible( + &self, + offset: usize, + limit: usize, + kind: Option, + range: Option<(i64, i64)>, + favorites: bool, + not_in_album: bool, + excluded: &str, ) -> Result> { let conn = self.read(); // Built up so any combination of the optional filters is one indexed // query rather than a statement per case. let mut sql = String::from(PHOTO_SELECT); - let mut binds: Vec = Vec::new(); + let mut binds: Vec = Vec::new(); let mut conds: Vec = Vec::new(); + if excluded != "[]" { + binds.push(excluded.to_owned().into()); + conds.push("p.uid NOT IN (SELECT value FROM json_each(?1))".to_owned()); + } if kind != Some(crate::control::PhotoKind::Raw) { conds.push("p.uid = COALESCE(p.group_key, p.uid)".to_string()); } if let Some(k) = kind { - binds.push(k.as_i64()); + binds.push((k.as_i64()).into()); conds.push(format!("p.kind = ?{}", binds.len())); } if let Some((from, to)) = range { - binds.push(from); + binds.push((from).into()); conds.push(format!("p.capture_time >= ?{}", binds.len())); - binds.push(to); + binds.push((to).into()); conds.push(format!("p.capture_time < ?{}", binds.len())); } if favorites { @@ -549,9 +567,9 @@ impl Db { sql.push_str(" WHERE "); sql.push_str(&conds.join(" AND ")); } - binds.push(limit as i64); + binds.push((limit as i64).into()); let limit_pos = binds.len(); - binds.push(offset as i64); + binds.push((offset as i64).into()); let offset_pos = binds.len(); sql.push_str(&format!( " ORDER BY p.seq LIMIT ?{limit_pos} OFFSET ?{offset_pos}" @@ -580,6 +598,25 @@ impl Db { Ok(rows) } + /// Include associated files so a public preview cannot reveal a hidden + /// RAW, JPEG or Live Photo through another part of the same shot. + pub fn photo_group_members_for(&self, uids: &HashSet) -> Result> { + if uids.is_empty() { + return Ok(HashSet::new()); + } + let ids = serde_json::to_string(uids).expect("file identifiers serialize"); + let conn = self.read(); + let mut query = conn.prepare( + "SELECT uid FROM photos WHERE COALESCE(group_key, uid) IN ( + SELECT COALESCE(group_key, uid) FROM photos + WHERE uid IN (SELECT value FROM json_each(?1)) + )", + )?; + Ok(query + .query_map([ids], |row| row.get(0))? + .collect::>()?) + } + /// The whole persisted timeline, in stored order — every file, not one row /// per group. Only for whole-library passes (the photo re-date); the gallery /// pages with [`Db::photos_page`]. @@ -601,27 +638,33 @@ impl Db { pub fn photos_months( &self, kind: Option, + ) -> Result> { + self.photos_months_visible(kind, "[]") + } + + pub fn photos_months_visible( + &self, + kind: Option, + excluded: &str, ) -> Result> { let conn = self.read(); // The scrubber has to agree with the page it scrubs, so it counts what // the page shows: groups everywhere except on the Raw tab. - let (filter, binds): (&str, Vec) = match kind { - Some(crate::control::PhotoKind::Raw) => (" WHERE kind = 2", Vec::new()), - Some(k) => ( - " WHERE uid = COALESCE(group_key, uid) AND kind = ?1", - vec![k.as_i64()], - ), - None => (" WHERE uid = COALESCE(group_key, uid)", Vec::new()), + let filter = match kind { + Some(crate::control::PhotoKind::Raw) => "kind = ?2", + Some(_) => "uid = COALESCE(group_key, uid) AND kind = ?2", + 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, \ CAST(strftime('%m', capture_time, 'unixepoch', 'localtime') AS INTEGER) AS m, \ COUNT(*) \ - FROM photos{filter} GROUP BY y, m ORDER BY y DESC, m DESC" + FROM photos WHERE {filter} AND uid NOT IN (SELECT value FROM json_each(?1)) + GROUP BY y, m ORDER BY y DESC, m DESC" ); let mut stmt = conn.prepare(&sql)?; let rows = stmt - .query_map(rusqlite::params_from_iter(binds), |r| { + .query_map(params![excluded, kind.map(|kind| kind.as_i64())], |r| { Ok(( r.get::<_, i32>(0)?, r.get::<_, i32>(1)?, @@ -637,6 +680,15 @@ impl Db { /// pick the date, and its own year is left out, because today's photos are /// what the timeline already opens on. One row per group, like the timeline. pub fn photos_on_this_day(&self, today: i64, limit: usize) -> Result> { + self.photos_on_this_day_visible(today, limit, "[]") + } + + pub fn photos_on_this_day_visible( + &self, + today: i64, + limit: usize, + excluded: &str, + ) -> Result> { let conn = self.read(); let sql = format!( "{PHOTO_SELECT} WHERE p.uid = COALESCE(p.group_key, p.uid) \ @@ -644,11 +696,12 @@ impl Db { = strftime('%m-%d', ?1, 'unixepoch', 'localtime') \ AND strftime('%Y', p.capture_time, 'unixepoch', 'localtime') \ < strftime('%Y', ?1, 'unixepoch', 'localtime') \ + AND p.uid NOT IN (SELECT value FROM json_each(?3)) ORDER BY p.seq LIMIT ?2" ); let mut stmt = conn.prepare(&sql)?; let rows = stmt - .query_map(params![today, limit as i64], stored_photo)? + .query_map(params![today, limit as i64, excluded], stored_photo)? .collect::>()?; Ok(rows) } @@ -657,6 +710,10 @@ impl Db { /// cover, most photographed first. Counted per group, like the timeline; /// photos without a location, or taken far from any town, are in none. pub fn photo_places(&self) -> Result> { + self.photo_places_visible("[]") + } + + pub fn photo_places_visible(&self, excluded: &str) -> Result> { let rows: Vec<(u32, usize, String)> = { let conn = self.read(); // SQLite fills the bare `uid` from the row `MIN(seq)` picked, which @@ -664,9 +721,10 @@ impl Db { let mut stmt = conn.prepare( "SELECT place_id, COUNT(*), uid, MIN(seq) FROM photos \ WHERE uid = COALESCE(group_key, uid) AND place_id IS NOT NULL \ + AND uid NOT IN (SELECT value FROM json_each(?1)) GROUP BY place_id ORDER BY COUNT(*) DESC, MIN(seq)", )?; - stmt.query_map([], |r| { + stmt.query_map([excluded], |r| { Ok((r.get(0)?, r.get::<_, i64>(1)? as usize, r.get(2)?)) })? .collect::>()? @@ -695,15 +753,29 @@ impl Db { id: u32, offset: usize, limit: usize, + ) -> Result> { + self.photos_at_place_visible(id, offset, limit, "[]") + } + + pub fn photos_at_place_visible( + &self, + id: u32, + offset: usize, + limit: usize, + excluded: &str, ) -> Result> { let conn = self.read(); let sql = format!( - "{PHOTO_SELECT} WHERE p.uid = COALESCE(p.group_key, p.uid) AND p.place_id = ?1 \ + "{PHOTO_SELECT} WHERE p.uid = COALESCE(p.group_key, p.uid) AND p.place_id = ?1 + AND p.uid NOT IN (SELECT value FROM json_each(?4)) ORDER BY p.seq LIMIT ?2 OFFSET ?3" ); let mut stmt = conn.prepare(&sql)?; let rows = stmt - .query_map(params![id, limit as i64, offset as i64], stored_photo)? + .query_map( + params![id, limit as i64, offset as i64, excluded], + stored_photo, + )? .collect::>()?; Ok(rows) } @@ -884,6 +956,10 @@ impl Db { /// Per-tab counts for the Photos page subtitle: `(photos, videos, raw)`. pub fn photos_counts(&self) -> Result<(usize, usize, usize)> { + self.photos_counts_visible("[]") + } + + pub fn photos_counts_visible(&self, excluded: &str) -> Result<(usize, usize, usize)> { use crate::control::PhotoKind; let conn = self.read(); // Photos and Videos count groups — one shot is one entry, however many @@ -891,9 +967,12 @@ impl Db { // them individually. let mut stmt = conn.prepare( "SELECT kind, COUNT(*) FROM photos \ - WHERE uid = COALESCE(group_key, uid) OR kind = 2 GROUP BY kind", + WHERE (uid = COALESCE(group_key, uid) OR kind = 2) + AND uid NOT IN (SELECT value FROM json_each(?1)) GROUP BY kind", )?; - let rows = stmt.query_map([], |r| Ok((r.get::<_, i64>(0)?, r.get::<_, i64>(1)?)))?; + let rows = stmt.query_map([excluded], |r| { + Ok((r.get::<_, i64>(0)?, r.get::<_, i64>(1)?)) + })?; let (mut photos, mut videos, mut raw) = (0usize, 0usize, 0usize); for row in rows { let (kind, n) = row?; diff --git a/crates/pdfs-core/src/db/tests.rs b/crates/pdfs-core/src/db/tests.rs index 68a941e..da34435 100644 --- a/crates/pdfs-core/src/db/tests.rs +++ b/crates/pdfs-core/src/db/tests.rs @@ -337,6 +337,10 @@ fn places_group_photos_by_the_nearest_town() { .map(|p| p.uid) .collect(); assert_eq!(berlin, ["b2", "b1-jpeg"]); + let visible = db.photo_places_visible(r#"["b2","p1"]"#).unwrap(); + assert_eq!(visible.len(), 1); + assert_eq!(visible[0].count, 1); + assert_eq!(visible[0].cover.uid, "b1-jpeg"); } /// A town's photos come with where each was taken, one per RAW+JPEG shot. @@ -7165,6 +7169,29 @@ fn a_raw_and_its_jpeg_are_one_entry_in_the_grid() { ["jpeg", "raw"] ); assert_eq!(db.photos_group("alone").unwrap().len(), 1); + + let hidden = db + .photo_group_members_for(&["raw".to_owned()].into_iter().collect()) + .unwrap(); + assert_eq!( + hidden, + ["raw".to_owned(), "jpeg".to_owned()].into_iter().collect() + ); + let excluded = serde_json::to_string(&hidden).unwrap(); + assert_eq!(db.photos_counts_visible(&excluded).unwrap(), (1, 0, 0)); + let months = db.photos_months_visible(None, &excluded).unwrap(); + assert_eq!(months.len(), 1); + assert_eq!(months[0].2, 1); + let public = db + .photos_page_visible(0, 1, None, None, false, false, &excluded) + .unwrap(); + assert_eq!( + public + .iter() + .map(|photo| photo.uid.as_str()) + .collect::>(), + ["alone"] + ); } /// Pixel names the two files of one raw capture after the role each plays, so diff --git a/crates/pdfs-fuse/Cargo.toml b/crates/pdfs-fuse/Cargo.toml index 6a36a0e..28c1d0a 100644 --- a/crates/pdfs-fuse/Cargo.toml +++ b/crates/pdfs-fuse/Cargo.toml @@ -14,6 +14,13 @@ pdfs-core.workspace = true zip.workspace = true sha1.workspace = true proton-drive-rs.workspace = true +pg-app.workspace = true +pg-core.workspace = true +hyper = { version = "1", features = ["http1", "server"] } +hyper-util = { version = "0.1", features = ["tokio"] } +http-body-util = "0.1" +getrandom = "0.4" +zeroize.workspace = true futures.workspace = true async-trait.workspace = true tokio.workspace = true diff --git a/crates/pdfs-fuse/src/albums.rs b/crates/pdfs-fuse/src/albums.rs index b5c7b1b..1c24e08 100644 --- a/crates/pdfs-fuse/src/albums.rs +++ b/crates/pdfs-fuse/src/albums.rs @@ -154,6 +154,7 @@ impl Core { album: &NodeUid, offset: usize, limit: usize, + excluded: &str, ) -> CoreResult> { let key = album.to_string(); let stamp = format!("{ALBUM_SYNCED_PREFIX}{key}"); @@ -172,7 +173,7 @@ impl Core { let page = self .db - .album_photos_page(&key, offset, limit) + .album_photos_page_visible(&key, offset, limit, excluded) .map_err(CoreError::from)?; Ok(page.into_iter().map(|p| self.photo_item(p)).collect()) } diff --git a/crates/pdfs-fuse/src/control.rs b/crates/pdfs-fuse/src/control.rs index 0db3cf0..3878879 100644 --- a/crates/pdfs-fuse/src/control.rs +++ b/crates/pdfs-fuse/src/control.rs @@ -396,6 +396,11 @@ fn touched_topics(request: &CtlRequest) -> &'static [Topic] { use CtlRequest as R; match request { R::Pin { .. } | R::Unpin { .. } => &[Topic::Files], + R::DriveGallery { + action: + pdfs_core::control::GalleryAction::Lock + | pdfs_core::control::GalleryAction::Unlock { .. }, + } => &[Topic::GalleryVisibility], R::CreateAlbum { .. } | R::RenameAlbum { .. } | R::DeleteAlbum { .. } @@ -552,6 +557,33 @@ 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)); + let visibility = if matches!( + &request, + Ok(CtlRequest::PhotosTimeline { .. } + | CtlRequest::PhotoDuplicates + | CtlRequest::PhotoSimilar + | CtlRequest::PhotoPlaces + | CtlRequest::PlacePhotos { .. } + | CtlRequest::PlaceLocations { .. } + | CtlRequest::PhotosOnThisDay { .. } + | CtlRequest::PhotoGroup { .. } + | CtlRequest::PhotoAlbums + | CtlRequest::AlbumPhotos { .. } + | CtlRequest::PhotoMonths { .. } + | CtlRequest::PhotoThumbs { .. } + | CtlRequest::OpenGalleryImage { .. } + | CtlRequest::OpenPhoto { .. }) + ) { + core.gallery_visibility() + } else { + Ok(std::sync::Arc::default()) + }; + let visibility = match visibility { + Ok(visibility) => visibility, + Err(error) => return write_response(stream, CtlResponse::error(error)), + }; + let excluded = + serde_json::to_string(&visibility.media).expect("a set of file identifiers serializes"); let response = match request { Ok(CtlRequest::Status) => status_response(core, username, mountpoint), Ok(CtlRequest::Subscribe) => { @@ -668,11 +700,12 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U range, favorites, not_in_album, + &excluded, ) { Ok(Some(items)) => CtlResponse::Photos { available: true, items, - counts: core.db.photos_counts().ok(), + counts: core.db.photos_counts_visible(&excluded).ok(), }, Ok(None) => CtlResponse::Photos { available: false, @@ -693,7 +726,7 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U }, Err(e) => CtlResponse::error(e), }, - Ok(CtlRequest::PhotoPlaces) => match core.photo_places() { + Ok(CtlRequest::PhotoPlaces) => match core.photo_places(&excluded) { Ok(items) => CtlResponse::Places { items, mapping: core.timeline_progress(), @@ -701,7 +734,7 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U Err(e) => CtlResponse::error(e), }, Ok(CtlRequest::PlacePhotos { id, offset, limit }) => { - match core.place_photos(id, offset, clamp_limit(limit)) { + match core.place_photos(id, offset, clamp_limit(limit), &excluded) { Ok(items) => CtlResponse::Photos { available: true, items, @@ -715,7 +748,7 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U Err(e) => CtlResponse::error(e), }, Ok(CtlRequest::PhotosOnThisDay { limit }) => { - match core.photos_on_this_day(clamp_limit(limit)) { + match core.photos_on_this_day(clamp_limit(limit), &excluded) { Ok(items) => CtlResponse::Photos { available: true, items, @@ -760,7 +793,10 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U // An album page is a timeline page as far as the front-end is // concerned, so it comes back in the same reply — with `counts` // unset, which describe the whole timeline rather than this album. - Some(album) => match core.album_photos(&album, offset, clamp_limit(limit)) { + Some(album) => match visibility + .permits(&uid) + .and_then(|()| core.album_photos(&album, offset, clamp_limit(limit), &excluded)) + { Ok(items) => CtlResponse::Photos { available: true, items, @@ -802,17 +838,23 @@ 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(kind) { - 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::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::PhotoThumbs { uids }) => { - let parsed: Vec = uids.iter().filter_map(|u| parse_uid(u)).collect(); + let parsed: Vec = uids + .iter() + .filter(|uid| !visibility.media.contains(*uid)) + .filter_map(|u| parse_uid(u)) + .collect(); CtlResponse::Thumbs { items: core.photo_thumbs(&parsed), } @@ -862,7 +904,7 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U running: core.timeline_refreshing(), }, Ok(CtlRequest::OpenPhoto { uid }) => match parse_uid(&uid) { - Some(u) => match core.open_photo(&u) { + Some(u) => match visibility.permits(&uid).and_then(|()| core.open_photo(&u)) { Ok(p) => CtlResponse::FilePath { path: p.display().to_string(), }, @@ -870,6 +912,27 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U }, None => CtlResponse::error(CoreError::invalid(format!("bad uid: {uid}"))), }, + Ok(CtlRequest::DriveGallery { action }) => core + .drive_gallery(action) + .unwrap_or_else(CtlResponse::error), + Ok(CtlRequest::OpenGalleryVideo { uid }) => core + .open_gallery_video(&uid) + .unwrap_or_else(CtlResponse::error), + Ok(CtlRequest::OpenGalleryImage { uid }) => match visibility + .permits(&uid) + .and_then(|()| core.open_shared_file(&uid)) + { + Ok(path) => CtlResponse::FilePath { + path: path.display().to_string(), + }, + Err(error) => CtlResponse::error(error), + }, + Ok(CtlRequest::CloseGalleryVideo { token }) => core + .close_gallery_video(&token) + .unwrap_or_else(CtlResponse::error), + Ok(CtlRequest::GalleryThumbnail { uid }) => core + .gallery_thumbnail(&uid) + .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 // `ImportStatus` rather than answered inline. @@ -1929,9 +1992,14 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U // The request did not parse: the caller sent something malformed. Err(e) => CtlResponse::error(CoreError::invalid(format!("bad request: {e}"))), }; + let response = filter_gallery_response(response, &visibility); if !touched.is_empty() && !matches!(response, CtlResponse::Error { .. }) { core.events.publish(touched); } + write_response(stream, response); +} + +fn write_response(mut stream: UnixStream, response: CtlResponse) { let mut out = match serde_json::to_vec(&response) { Ok(v) => v, Err(e) => { @@ -1940,10 +2008,40 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U } }; out.push(b'\n'); - let mut stream = stream; let _ = stream.write_all(&out); } +fn filter_gallery_response( + mut response: CtlResponse, + visibility: &super::gallery::Visibility, +) -> CtlResponse { + let visible = |item: &pdfs_core::control::PhotoItem| !visibility.media.contains(&item.uid); + match &mut response { + CtlResponse::Photos { items, .. } => items.retain(visible), + CtlResponse::Albums { items, .. } => { + items.retain(|item| !visibility.albums.contains(&item.uid)); + for album in items { + if album + .cover_uid + .as_ref() + .is_some_and(|uid| visibility.media.contains(uid)) + { + album.cover_uid = None; + } + } + } + CtlResponse::PhotoDuplicates { sets } | CtlResponse::PhotoSimilar { sets, .. } => { + for set in sets.iter_mut() { + set.retain(visible); + } + sets.retain(|set| set.len() > 1); + } + CtlResponse::PhotoLocations { items } => items.retain(|located| visible(&located.photo)), + _ => {} + } + response +} + /// Listen on the control socket, serving one command per connection, each on its /// own thread. Runs on its own thread; returns only if the listener itself fails. /// diff --git a/crates/pdfs-fuse/src/gallery.rs b/crates/pdfs-fuse/src/gallery.rs new file mode 100644 index 0000000..6ffaa1f --- /dev/null +++ b/crates/pdfs-fuse/src/gallery.rs @@ -0,0 +1,431 @@ +//! Host Proton Gallery's account and catalog services in the Drive daemon. + +mod video; + +use std::collections::HashSet; +use std::path::PathBuf; +use std::sync::{ + Arc, + atomic::{AtomicBool, Ordering}, +}; +use std::time::{Duration, Instant}; + +use pdfs_core::control::{ + GalleryAction, GalleryAlbum, GalleryFolder, GalleryPlace, PhotoItem, PhotoKind, Response, +}; +use pdfs_core::{CoreError, CoreResult}; +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 super::{Core, NodeUid, parse_uid}; + +pub(super) struct Gallery { + root: PathBuf, + session: ProtonApiSession, + cancel: CancellationToken, + app: OnceCell, + checked: Mutex>)>>, + unlocked: AtomicBool, + video: video::Server, +} + +#[derive(Default, PartialEq, Eq)] +pub(super) struct Visibility { + pub(super) media: HashSet, + pub(super) albums: HashSet, +} + +impl Visibility { + pub(super) fn permits(&self, uid: &str) -> CoreResult<()> { + if self.media.contains(uid) || self.albums.contains(uid) { + return Err(CoreError::invalid("Unlock hidden albums to open this item")); + } + Ok(()) + } +} + +impl Gallery { + pub(super) fn new(root: PathBuf, session: ProtonApiSession) -> Self { + Self { + root, + session, + cancel: CancellationToken::new(), + app: OnceCell::new(), + checked: Mutex::new(None), + unlocked: AtomicBool::new(false), + video: video::Server::default(), + } + } + + pub(super) fn cancel(&self) { + self.cancel.cancel(); + self.video.close_all(); + } + + async fn app(&self, core: &Core) -> CoreResult<&App> { + self.app + .get_or_try_init(|| async { + App::open_hosted( + self.root.clone(), + self.session.clone(), + core.client.clone(), + self.cancel.child_token(), + ) + .await + .map_err(gallery_error) + }) + .await + } + + async fn ensure_visibility( + &self, + core: &Core, + app: &App, + force: bool, + ) -> CoreResult> { + if self.cancel.is_cancelled() { + return Err(CoreError::remote("The Gallery session expired")); + } + let mut checked = self.checked.lock().await; + if !force + && let Some((instant, Some(visibility))) = checked.as_ref() + && instant.elapsed() < Duration::from_secs(60) + { + return Ok(visibility.clone()); + } + 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()) + .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)) + } + .await; + let current = visibility.as_ref().ok(); + if previous.is_some_and(|previous| previous != current) { + self.video.close_all(); + core.events + .publish(&[pdfs_core::control::Topic::GalleryVisibilitySynced]); + } + *checked = Some((Instant::now(), current.cloned())); + visibility + } + + fn account(&self) -> CoreResult { + pg_core::model::AccountId::new(self.session.user_id().as_str()).map_err(gallery_error) + } + + fn lock(&self) { + self.unlocked.store(false, Ordering::SeqCst); + self.video.close_all(); + } + + fn unlocked(&self) -> bool { + self.unlocked.load(Ordering::SeqCst) + } + + pub(super) async fn poll(self: Arc, core: Core) { + loop { + tokio::select! { + biased; + _ = self.cancel.cancelled() => break, + _ = tokio::time::sleep(Duration::from_secs(60)) => {} + } + if let Some(app) = self.app.get() { + let _ = self.ensure_visibility(&core, app, false).await; + } + } + } + + fn asset(&self, uid: &NodeUid) -> CoreResult { + Ok(AssetKey { + account: self.account()?, + volume: pg_core::model::VolumeId::new(uid.volume_id.as_str()).map_err(gallery_error)?, + node: pg_core::model::NodeId::new(uid.link_id.as_str()).map_err(gallery_error)?, + }) + } +} + +fn gallery_error(error: impl std::fmt::Display) -> CoreError { + CoreError::remote(error.to_string()) +} + +fn uid(value: &str) -> CoreResult { + parse_uid(value).ok_or_else(|| CoreError::invalid("Invalid gallery node")) +} + +fn done() -> Response { + Response::Ok { + message: "Gallery updated".into(), + } +} + +fn asset_uid(asset: &AssetKey) -> String { + NodeUid::new(asset.volume.as_str().into(), asset.node.as_str().into()).to_string() +} + +impl Core { + pub(super) fn gallery_visibility(&self) -> CoreResult> { + if self.gallery.is_none() { + return Ok(Arc::default()); + } + 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 + }) + }) + } + + fn gallery_host(&self) -> CoreResult<&Gallery> { + self.gallery + .as_deref() + .filter(|gallery| !gallery.cancel.is_cancelled()) + .ok_or_else(|| CoreError::remote("The Gallery session is unavailable")) + } + + pub(super) fn drive_gallery(&self, action: GalleryAction) -> CoreResult { + let gallery = self.gallery_host()?; + let action = match action { + GalleryAction::Unlock { passphrase } => { + let passphrase = zeroize::Zeroizing::new(passphrase); + pdfs_core::auth::unlock_gallery(gallery.session.username(), &passphrase) + .map_err(gallery_error)?; + gallery.unlocked.store(true, Ordering::SeqCst); + return Ok(done()); + } + GalleryAction::Lock => { + gallery.lock(); + return Ok(done()); + } + other => other, + }; + self.rt.block_on(async { + let app = gallery.app(self).await?; + 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, + } => { + 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, + }) + } + GalleryAction::Folders { parent } => { + let list = app + .browse_drive_folders(parent.as_deref().map(uid).transpose()?) + .await + .map_err(gallery_error)?; + Ok(Response::GalleryFolders { + folders: list + .children + .into_iter() + .map(|folder| GalleryFolder { + uid: folder.uid.to_string(), + name: folder.name, + }) + .collect(), + }) + } + GalleryAction::Add { uid: node } => { + app.add_drive_folder(uid(&node)?) + .await + .map_err(gallery_error)?; + gallery.ensure_visibility(self, app, true).await?; + Ok(done()) + } + GalleryAction::Remove { gallery: id } => { + app.forget_drive_gallery(SourceId::new(id).map_err(gallery_error)?) + .await + .map_err(gallery_error)?; + gallery.ensure_visibility(self, app, true).await?; + Ok(done()) + } + GalleryAction::Refresh => { + for album in app.drive_albums(None, true).await.map_err(gallery_error)? { + let root = NodeUid::new( + album.source.volume.as_str().into(), + album.source.root.as_str().into(), + ); + app.scan_drive_folder(root).await.map_err(gallery_error)?; + } + gallery.ensure_visibility(self, app, true).await?; + Ok(done()) + } + 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 mut settings = app + .catalog + .album_settings(id.clone()) + .await + .map_err(gallery_error)?; + settings.cover = Some(gallery.asset(&uid(&node)?)?); + app.catalog + .set_album_settings(id, settings) + .await + .map_err(gallery_error)?; + gallery.ensure_visibility(self, app, true).await?; + Ok(done()) + } + } + }) + } + + pub(super) fn open_gallery_video(&self, node: &str) -> 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() { + visibility.permits(node)?; + } + let stream = app + .stream_video(&gallery.asset(&uid)?) + .await + .map_err(gallery_error)?; + gallery.video.open(stream, &gallery.cancel).await + }) + } + + pub(super) fn close_gallery_video(&self, token: &str) -> CoreResult { + self.gallery_host()?.video.close(token); + Ok(done()) + } + + pub(super) fn gallery_thumbnail(&self, node: &str) -> 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() { + visibility.permits(node)?; + } + let data = app + .thumbnail(&asset) + .await + .map_err(gallery_error)? + .map(|bytes| STANDARD.encode(bytes)); + Ok(Response::GalleryThumbnail { data }) + }) + } +} diff --git a/crates/pdfs-fuse/src/gallery/video.rs b/crates/pdfs-fuse/src/gallery/video.rs new file mode 100644 index 0000000..35a9a4f --- /dev/null +++ b/crates/pdfs-fuse/src/gallery/video.rs @@ -0,0 +1,205 @@ +use std::{collections::VecDeque, io, sync::Arc, time::Duration}; + +use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD}; +use http_body_util::{BodyExt, Empty, StreamBody, combinators::UnsyncBoxBody}; +use hyper::{ + Method, Request, Response, StatusCode, + body::{Bytes, Frame, Incoming}, + header, + server::conn::http1, + service::service_fn, +}; +use hyper_util::rt::TokioIo; +use pdfs_core::{CoreResult, control::Response as ControlResponse}; +use pg_app::video::VideoStream; +use pg_core::CancellationToken; +use tokio::net::TcpListener; + +type Body = UnsyncBoxBody; + +const LEASE: Duration = Duration::from_secs(4 * 60 * 60); +const MAX_STREAMS: usize = 4; +const CHUNK: u32 = 256 * 1024; + +#[derive(Default)] +pub(super) struct Server { + active: parking_lot::Mutex>, +} + +impl Server { + pub(super) fn close(&self, token: &str) { + let mut active = self.active.lock(); + if let Some(index) = active.iter().position(|(id, _)| id == token) + && let Some((_, cancel)) = active.remove(index) + { + cancel.cancel(); + } + } + + pub(super) fn close_all(&self) { + for (_, cancel) in self.active.lock().drain(..) { + cancel.cancel(); + } + } + + pub(super) async fn open( + &self, + stream: Arc, + account: &CancellationToken, + ) -> CoreResult { + let listener = TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0)) + .await + .map_err(super::gallery_error)?; + let address = listener.local_addr().map_err(super::gallery_error)?; + let mut nonce = [0; 32]; + getrandom::fill(&mut nonce).map_err(super::gallery_error)?; + let token = URL_SAFE_NO_PAD.encode(nonce); + let path: Arc = format!("/{token}").into(); + let cancel = account.child_token(); + { + let mut active = self.active.lock(); + active.retain(|(_, cancel)| !cancel.is_cancelled()); + if active.len() >= MAX_STREAMS + && let Some((_, oldest)) = active.pop_front() + { + oldest.cancel(); + } + active.push_back((token.clone(), cancel.clone())); + } + let size = stream.length(); + tokio::spawn(async move { + let mut connections = tokio::task::JoinSet::new(); + let lifetime = tokio::time::sleep(LEASE); + tokio::pin!(lifetime); + loop { + tokio::select! { + biased; + _ = cancel.cancelled() => break, + _ = &mut lifetime => break, + _ = connections.join_next(), if !connections.is_empty() => {}, + incoming = listener.accept(), if connections.len() < 8 => { + let Ok((socket, _)) = incoming else { break }; + let stream = stream.clone(); + let path = path.clone(); + connections.spawn(async move { + let service = service_fn(move |request| reply(request, stream.clone(), path.clone())); + let _ = http1::Builder::new() + .timer(hyper_util::rt::TokioTimer::new()) + .header_read_timeout(Duration::from_secs(10)) + .keep_alive(false) + .serve_connection(TokioIo::new(socket), service).await; + }); + } + } + } + stream.stop(); + cancel.cancel(); + connections.abort_all(); + }); + Ok(ControlResponse::GalleryVideo { + url: format!("http://{address}/{token}"), + token, + size, + }) + } +} + +fn range(value: Option<&str>, size: u64) -> Option<(u64, u64)> { + let Some(value) = value else { + return Some((0, size)); + }; + let (first, last) = value.strip_prefix("bytes=")?.split_once('-')?; + if first.is_empty() { + let suffix = last.parse::().ok()?.min(size); + return (suffix > 0).then_some((size - suffix, size)); + } + let start = first.parse::().ok()?; + let end = if last.is_empty() { + size + } else { + last.parse::().ok()?.saturating_add(1).min(size) + }; + (start < end).then_some((start, end)) +} + +fn empty() -> Body { + Empty::new().map_err(|never| match never {}).boxed_unsync() +} + +async fn reply( + request: Request, + stream: Arc, + path: Arc, +) -> Result, hyper::http::Error> { + let response = Response::builder().header(header::CACHE_CONTROL, "no-store"); + if request + .uri() + .path_and_query() + .is_none_or(|actual| actual.as_str() != path.as_ref()) + { + return response.status(StatusCode::NOT_FOUND).body(empty()); + } + if !matches!(*request.method(), Method::HEAD | Method::GET) { + return response + .status(StatusCode::METHOD_NOT_ALLOWED) + .body(empty()); + } + let size = stream.length(); + let requested = request.headers().get(header::RANGE); + let parsed = match requested { + Some(value) => value + .to_str() + .ok() + .and_then(|value| range(Some(value), size)), + None => range(None, size), + }; + let Some((start, end)) = parsed else { + return response + .status(StatusCode::RANGE_NOT_SATISFIABLE) + .header(header::CONTENT_RANGE, format!("bytes */{size}")) + .body(empty()); + }; + let response = response + .header(header::ACCEPT_RANGES, "bytes") + .header(header::CONTENT_LENGTH, end - start) + .header(header::CONTENT_TYPE, "application/octet-stream"); + let response = if requested.is_some() { + response.status(StatusCode::PARTIAL_CONTENT).header( + header::CONTENT_RANGE, + format!("bytes {start}-{}/{size}", end - 1), + ) + } else { + response + }; + if request.method() == Method::HEAD { + return response.body(empty()); + } + let body = futures::stream::try_unfold((stream, start), move |(stream, at)| async move { + if at == end { + return Ok(None); + } + let read = (end - at).min(u64::from(CHUNK)) as u32; + let bytes = stream.read(at, read).await.map_err(io::Error::other)?; + if bytes.is_empty() { + return Err(io::Error::from(io::ErrorKind::UnexpectedEof)); + } + let next = at + bytes.len() as u64; + Ok(Some((Frame::data(Bytes::from(bytes)), (stream, next)))) + }); + response.body(BodyExt::boxed_unsync(StreamBody::new(body))) +} + +#[cfg(test)] +mod tests { + use super::range; + + #[test] + fn resolves_seek_ranges_and_rejects_invalid_ranges() { + assert_eq!(range(None, 10), Some((0, 10))); + assert_eq!(range(Some("bytes=3-5"), 10), Some((3, 6))); + assert_eq!(range(Some("bytes=9-"), 10), Some((9, 10))); + assert_eq!(range(Some("bytes=-3"), 10), Some((7, 10))); + assert_eq!(range(Some("bytes=10-"), 10), None); + assert_eq!(range(Some("bytes=0-1,3-4"), 10), None); + } +} diff --git a/crates/pdfs-fuse/src/lib.rs b/crates/pdfs-fuse/src/lib.rs index ee73dd4..5418b08 100644 --- a/crates/pdfs-fuse/src/lib.rs +++ b/crates/pdfs-fuse/src/lib.rs @@ -91,6 +91,7 @@ mod drive; use drive::{DriveApi, RevisionRead}; mod events; mod filesystem; +mod gallery; mod keeper; mod link; pub use filesystem::ProtonFs; @@ -499,6 +500,7 @@ struct Core { /// The concrete client, for what [`DriveApi`] does not cover: sharing, /// Photos, devices, invitations and public links. client: ProtonDriveClient, + gallery: Option>, rt: tokio::runtime::Handle, /// The daemon's My Files root. Forked on-demand sessions retain this value /// so ownership checks never mistake their own mount root for account scope. diff --git a/crates/pdfs-fuse/src/link.rs b/crates/pdfs-fuse/src/link.rs index 517d175..7b65347 100644 --- a/crates/pdfs-fuse/src/link.rs +++ b/crates/pdfs-fuse/src/link.rs @@ -232,6 +232,9 @@ impl Core { /// Unless the keyring holds a newer session than the refused one: then /// the mount ends, for the daemon to mount again on that one. pub(crate) fn mark_session_expired(&self, what: &str, error: &dyn std::fmt::Display) { + if let Some(gallery) = &self.gallery { + gallery.cancel(); + } if self.link.resume_stored.load(Ordering::Relaxed) { return self.mark_offline(what, error); } diff --git a/crates/pdfs-fuse/src/mount.rs b/crates/pdfs-fuse/src/mount.rs index 1051512..a989f02 100644 --- a/crates/pdfs-fuse/src/mount.rs +++ b/crates/pdfs-fuse/src/mount.rs @@ -310,6 +310,7 @@ enum Start { pub struct MountOptions { /// Proton account the session belongs to, for display and per-user paths. pub username: String, + pub gallery_session: Option, /// What the background conflict sweep may do. See `docs/BUGS.md` B71. pub sweep_mode: SweepMode, /// Upload and download caps in bytes per second (`0` = no cap). @@ -456,6 +457,7 @@ pub(crate) fn mount_with( ) -> std::io::Result { let MountOptions { username, + gallery_session, sweep_mode, upload_limit, download_limit, @@ -480,9 +482,13 @@ pub(crate) fn mount_with( let (sync_tx, sync_rx) = std::sync::mpsc::channel::(); let paused_until = pause::load_paused_until(&db); + let gallery_dir = control_socket.with_file_name("gallery-catalog"); + let gallery = + gallery_session.map(|session| Arc::new(super::gallery::Gallery::new(gallery_dir, session))); let core = Core { drive, client, + gallery, rt: rt.clone(), maintenance: Arc::new(Mutex::new(Default::default())), primary_root_uid: root.uid.clone(), @@ -636,6 +642,9 @@ pub(crate) fn mount_with( // Keep the launcher prompt's "This computer" index fresh. Its own thread: // the walk is I/O-heavy and must never sit in front of a FUSE callback. if matches!(host, Host::Daemon) { + if let Some(gallery) = &core.gallery { + rt.spawn(gallery.clone().poll(core.clone())); + } let db = core.db.clone(); let indexing = core.indexing.clone(); let transfers = core.transfers.clone(); @@ -954,6 +963,9 @@ fn keep_or_abandon( /// Signal every worker to stop, then join them up to [`WORKER_JOIN_DEADLINE`]. fn halt_workers(core: &Core, control_socket: &Path, workers: Vec>) { core.shutdown.stop(); + if let Some(gallery) = &core.gallery { + gallery.cancel(); + } core.wake_drain(); let _ = core.sync_tx.send(sync::SyncMsg::Stop); // Connect while the socket still exists — that is the whole point of the diff --git a/crates/pdfs-fuse/src/photos.rs b/crates/pdfs-fuse/src/photos.rs index 9d055d3..b8d1e16 100644 --- a/crates/pdfs-fuse/src/photos.rs +++ b/crates/pdfs-fuse/src/photos.rs @@ -1175,6 +1175,7 @@ impl Core { .unwrap_or_default() } + #[allow(clippy::too_many_arguments)] pub(crate) fn photos_timeline( &self, offset: usize, @@ -1183,6 +1184,7 @@ impl Core { range: Option<(i64, i64)>, favorites: bool, not_in_album: bool, + excluded: &str, ) -> CoreResult>> { let count = self.db.photos_count().map_err(CoreError::from)?; if count == 0 { @@ -1208,7 +1210,15 @@ impl Core { let page = self .db - .photos_page(offset, limit, kind, range, favorites, not_in_album) + .photos_page_visible( + offset, + limit, + kind, + range, + favorites, + not_in_album, + excluded, + ) .map_err(CoreError::from)?; Ok(Some(page.into_iter().map(|p| self.photo_item(p)).collect())) } @@ -1365,8 +1375,11 @@ impl Core { /// The towns the photos were taken in, as wire items. A town the bundled /// table no longer knows (the stored id came from an older table) is left /// out rather than shown without a name. - pub(crate) fn photo_places(&self) -> CoreResult> { - let places = self.db.photo_places().map_err(CoreError::from)?; + pub(crate) fn photo_places(&self, excluded: &str) -> CoreResult> { + let places = self + .db + .photo_places_visible(excluded) + .map_err(CoreError::from)?; Ok(places .into_iter() .filter_map(|place| { @@ -1390,10 +1403,11 @@ impl Core { id: u32, offset: usize, limit: usize, + excluded: &str, ) -> CoreResult> { let photos = self .db - .photos_at_place(id, offset, limit) + .photos_at_place_visible(id, offset, limit, excluded) .map_err(CoreError::from)?; Ok(photos.into_iter().map(|p| self.photo_item(p)).collect()) } @@ -1417,13 +1431,17 @@ impl Core { /// Photos taken on today's date in earlier years, as wire items. Served /// from the stored timeline only: the strip is a nicety, not worth a wait /// on the network, and the timeline's own load keeps that store fresh. - pub(crate) fn photos_on_this_day(&self, limit: usize) -> CoreResult> { + pub(crate) fn photos_on_this_day( + &self, + limit: usize, + excluded: &str, + ) -> CoreResult> { let now = std::time::SystemTime::now() .duration_since(std::time::UNIX_EPOCH) .map_or(0, |d| d.as_secs() as i64); let photos = self .db - .photos_on_this_day(now, limit) + .photos_on_this_day_visible(now, limit, excluded) .map_err(CoreError::from)?; Ok(photos.into_iter().map(|p| self.photo_item(p)).collect()) } diff --git a/crates/pdfs-fuse/src/sim/daemon.rs b/crates/pdfs-fuse/src/sim/daemon.rs index 3a1cd9c..c6579e6 100644 --- a/crates/pdfs-fuse/src/sim/daemon.rs +++ b/crates/pdfs-fuse/src/sim/daemon.rs @@ -89,6 +89,7 @@ impl Daemon { db, MountOptions { username: "sim".into(), + gallery_session: None, sweep_mode: AppConfig::default().resolved_conflict_sweep(), upload_limit: 0, download_limit: 0, diff --git a/crates/pdfs-gui/Cargo.toml b/crates/pdfs-gui/Cargo.toml index d876395..ddee5ac 100644 --- a/crates/pdfs-gui/Cargo.toml +++ b/crates/pdfs-gui/Cargo.toml @@ -22,6 +22,8 @@ name = "pdfs-prompt" path = "src/prompt.rs" [dependencies] +pg-core.workspace = true +base64.workspace = true pdfs-core.workspace = true tracing.workspace = true tracing-subscriber.workspace = true diff --git a/crates/pdfs-gui/resources/style.css b/crates/pdfs-gui/resources/style.css index 0a242f9..ddbf362 100644 --- a/crates/pdfs-gui/resources/style.css +++ b/crates/pdfs-gui/resources/style.css @@ -123,6 +123,7 @@ scale.browser-status-meter trough { min-width: 140px; min-height: 6px; } .album-cover { border-radius: 16px; background: alpha(currentColor, 0.06); box-shadow: 0 4px 16px rgba(0, 0, 0, 0.32); transition: box-shadow 180ms ease; } .album-card:hover .album-cover { box-shadow: 0 10px 26px rgba(0, 0, 0, 0.5); } .album-card:hover .photo-thumb { transform: scale(1.05); } +listview.drive-gallery-rows > row { padding: 0; } .view-switch button, .view-switch toggle { padding-left: 12px; padding-right: 12px; } /* Shared with Me: what a share lets me do, as a tinted pill beside the name. */ diff --git a/crates/pdfs-gui/src/app/events.rs b/crates/pdfs-gui/src/app/events.rs index 65e33f1..6cb1219 100644 --- a/crates/pdfs-gui/src/app/events.rs +++ b/crates/pdfs-gui/src/app/events.rs @@ -133,6 +133,32 @@ 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) { + for window in gtk4::Window::list_toplevels() { + if let Ok(window) = window.downcast::() + && window.has_css_class("photo-viewer-window") + { + window.close(); + } + } + 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.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("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)) { diff --git a/crates/pdfs-gui/src/app/main.rs b/crates/pdfs-gui/src/app/main.rs index d3233a3..55d237f 100644 --- a/crates/pdfs-gui/src/app/main.rs +++ b/crates/pdfs-gui/src/app/main.rs @@ -160,6 +160,7 @@ struct Ui { pub(crate) details: DetailsState, pub(crate) trash: TrashState, pub(crate) gallery: GalleryState, + drive_galleries: RefCell>, pub(crate) shared: SharedState, pub(crate) shared_by_me: SharedByMeState, pub(crate) devices: DevicesState, @@ -459,6 +460,7 @@ fn build_window(app: &adw::Application) { nav: split.clone(), narrow: Cell::new(false), file_thumbs: FileThumbnailState::new(), + drive_galleries: RefCell::default(), login: login_widgets, status: StatusState { status_inflight: Cell::new(false), @@ -760,6 +762,10 @@ 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, diff --git a/crates/pdfs-gui/src/app/pages/drive_galleries.rs b/crates/pdfs-gui/src/app/pages/drive_galleries.rs new file mode 100644 index 0000000..00fa925 --- /dev/null +++ b/crates/pdfs-gui/src/app/pages/drive_galleries.rs @@ -0,0 +1,822 @@ +use crate::*; +use base64::{Engine, engine::general_purpose::STANDARD}; +use pdfs_core::control::{GalleryAction, GalleryAlbum, GalleryFolder, GalleryPlace}; + +const PAGE: usize = 150; + +#[derive(Clone)] +enum Row { + Albums(Vec, i32), + Heading(String), + Media(Vec<(PhotoItem, (i32, i32))>), + Folder(GalleryFolder), +} + +struct Place { + album: GalleryAlbum, + parent_offset: f64, +} + +pub(crate) struct Browser { + ui: Rc, + window: glib::WeakRef, + rows: gio::ListStore, + scroll: gtk4::ScrolledWindow, + title: adw::WindowTitle, + status: gtk4::Label, + choose: gtk4::Button, + trail: RefCell>, + chooser: RefCell>>, + cover: RefCell>, + albums: RefCell>, + items: RefCell>, + width: Cell, + generation: Cell, + total: Cell, + loading: Cell, + unlocked: Cell, + thumbnail_slots: tokio::sync::Semaphore, +} + +impl Browser { + pub(crate) fn close(&self) { + if let Some(window) = self.window.upgrade() { + window.close(); + } + } + + 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); + } + } + + fn current(&self) -> Option { + self.trail.borrow().last().map(|place| place.album.clone()) + } + + fn next_request(&self) -> u64 { + let next = self.generation.get().wrapping_add(1); + self.generation.set(next); + next + } + + fn load(self: &Rc, offset: usize, restore: f64) { + self.choose.set_visible(false); + 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(); + 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(), + ); + self.status.set_label(&gettext("Loading…")); + let rx = spawn_request( + self.ui.dirs.control_socket(), + Request::DriveGallery { + action: GalleryAction::List { + album: album.map(|a| a.place), + offset, + limit: PAGE, + }, + }, + ); + let browser = self.clone(); + glib::spawn_future_local(async move { + let result = rx.recv().await; + if browser.generation.get() != generation { + return; + } + browser.loading.set(false); + match result { + Ok(Ok(Response::GalleryPage { + albums, + items, + total, + })) => { + if offset == 0 { + *browser.albums.borrow_mut() = albums; + } + browser.items.borrow_mut().extend(items); + browser.total.set(total); + let empty = total == 0 && browser.albums.borrow().is_empty(); + 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.") + } 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)); + } + } + Ok(Ok(Response::Error { message, .. })) => browser.status.set_label(&message), + _ => browser + .status + .set_label(&gettext("Couldn't reach Proton Drive.")), + } + }); + } + + fn browse_folders(self: &Rc) { + let Some(trail) = self.chooser.borrow().clone() else { + return; + }; + let generation = self.next_request(); + let parent = trail.last().map(|folder| folder.uid.clone()); + self.choose.set_visible(parent.is_some()); + self.title.set_title(&gettext("Choose a Drive Folder")); + self.rows.remove_all(); + let rx = spawn_request( + self.ui.dirs.control_socket(), + Request::DriveGallery { + action: GalleryAction::Folders { parent }, + }, + ); + let browser = self.clone(); + glib::spawn_future_local(async move { + let result = rx.recv().await; + if browser.generation.get() != generation { + return; + } + match result { + Ok(Ok(Response::GalleryFolders { folders })) => { + 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))); + } + } + Ok(Ok(Response::Error { message, .. })) => browser.status.set_label(&message), + _ => browser + .status + .set_label(&gettext("Couldn't reach Proton Drive.")), + } + }); + } + + 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 generation = self.next_request(); + self.status.set_label(&gettext("Updating gallery…")); + let rx = spawn_request( + self.ui.dirs.control_socket(), + Request::DriveGallery { action }, + ); + let browser = self.clone(); + glib::spawn_future_local(async move { + let result = rx.recv().await; + if browser.generation.get() != generation { + if unlock && matches!(result, Ok(Ok(Response::Ok { .. }))) { + browser.lock(); + } + return; + } + match result { + Ok(Ok(Response::Ok { .. })) => { + if unlock || lock { + browser.unlocked.set(unlock); + } + browser.chooser.borrow_mut().take(); + browser.load(0, 0.0); + } + Ok(Ok(Response::Error { message, .. })) => browser.status.set_label(&message), + _ => browser + .status + .set_label(&gettext("Couldn't reach Proton Drive.")), + } + }); + } + + fn lock(&self) { + let _ = spawn_request( + self.ui.dirs.control_socket(), + Request::DriveGallery { + action: GalleryAction::Lock, + }, + ); + } + + fn prompt_unlock(self: &Rc) { + let Some(parent) = self.window.upgrade() else { + return; + }; + let dialog = adw::AlertDialog::builder() + .heading(gettext("Unlock Hidden Albums")) + .body(gettext("Enter your Gallery passphrase. On first use, choose one with at least 12 characters.")) + .build(); + let password = gtk4::PasswordEntry::builder().show_peek_icon(true).build(); + dialog.set_extra_child(Some(&password)); + dialog.add_response("cancel", &gettext("Cancel")); + dialog.add_response("unlock", &gettext("Unlock")); + dialog.set_response_appearance("unlock", adw::ResponseAppearance::Suggested); + dialog.set_default_response(Some("unlock")); + let browser = Rc::downgrade(self); + dialog.connect_response(None, move |_, response| { + let passphrase = password.text().to_string(); + password.set_text(""); + if response == "unlock" + && let Some(browser) = browser.upgrade() + { + browser.change(GalleryAction::Unlock { passphrase }); + } + }); + dialog.present(Some(&parent)); + } + + 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(); + } else { + self.chooser.borrow_mut().take(); + self.load(0, 0.0); + } + return; + } + let at_target = self + .cover + .borrow() + .as_ref() + .zip(self.current()) + .is_some_and(|(target, current)| target.album == current.place.album); + if at_target { + self.cover.borrow_mut().take(); + self.status.set_label(""); + return; + } + let previous = self.trail.borrow_mut().pop(); + if let Some(previous) = previous { + self.load(0, previous.parent_offset); + } else if let Some(window) = self.window.upgrade() { + window.close(); + } + } + + fn rebuild(&self) { + if self.chooser.borrow().is_some() { + return; + } + let width = (self.width.get() - 24).max(240); + let columns = ((width + 8) / 216).max(1); + let card = (width - 8 * (columns - 1)) / columns; + let mut rows = Vec::new(); + for albums in self.albums.borrow().chunks(columns as usize) { + rows.push(BoxedAnyObject::new(Row::Albums(albums.to_vec(), card))); + } + let items = self.items.borrow(); + let period = |item: &PhotoItem| { + glib::DateTime::from_unix_local(item.capture_time) + .ok() + .and_then(|date| date.format("%B %Y").ok()) + .map(|value| value.to_string()) + .unwrap_or_else(|| gettext("Unknown date")) + }; + for section in items.chunk_by(|a, b| period(a) == period(b)) { + rows.push(BoxedAnyObject::new(Row::Heading(period(§ion[0])))); + let ratios: Vec<_> = section + .iter() + .map(|item| item.ratio.unwrap_or(1.0)) + .collect(); + let mut items = section.iter(); + for sizes in super::photos::plan_justified(&ratios, width, 180) { + rows.push(BoxedAnyObject::new(Row::Media( + items.by_ref().cloned().zip(sizes).collect(), + ))); + } + } + self.rows.splice(0, self.rows.n_items(), &rows); + } + + fn preview(self: &Rc, item: PhotoItem) { + let video = item.kind == PhotoKind::Video; + let request = if video { + Request::OpenGalleryVideo { uid: item.uid } + } else { + Request::OpenGalleryImage { uid: item.uid } + }; + let reply = spawn_request(self.ui.dirs.control_socket(), request); + let browser = self.clone(); + let generation = self.generation.get(); + glib::spawn_future_local(async move { + let result = reply.recv().await; + let close = |token| { + let _ = spawn_request( + browser.ui.dirs.control_socket(), + Request::CloseGalleryVideo { token }, + ); + }; + let parent = browser + .window + .upgrade() + .filter(|_| 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) + .title(item.name.unwrap_or_else(|| gettext("Preview"))) + .default_width(850) + .default_height(600) + .build(); + preview.add_css_class("photo-viewer-window"); + 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)); + let socket = browser.ui.dirs.control_socket(); + preview.connect_close_request(move |_| { + player.set_media_stream(gtk4::MediaStream::NONE); + let _ = spawn_request( + socket.clone(), + Request::CloseGalleryVideo { + token: token.clone(), + }, + ); + glib::Propagation::Proceed + }); + } + Ok(Ok(Response::FilePath { path })) => { + let picture = gtk4::Picture::for_filename(path); + preview.set_child(Some(&picture)); + } + Ok(Ok(Response::Error { message, .. })) => { + browser.status.set_label(&message); + return; + } + _ => { + browser + .status + .set_label(&gettext("Couldn't open the file.")); + return; + } + } + preview.present(); + }); + } +} + +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")); + let choose = gtk4::Button::with_label(&gettext("Add This Folder")); + choose.set_visible(false); + header.pack_end(&add); + header.pack_end(&choose); + let more = gtk4::Button::from_icon_name("view-more-symbolic"); + more.set_tooltip_text(Some(&gettext("Gallery Options"))); + header.pack_end(&more); + let rows = gio::ListStore::new::(); + let factory = gtk4::SignalListItemFactory::new(); + let list = gtk4::ListView::builder() + .model(>k4::NoSelection::new(Some(rows.clone()))) + .factory(&factory) + .build(); + list.add_css_class("drive-gallery-rows"); + let scroll = gtk4::ScrolledWindow::builder() + .vexpand(true) + .hscrollbar_policy(gtk4::PolicyType::External) + .child(&list) + .build(); + let status = gtk4::Label::new(None); + status.set_wrap(true); + let content = gtk4::Box::new(gtk4::Orientation::Vertical, 0); + content.append(&header); + content.append(&status); + content.append(&scroll); + window.set_child(Some(&content)); + let browser = Rc::new(Browser { + ui: ui.clone(), + window: window.downgrade(), + rows, + scroll: scroll.clone(), + title, + status, + choose: choose.clone(), + trail: RefCell::new(Vec::new()), + chooser: RefCell::new(None), + cover: RefCell::new(None), + albums: RefCell::new(Vec::new()), + items: RefCell::new(Vec::new()), + width: Cell::new(0), + generation: Cell::new(0), + total: Cell::new(0), + loading: Cell::new(false), + unlocked: Cell::new(false), + thumbnail_slots: tokio::sync::Semaphore::new(8), + }); + *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); + factory.connect_bind(move |_, item| { + let Some(browser) = weak.upgrade() else { + return; + }; + let Some(list_item) = item.downcast_ref::() else { + return; + }; + let Some(data) = list_item.item().and_downcast::() else { + return; + }; + let row = data.borrow::(); + let line = gtk4::Box::new(gtk4::Orientation::Horizontal, 8); + line.set_margin_start(12); + line.set_margin_end(12); + line.set_margin_bottom(8); + match &*row { + Row::Heading(label) => { + let label = gtk4::Label::new(Some(label)); + label.add_css_class("heading"); + line.append(&label); + } + Row::Folder(folder) => { + let button = gtk4::Button::with_label(&folder.name); + button.set_hexpand(true); + button.connect_clicked({ + let weak = Rc::downgrade(&browser); + let folder = folder.clone(); + move |_| { + if let Some(browser) = weak.upgrade() { + if let Some(trail) = browser.chooser.borrow_mut().as_mut() { + trail.push(folder.clone()); + } + browser.browse_folders(); + } + } + }); + line.append(&button); + } + 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, + ); + button.connect_clicked({ + let weak = Rc::downgrade(&browser); + let album = album.clone(); + move |_| { + if let Some(browser) = weak.upgrade() { + browser.trail.borrow_mut().push(Place { + album: album.clone(), + parent_offset: browser.scroll.vadjustment().value(), + }); + browser.load(0, 0.0); + } + } + }); + line.append(&button); + } + } + Row::Media(items) => { + line.set_spacing(super::photos::TILE_GAP); + for (item, (width, height)) in items { + let button = tile( + &browser, + item.name.as_deref().unwrap_or(""), + Some(&item.uid), + *width, + *height, + None, + item.kind == PhotoKind::Video, + ); + button.connect_clicked({ + let weak = Rc::downgrade(&browser); + let item = item.clone(); + move |_| { + if let Some(browser) = weak.upgrade() { + let cover = browser.cover.borrow_mut().take(); + if let Some(album) = cover { + browser.change(GalleryAction::Cover { + album, + uid: item.uid.clone(), + }); + } else { + browser.preview(item.clone()); + } + } + } + }); + line.append(&button); + } + } + } + list_item.set_child(Some(&line)); + }); + factory.connect_unbind(|_, item| { + if let Some(item) = item.downcast_ref::() { + 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(); + move |_| { + if let Some(browser) = weak.upgrade() { + choose.set_visible(true); + *browser.chooser.borrow_mut() = Some(Vec::new()); + browser.browse_folders(); + } + } + }); + choose.connect_clicked({ + let weak = Rc::downgrade(&browser); + move |button| { + if let Some(browser) = weak.upgrade() { + let uid = browser + .chooser + .borrow() + .as_ref() + .and_then(|trail| trail.last()) + .map(|f| f.uid.clone()); + if let Some(uid) = uid { + button.set_visible(false); + browser.change(GalleryAction::Add { uid }); + } + } + } + }); + more.connect_clicked({ + let weak = Rc::downgrade(&browser); + move |button| { + if let Some(browser) = weak.upgrade() { + let mut menu = ActionMenu::new(); + menu.item(&gettext("Refresh"), { + let browser = browser.clone(); + move || browser.change(GalleryAction::Refresh) + }); + if browser.unlocked.get() { + menu.item(&gettext("Lock Hidden Albums"), { + let browser = browser.clone(); + move || browser.change(GalleryAction::Lock) + }); + } else { + menu.item(&gettext("Unlock Hidden Albums"), { + let browser = browser.clone(); + move || browser.prompt_unlock() + }); + } + if let Some(album) = browser.current() { + menu.item(&gettext("Choose Cover"), { + let browser = browser.clone(); + let place = album.place.clone(); + move || { + *browser.cover.borrow_mut() = Some(place.clone()); + browser.status.set_label(&gettext( + "Choose a photo or video from this album or a subfolder.", + )); + } + }); + 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"), { + let browser = browser.clone(); + move || { + browser.trail.borrow_mut().clear(); + browser.change(GalleryAction::Remove { + gallery: album.place.gallery.clone(), + }); + } + }); + } + } + menu.popup_at( + button, + f64::from(button.width()) / 2.0, + f64::from(button.height()), + ); + } + } + }); + scroll.vadjustment().connect_value_changed({ + let weak = Rc::downgrade(&browser); + move |adj| { + if let Some(browser) = weak.upgrade() { + let offset = browser.items.borrow().len(); + if browser.chooser.borrow().is_none() + && !browser.loading.get() + && offset < browser.total.get() + && adj.value() + adj.page_size() + 800.0 >= adj.upper() + { + browser.load(offset, 0.0); + } + } + } + }); + scroll.add_tick_callback({ + let weak = Rc::downgrade(&browser); + move |scroll, _| { + let Some(browser) = weak.upgrade() else { + return glib::ControlFlow::Break; + }; + let width = scroll.width(); + if width > 0 && browser.width.replace(width) != width { + browser.rebuild(); + } + 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>, + video: 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); + icon.add_css_class("dim-label"); + cover.add_overlay(&icon); + 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 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(); + 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() { + return; + } + let request = spawn_request( + browser.ui.dirs.control_socket(), + Request::GalleryThumbnail { uid }, + ); + 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)) + { + picture.set_paintable(Some(&texture)); + if let Some(icon) = icon.upgrade() { + icon.set_visible(false); + } + } + }); + } + button +} diff --git a/crates/pdfs-gui/src/app/pages/login.rs b/crates/pdfs-gui/src/app/pages/login.rs index e7b0dc8..b8c4122 100644 --- a/crates/pdfs-gui/src/app/pages/login.rs +++ b/crates/pdfs-gui/src/app/pages/login.rs @@ -683,6 +683,10 @@ pub(crate) fn sign_out(ui: &Rc) { ), &gettext("Sign Out"), move || { + let galleries = ui.drive_galleries.borrow().upgrade(); + if let Some(galleries) = galleries { + galleries.close(); + } // systemctl and the keyring both block, so run them on a worker. let ui = ui.clone(); glib::spawn_future_local(async move { diff --git a/crates/pdfs-gui/src/app/pages/mod.rs b/crates/pdfs-gui/src/app/pages/mod.rs index fd1a8bf..0de5bc0 100644 --- a/crates/pdfs-gui/src/app/pages/mod.rs +++ b/crates/pdfs-gui/src/app/pages/mod.rs @@ -3,6 +3,7 @@ pub(crate) mod activity_text; pub(crate) mod albums; pub(crate) mod browser; pub(crate) mod devices; +pub(crate) mod drive_galleries; pub(crate) mod duplicates; pub(crate) mod locations; pub(crate) mod login; diff --git a/crates/pdfs-gui/src/app/pages/photo_viewer.rs b/crates/pdfs-gui/src/app/pages/photo_viewer.rs index 793c136..c857bde 100644 --- a/crates/pdfs-gui/src/app/pages/photo_viewer.rs +++ b/crates/pdfs-gui/src/app/pages/photo_viewer.rs @@ -31,6 +31,8 @@ pub(crate) struct Viewer { pub(crate) scroller: gtk4::ScrolledWindow, pub(crate) picture: gtk4::Picture, pub(crate) video: gtk4::Video, + video_token: RefCell>, + load_generation: Cell, pub(crate) spinner: Spinner, pub(crate) status: gtk4::Label, pub(crate) title: gtk4::Label, @@ -272,12 +274,14 @@ fn viewer_item(ui: &Rc, viewer: &Rc, uid: &str) -> Option /// full-size file, and swap it in — plus its EXIF — when it lands. A video /// plays in place once its file is down. pub(crate) fn load_photo(ui: &Rc, viewer: &Rc, uid: String) { + let generation = viewer.load_generation.get().wrapping_add(1); + viewer.load_generation.set(generation); viewer.spinner.set_visible(true); viewer.status.set_visible(false); viewer.loading.set(true); *viewer.path.borrow_mut() = None; clear_info(viewer); - stop_video(viewer); + stop_video(ui, viewer); viewer.media.set_visible_child_name("photo"); sync_strip(viewer); reset_zoom(viewer); @@ -302,17 +306,22 @@ pub(crate) fn load_photo(ui: &Rc, viewer: &Rc, uid: String) { None => viewer.picture.set_paintable(gtk4::gdk::Paintable::NONE), } - let rx = spawn_request( - ui.dirs.control_socket(), - Request::OpenPhoto { uid: uid.clone() }, - ); + let request = if is_video { + Request::OpenGalleryVideo { uid: uid.clone() } + } else { + Request::OpenPhoto { uid: uid.clone() } + }; + let rx = spawn_request(ui.dirs.control_socket(), request); let viewer = viewer.clone(); let ui = ui.clone(); glib::spawn_future_local(async move { let result = rx.recv().await; // The user may have moved on while this was in flight; that photo's own // request owns the viewer now. - if *viewer.uid.borrow() != uid { + if viewer.load_generation.get() != generation { + if let Ok(Ok(Response::GalleryVideo { token, .. })) = result { + close_video(&ui, token); + } return; } viewer.spinner.set_visible(false); @@ -326,6 +335,14 @@ pub(crate) fn load_photo(ui: &Rc, viewer: &Rc, uid: String) { viewer.status.set_visible(true); }; let path = match result { + Ok(Ok(Response::GalleryVideo { url, token, size })) => { + *viewer.video_token.borrow_mut() = Some(token); + viewer.video.set_file(Some(&gio::File::for_uri(&url))); + viewer.media.set_visible_child_name("video"); + sync_strip(&viewer); + show_info(&viewer, Some(size), ExifInfo::default()); + return; + } Ok(Ok(Response::FilePath { path })) => path, Ok(Ok(Response::Error { message, .. })) => return fail(&message), Ok(Ok(_)) => return fail(&gettext("Unexpected reply from the Proton Drive service.")), @@ -481,8 +498,18 @@ fn next_slide(ui: &Rc, viewer: &Rc) { /// Stop whatever the player was playing, so stepping off a video (or closing /// the lightbox) doesn't leave its sound running. -fn stop_video(viewer: &Rc) { +fn close_video(ui: &Ui, token: String) { + let _reply = spawn_request( + ui.dirs.control_socket(), + Request::CloseGalleryVideo { token }, + ); +} + +fn stop_video(ui: &Ui, viewer: &Rc) { viewer.video.set_media_stream(gtk4::MediaStream::NONE); + if let Some(token) = viewer.video_token.borrow_mut().take() { + close_video(ui, token); + } } /// Warm the cache with the photo `delta` steps away, so stepping there is @@ -1473,6 +1500,8 @@ pub(crate) fn open_photo_viewer(ui: &Rc, initial_uid: String) -> gtk4::Windo scroller: scroller.clone(), picture: picture.clone(), video, + video_token: RefCell::new(None), + load_generation: Cell::new(0), spinner, status: status_label, title: title_label, @@ -1700,7 +1729,10 @@ pub(crate) fn open_photo_viewer(ui: &Rc, initial_uid: String) -> gtk4::Windo } if let Some(viewer) = keep.borrow_mut().take() { reveal_photo(&ui_close, &viewer.uid.borrow()); - stop_video(&viewer); + viewer + .load_generation + .set(viewer.load_generation.get().wrapping_add(1)); + stop_video(&ui_close, &viewer); disarm_slide(&viewer); if let Some(source) = viewer.chrome_source.borrow_mut().take() { source.remove(); @@ -1952,7 +1984,7 @@ fn open_viewer_menu(ui: &Rc, viewer: &Rc) { } menu.section(); // These need the full-size file, which may still be downloading. - if viewer.path.borrow().is_some() { + if viewer.path.borrow().is_some() || viewer.video_token.borrow().is_some() { let still = viewer.media.visible_child_name().as_deref() == Some("photo"); if still { // Translators: menu item that puts the photo on the clipboard as an image. @@ -1999,17 +2031,45 @@ fn open_viewer_menu(ui: &Rc, viewer: &Rc) { }); } -fn save_shown_photo(_ui: &Rc, viewer: &Rc) { - if let Some(path) = viewer.path.borrow().as_deref() { - let name = viewer.name.borrow(); - save_photo_to_disk(viewer, path, name.as_deref().unwrap_or("photo")); - } +fn save_shown_photo(ui: &Rc, viewer: &Rc) { + with_viewer_file(ui, viewer, |viewer, path, name| { + save_photo_to_disk(viewer, path, name.unwrap_or("photo")) + }); } -fn open_shown_photo(_ui: &Rc, viewer: &Rc) { +fn open_shown_photo(ui: &Rc, viewer: &Rc) { + with_viewer_file(ui, viewer, |viewer, path, name| { + open_with(&viewer.window, path, name) + }); +} + +fn with_viewer_file( + ui: &Rc, + viewer: &Rc, + use_file: impl FnOnce(&Rc, &str, Option<&str>) + 'static, +) { + let name = viewer.name.borrow().clone(); if let Some(path) = viewer.path.borrow().as_deref() { - open_with(&viewer.window, path, viewer.name.borrow().as_deref()); + use_file(viewer, path, name.as_deref()); + return; } + if viewer.video_token.borrow().is_none() { + return; + } + let uid = viewer.uid.borrow().clone(); + let viewer = viewer.clone(); + let rx = spawn_request(ui.dirs.control_socket(), Request::OpenPhoto { uid }); + glib::spawn_future_local(async move { + match rx.recv().await { + Ok(Ok(Response::FilePath { path })) => use_file(&viewer, &path, name.as_deref()), + Ok(Ok(Response::Error { message, .. })) => { + viewer.toasts.add_toast(adw::Toast::new(&message)) + } + _ => viewer + .toasts + .add_toast(adw::Toast::new(&gettext("Couldn't open the file."))), + } + }); } fn add_shown_photo_to_album(ui: &Rc, viewer: &Rc) { diff --git a/crates/pdfs-gui/src/app/pages/photos.rs b/crates/pdfs-gui/src/app/pages/photos.rs index 5699eda..3b39453 100644 --- a/crates/pdfs-gui/src/app/pages/photos.rs +++ b/crates/pdfs-gui/src/app/pages/photos.rs @@ -467,6 +467,7 @@ impl GalleryRow { /// The widgets [`build_gallery_page`] hands back to [`build_window`]. pub(crate) struct GalleryWidgets { + pub(crate) drive_galleries: 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, @@ -940,10 +941,13 @@ 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, model, groups, content, @@ -2203,16 +2207,15 @@ pub(crate) fn justify_rows(ui: &Rc, photos: &[PhotoItem], width: i32) -> Vec /// The narrowest and the widest shape a tile may take, as width over height. /// A panorama at its own shape would be a ribbon, and a screenshot of a phone /// a thread; past these the thumbnail is cropped to fit. -pub(crate) const TILE_RATIO_MIN: f64 = 0.5; -pub(crate) const TILE_RATIO_MAX: f64 = 2.5; +#[cfg(test)] +const TILE_RATIO_MIN: f64 = 0.5; +#[cfg(test)] +const TILE_RATIO_MAX: f64 = 2.5; /// The shape a photo's tile takes: its own, clamped, or square while the /// daemon has not seen a thumbnail of it yet. pub(crate) fn tile_ratio(ratio: Option) -> f64 { - ratio - .filter(|ratio| ratio.is_finite() && *ratio > 0.0) - .unwrap_or(1.0) - .clamp(TILE_RATIO_MIN, TILE_RATIO_MAX) + pg_core::grid::tile_ratio(ratio.unwrap_or(1.0)) } /// The justified layout math: tiles of the given shapes, in order, broken into @@ -2225,64 +2228,33 @@ pub(crate) fn tile_ratio(ratio: Option) -> f64 { /// two photos from one day stay two photos at the target height, not two /// photos as tall as the window. pub(crate) fn plan_justified(ratios: &[f64], width: i32, target: i32) -> Vec> { - let width = width.max(1); - let target = f64::from(target.clamp(ROW_MIN, ROW_MAX)); - let gap = f64::from(TILE_GAP); - // The height that makes `ratios` span the width exactly. - let fit = |ratios: &[f64]| { - let gaps = gap * (ratios.len() as f64 - 1.0); - (f64::from(width) - gaps).max(1.0) / ratios.iter().sum::() + let Ok(grid) = pg_core::grid::plan_sections( + ratios, + &[], + width.clamp(1, 32_768) as u32, + target.clamp(ROW_MIN, ROW_MAX) as u32, + TILE_GAP as u32, + ) else { + return Vec::new(); }; - let mut rows = Vec::new(); - let mut start = 0; - while start < ratios.len() { - let mut end = start + 1; - while end < ratios.len() && fit(&ratios[start..end]) > target { - end += 1; - } - let full = fit(&ratios[start..end]) <= target; - // Giving the last photo back leaves the row taller than the target; - // keeping it, shorter. Whichever misses by less wins. - if full - && end - start > 1 - && fit(&ratios[start..end - 1]) - target < target - fit(&ratios[start..end]) - { - end -= 1; - } - let row = &ratios[start..end]; - rows.push(if full { - size_row(row, fit(row), Some(width)) - } else { - size_row(row, target, None) - }); - start = end; - } - rows -} - -/// Tile sizes for one row of shapes at `height`. With `span`, the widths are -/// rounded so the row, gaps included, is exactly that wide: each tile ends -/// where its share of the row ends, so no rounding error piles up at the end. -fn size_row(ratios: &[f64], height: f64, span: Option) -> Vec<(i32, i32)> { - let tile_height = (height.round() as i32).max(1); - let Some(span) = span else { - return ratios - .iter() - .map(|ratio| (((ratio * height).round() as i32).max(1), tile_height)) - .collect(); - }; - let content = f64::from(span - TILE_GAP * (ratios.len() as i32 - 1)); - let total: f64 = ratios.iter().sum(); - let mut sizes = Vec::with_capacity(ratios.len()); - let mut done = 0.0; - let mut left = 0; - for ratio in ratios { - done += ratio; - let right = (content * done / total).round() as i32; - sizes.push(((right - left).max(1), tile_height)); - left = right; - } - sizes + let ends = grid + .row_starts + .iter() + .copied() + .skip(1) + .chain(std::iter::once(grid.widths.len() as u32)); + grid.row_starts + .iter() + .copied() + .zip(ends) + .zip(grid.row_heights) + .map(|((start, end), height)| { + grid.widths[start as usize..end as usize] + .iter() + .map(|width| (*width as i32, height as i32)) + .collect() + }) + .collect() } /// The layout math: how many square tiles of about `target` px fit across diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md index eb3ac26..4ccd367 100644 --- a/docs/CHANGELOG.md +++ b/docs/CHANGELOG.md @@ -11,6 +11,19 @@ scratch (user data in `staging/` and `recovery/` is never touched by this). ## [Unreleased] +### Added + +- Open **Drive Galleries** from Photos 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. + +### Changed + +- Photos uses Proton Gallery's justified row planner. The Photos viewer starts + and seeks through supported videos without caching the whole original. +- Gallery-hidden albums and their contents are filtered from Photos and Drive + Galleries. Unlock them with the local Gallery passphrase. + ## [3.8.1] — 2026-11-19 Schema: **45**. No database migration in this release. diff --git a/packaging/copr/README.md b/packaging/copr/README.md index 67292d8..dc11962 100644 --- a/packaging/copr/README.md +++ b/packaging/copr/README.md @@ -8,7 +8,7 @@ release assets: | Source | What it is | | --- | --- | | `Source0` | GitHub's archive of the `v` tag | -| `Source1` | `proton-drive-linux-vendor-.tar.xz`: every crate from `Cargo.lock`, made by `cargo vendor` in `release.yml` | +| `Source1` | `proton-drive-linux-vendor-.tar.xz`: the crates and source mappings generated by `cargo vendor` in `release.yml` | With the vendored crates the build needs no network, so the COPR project keeps network access off. diff --git a/packaging/nix/package.nix b/packaging/nix/package.nix index c2bce34..e9f4b4a 100644 --- a/packaging/nix/package.nix +++ b/packaging/nix/package.nix @@ -44,7 +44,10 @@ rustPlatform.buildRustPackage { ]; }; - cargoLock.lockFile = ../../Cargo.lock; + cargoLock = { + lockFile = ../../Cargo.lock; + allowBuiltinFetchGit = true; + }; cargoBuildFlags = [ "--bin" diff --git a/packaging/proton-drive-linux.spec b/packaging/proton-drive-linux.spec index d383a70..4cc1ac9 100644 --- a/packaging/proton-drive-linux.spec +++ b/packaging/proton-drive-linux.spec @@ -2,7 +2,7 @@ # # - From a checkout (local builds and the release workflow). From the repository root: # rpmbuild -bb packaging/proton-drive-linux.spec --define "git_dir $PWD" ... -# %build needs network so cargo can fetch crates.io (same trade-off as the Arch PKGBUILD). +# %build needs network so Cargo can fetch crates.io and Git dependencies. # - From the release tarballs (COPR, .github/workflows/copr.yml), when git_dir is not # defined. Source1 holds every crate, so the build runs offline. @@ -72,16 +72,19 @@ system tray and search launcher. Unofficial and not affiliated with Proton AG. test -f %{git_dir}/Cargo.toml cp -a %{git_dir}/LICENSE . %else -# -a 1 unpacks the vendored crates into vendor/ inside the source tree. +# -a 1 unpacks the vendored crates and their source mappings. %autosetup -n %{name}-%{version} -a 1 -mkdir -p .cargo -cat > .cargo/config.toml <<'EOF' +# Older vendor tarballs contained only crates.io dependencies. +if [ ! -f .cargo/config.toml ]; then + mkdir -p .cargo + cat > .cargo/config.toml <<'EOF' [source.crates-io] replace-with = "vendored-sources" [source.vendored-sources] directory = "vendor" EOF +fi %endif %build diff --git a/po/POTFILES.in b/po/POTFILES.in index 3b066df..c411c36 100644 --- a/po/POTFILES.in +++ b/po/POTFILES.in @@ -6,6 +6,7 @@ crates/pdfs-gui/src/app/pages/activity_text.rs crates/pdfs-gui/src/app/pages/albums.rs crates/pdfs-gui/src/app/pages/browser.rs crates/pdfs-gui/src/app/pages/devices.rs +crates/pdfs-gui/src/app/pages/drive_galleries.rs crates/pdfs-gui/src/app/pages/duplicates.rs crates/pdfs-gui/src/app/pages/locations.rs crates/pdfs-gui/src/app/pages/login.rs From 1c2a66169fc0986d6684832fd83a147e947d0567 Mon Sep 17 00:00:00 2001 From: Nils Pukropp Date: Thu, 19 Nov 2026 17:56:32 +0100 Subject: [PATCH 2/5] feat(photos): embed galleries and speed up zoom Keep album browsing and private galleries inside Photos. Build GTK tiles near the viewport and anchor relayouts on the visible photo. Migrate the Photos cache to persist pending event work with its cursor. Pin the published Gallery engine for scoped private album reads. --- Cargo.lock | 8 +- Cargo.toml | 4 +- crates/pdfs-core/src/control.rs | 23 + crates/pdfs-core/src/db/albums.rs | 107 ++- crates/pdfs-core/src/db/migrations.rs | 23 +- crates/pdfs-core/src/db/photos.rs | 320 ++++++- crates/pdfs-core/src/db/tests.rs | 84 ++ crates/pdfs-fuse/src/albums.rs | 200 +++-- crates/pdfs-fuse/src/background.rs | 149 ++-- crates/pdfs-fuse/src/control.rs | 85 +- crates/pdfs-fuse/src/gallery.rs | 489 ++++++++--- crates/pdfs-fuse/src/lib.rs | 2 +- crates/pdfs-fuse/src/photos.rs | 280 +++--- crates/pdfs-gui/src/app/events.rs | 32 +- crates/pdfs-gui/src/app/main.rs | 35 +- crates/pdfs-gui/src/app/pages/albums.rs | 38 +- .../pdfs-gui/src/app/pages/drive_galleries.rs | 822 ++++++++++++------ crates/pdfs-gui/src/app/pages/login.rs | 2 +- crates/pdfs-gui/src/app/pages/photo_viewer.rs | 54 +- crates/pdfs-gui/src/app/pages/photos.rs | 780 +++++++++++------ crates/pdfs-gui/tests/icon_names.rs | 1 + docs/CHANGELOG.md | 2 +- docs/PHOTOS.md | 25 + 23 files changed, 2504 insertions(+), 1061 deletions(-) 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`. From 834684f6d773a70a0667580156eb3831439e8e13 Mon Sep 17 00:00:00 2001 From: Nils Pukropp Date: Thu, 19 Nov 2026 18:15:54 +0100 Subject: [PATCH 3/5] chore(release): prepare Proton Drive 3.9.0 --- Cargo.lock | 8 ++++---- Cargo.toml | 2 +- docs/CHANGELOG.md | 10 +++++++++- packaging/PKGBUILD | 2 +- packaging/proton-drive-linux.spec | 2 +- 5 files changed, 16 insertions(+), 8 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 8d92e79..11ce2b7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3592,7 +3592,7 @@ checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4" [[package]] name = "pdfs-cli" -version = "3.8.1" +version = "3.9.0" dependencies = [ "anyhow", "clap", @@ -3609,7 +3609,7 @@ dependencies = [ [[package]] name = "pdfs-core" -version = "3.8.1" +version = "3.9.0" dependencies = [ "argon2", "async-trait", @@ -3640,7 +3640,7 @@ dependencies = [ [[package]] name = "pdfs-fuse" -version = "3.8.1" +version = "3.9.0" dependencies = [ "async-trait", "base64 0.23.1", @@ -3671,7 +3671,7 @@ dependencies = [ [[package]] name = "pdfs-gui" -version = "3.8.1" +version = "3.9.0" dependencies = [ "anyhow", "async-channel", diff --git a/Cargo.toml b/Cargo.toml index 95ec75c..fbcfe1b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -3,7 +3,7 @@ resolver = "2" members = ["crates/pdfs-core", "crates/pdfs-fuse", "crates/pdfs-cli", "crates/pdfs-gui"] [workspace.package] -version = "3.8.1" +version = "3.9.0" edition = "2024" license = "MIT" authors = ["Nils Pukropp "] diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md index 2608287..cfb1803 100644 --- a/docs/CHANGELOG.md +++ b/docs/CHANGELOG.md @@ -11,18 +11,25 @@ scratch (user data in `staging/` and `recovery/` is never touched by this). ## [Unreleased] +## [3.9.0] — 2026-11-19 + +Schema: **46**. Photos adds a local database migration for incremental metadata sync. + ### Added - 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. +- Unlock hidden albums from the Albums view with the local Gallery passphrase. ### Changed - Photos uses Proton Gallery's justified row planner. The Photos viewer starts and seeks through supported videos without caching the whole original. - Gallery-hidden albums and their contents are filtered from Photos and Drive - Galleries. Unlock them with the local Gallery passphrase. + Galleries until unlocked. +- Photo grids defer work for off-screen tiles and keep the viewed photo anchored + during zoom. ## [3.8.1] — 2026-11-19 @@ -2385,6 +2392,7 @@ First stable release: FUSE files-on-demand mount, sync daemon under `proton-driv - The outstanding FUSE defects tracked in `docs/BUGS.md`, plus a truncate defect, validated by a new POSIX compliance suite for the filesystem. +[3.9.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v3.9.0 [3.8.1]: https://github.com/narrrl/proton-drive-linux/releases/tag/v3.8.1 [3.5.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v3.5.0 [3.4.1]: https://github.com/narrrl/proton-drive-linux/releases/tag/v3.4.1 diff --git a/packaging/PKGBUILD b/packaging/PKGBUILD index 35e839d..f5ae332 100644 --- a/packaging/PKGBUILD +++ b/packaging/PKGBUILD @@ -9,7 +9,7 @@ # Build + install: cd packaging && makepkg -fi pkgname=proton-drive-linux -pkgver=3.8.1 +pkgver=3.9.0 pkgrel=1 pkgdesc="Unofficial Proton Drive client for Linux: files-on-demand FUSE mount, CLI, GTK4 app + tray" arch=('x86_64') diff --git a/packaging/proton-drive-linux.spec b/packaging/proton-drive-linux.spec index 4cc1ac9..442c631 100644 --- a/packaging/proton-drive-linux.spec +++ b/packaging/proton-drive-linux.spec @@ -10,7 +10,7 @@ # Match Arch PKGBUILD `!lto` — LTO has broken some GTK/Rust links in practice. %global _lto_cflags %{nil} -%{!?version: %global version 3.8.0} +%{!?version: %global version 3.9.0} %global forge https://github.com/narrrl/proton-drive-linux # Files come from the checkout, or from the unpacked tag archive. %global src %{?git_dir}%{!?git_dir:.} From 1e6043d12a1ccdf450dc1b99ab344bea9ee0e5cd Mon Sep 17 00:00:00 2001 From: Nils Pukropp Date: Thu, 19 Nov 2026 20:44:44 +0100 Subject: [PATCH 4/5] fix(photos): keep hidden albums open after unlock --- crates/pdfs-fuse/src/control.rs | 6 +++--- crates/pdfs-gui/resources/style.css | 3 +++ crates/pdfs-gui/src/app/events.rs | 2 +- crates/pdfs-gui/src/app/pages/albums.rs | 5 ++++- crates/pdfs-gui/src/app/pages/drive_galleries.rs | 15 ++++++++++++--- crates/pdfs-gui/src/app/pages/photos.rs | 2 ++ docs/CHANGELOG.md | 5 +++++ 7 files changed, 30 insertions(+), 8 deletions(-) diff --git a/crates/pdfs-fuse/src/control.rs b/crates/pdfs-fuse/src/control.rs index 460a188..3047c3d 100644 --- a/crates/pdfs-fuse/src/control.rs +++ b/crates/pdfs-fuse/src/control.rs @@ -396,10 +396,10 @@ fn touched_topics(request: &CtlRequest) -> &'static [Topic] { use CtlRequest as R; match request { R::Pin { .. } | R::Unpin { .. } => &[Topic::Files], + // Unlock affects private requests only. Publishing the lock notification + // here for Unlock as well could close the view that just opened. R::DriveGallery { - action: - pdfs_core::control::GalleryAction::Lock - | pdfs_core::control::GalleryAction::Unlock { .. }, + action: pdfs_core::control::GalleryAction::Lock, } => &[Topic::GalleryVisibility], R::CreateAlbum { .. } | R::RenameAlbum { .. } diff --git a/crates/pdfs-gui/resources/style.css b/crates/pdfs-gui/resources/style.css index ddbf362..8fa4610 100644 --- a/crates/pdfs-gui/resources/style.css +++ b/crates/pdfs-gui/resources/style.css @@ -118,6 +118,9 @@ scale.browser-status-meter trough { min-width: 140px; min-height: 6px; } .memory-card { padding: 0; border-radius: 12px; } .memory-cover { border-radius: 12px; background: alpha(currentColor, 0.06); } .memory-label { font-weight: 700; color: white; text-shadow: 0 1px 3px rgba(0, 0, 0, 0.9); padding: 22px 10px 6px 10px; background: linear-gradient(to top, rgba(0, 0, 0, 0.6), rgba(0, 0, 0, 0)); } +/* The button handles hover and clicks. The FlowBox cell can be wider than it. */ +flowbox.photo-album-grid > flowboxchild:hover, +flowbox.photo-album-grid > flowboxchild:active { background: transparent; } .album-card { padding: 0; border-radius: 16px; transition: background 180ms ease; } .album-card:hover { background: alpha(currentColor, 0.07); } .album-cover { border-radius: 16px; background: alpha(currentColor, 0.06); box-shadow: 0 4px 16px rgba(0, 0, 0, 0.32); transition: box-shadow 180ms ease; } diff --git a/crates/pdfs-gui/src/app/events.rs b/crates/pdfs-gui/src/app/events.rs index 0df7f25..0fd1caa 100644 --- a/crates/pdfs-gui/src/app/events.rs +++ b/crates/pdfs-gui/src/app/events.rs @@ -138,7 +138,7 @@ fn follow_changes(ui: &Rc, state: &FeedState, topics: &[Topic]) { let page = ui.stack.visible_child_name(); if changed(Topic::GalleryVisibility) || changed(Topic::GalleryVisibilitySynced) { if let Some(browser) = ui.drive_galleries.borrow().upgrade() { - browser.refresh_visibility(); + browser.refresh_visibility(changed(Topic::GalleryVisibility)); } for window in gtk4::Window::list_toplevels() { if let Ok(window) = window.downcast::() diff --git a/crates/pdfs-gui/src/app/pages/albums.rs b/crates/pdfs-gui/src/app/pages/albums.rs index 29cf9e0..c75edc2 100644 --- a/crates/pdfs-gui/src/app/pages/albums.rs +++ b/crates/pdfs-gui/src/app/pages/albums.rs @@ -180,7 +180,10 @@ pub(crate) fn collection_card( card.append(&name); card.append(&count); - let button = gtk4::Button::builder().child(&card).build(); + let button = gtk4::Button::builder() + .child(&card) + .halign(gtk4::Align::Start) + .build(); button.add_css_class("flat"); button.add_css_class("album-card"); button.set_tooltip_text(Some(title)); diff --git a/crates/pdfs-gui/src/app/pages/drive_galleries.rs b/crates/pdfs-gui/src/app/pages/drive_galleries.rs index 97a20a6..8edf00e 100644 --- a/crates/pdfs-gui/src/app/pages/drive_galleries.rs +++ b/crates/pdfs-gui/src/app/pages/drive_galleries.rs @@ -113,7 +113,7 @@ impl Browser { sync_header(&self.ui); } - pub(crate) fn refresh_visibility(self: &Rc) { + pub(crate) fn refresh_visibility(self: &Rc, locked: bool) { self.thumbnails.borrow_mut().clear(); self.root.remove_all(); self.load_root(); @@ -124,7 +124,17 @@ impl Browser { preview.force_close(); } if self.unlocked.get() { - self.close(); + if locked { + self.close(); + } else { + // The first private listing can also discover a newer visibility + // snapshot. Rebuild from the private root so a folder that is no + // longer hidden cannot leave its title or contents on screen. + self.trail.borrow_mut().clear(); + self.cover.borrow_mut().take(); + self.thumb_pending.borrow_mut().clear(); + self.load(0, 0.0); + } } else { self.load(0, self.scroll.vadjustment().value()); } @@ -214,7 +224,6 @@ impl Browser { }, (width, width.min(200)), ); - button.set_halign(gtk4::Align::Start); wire_thumbnail(self, &picture, album.cover.as_deref(), private, None); button } diff --git a/crates/pdfs-gui/src/app/pages/photos.rs b/crates/pdfs-gui/src/app/pages/photos.rs index d6a534e..fd0770b 100644 --- a/crates/pdfs-gui/src/app/pages/photos.rs +++ b/crates/pdfs-gui/src/app/pages/photos.rs @@ -845,6 +845,7 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) { .max_children_per_line(8) .valign(gtk4::Align::Start) .build(); + albums.add_css_class("photo-album-grid"); let albums_status = adw::StatusPage::builder() .icon_name("pdfs-album-symbolic") .vexpand(true) @@ -874,6 +875,7 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) { .max_children_per_line(8) .valign(gtk4::Align::Start) .build(); + drive_galleries.add_css_class("photo-album-grid"); 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")); diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md index cfb1803..2fd2f73 100644 --- a/docs/CHANGELOG.md +++ b/docs/CHANGELOG.md @@ -31,6 +31,11 @@ Schema: **46**. Photos adds a local database migration for incremental metadata - Photo grids defer work for off-screen tiles and keep the viewed photo anchored during zoom. +### Fixed + +- Unlocking Hidden albums keeps the private view open while its albums load. +- Hovering over an album highlights its card without shading the surrounding grid cell. + ## [3.8.1] — 2026-11-19 Schema: **45**. No database migration in this release. From cc020bfb54862ac13c0adead2c92ebf66591b766 Mon Sep 17 00:00:00 2001 From: Nils Pukropp Date: Thu, 19 Nov 2026 20:55:26 +0100 Subject: [PATCH 5/5] feat(photos): unlock hidden albums with system login --- .github/workflows/release.yml | 3 +- Cargo.lock | 14 +-- Cargo.toml | 4 +- crates/pdfs-core/Cargo.toml | 1 - crates/pdfs-core/src/auth.rs | 42 ------- crates/pdfs-core/src/control.rs | 4 +- crates/pdfs-fuse/Cargo.toml | 1 + crates/pdfs-fuse/src/control.rs | 9 +- crates/pdfs-fuse/src/gallery.rs | 44 +++++-- .../pdfs-gui/src/app/pages/drive_galleries.rs | 117 ++++++++++-------- docs/CHANGELOG.md | 2 +- docs/PHOTOS.md | 17 ++- packaging/PKGBUILD | 5 +- .../aur/proton-drive-for-linux-bin/.SRCINFO | 1 + .../aur/proton-drive-for-linux-bin/PKGBUILD | 2 +- .../aur/proton-drive-for-linux-git/.SRCINFO | 1 + .../aur/proton-drive-for-linux-git/PKGBUILD | 5 +- packaging/aur/proton-drive-for-linux/.SRCINFO | 1 + packaging/aur/proton-drive-for-linux/PKGBUILD | 5 +- packaging/io.narl.proton-drive-linux.policy | 14 +++ packaging/nix/package.nix | 6 +- packaging/proton-drive-linux.spec | 4 + packaging/tarball/build.sh | 2 + 23 files changed, 175 insertions(+), 129 deletions(-) create mode 100644 packaging/io.narl.proton-drive-linux.policy diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index b314769..468bd3e 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -156,6 +156,7 @@ jobs: cp packaging/io.narl.proton-drive-linux.desktop deb/usr/share/applications/ cp packaging/io.narl.proton-drive-linux-tray.desktop deb/etc/xdg/autostart/ cp packaging/io.narl.proton-drive-linux.svg deb/usr/share/icons/hicolor/scalable/apps/ + install -Dm644 packaging/io.narl.proton-drive-linux.policy deb/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy cp packaging/proton-drive.service deb/usr/lib/systemd/user/ cp LICENSE deb/usr/share/licenses/proton-drive-linux/ po/build.sh deb/usr/share/locale @@ -175,7 +176,7 @@ jobs: Priority: optional Architecture: amd64 Maintainer: Nils Pukropp - Depends: fuse3, libgtk-4-1 (>= 4.12.0), libadwaita-1-0 (>= 1.5.0), libsecret-1-0, libwebkitgtk-6.0-4, libimage-exiftool-perl + Depends: polkitd, fuse3, libgtk-4-1 (>= 4.12.0), libadwaita-1-0 (>= 1.5.0), libsecret-1-0, libwebkitgtk-6.0-4, libimage-exiftool-perl Installed-Size: ${INSTALLED_SIZE} Homepage: https://proton-drive.narl.io Description: Unofficial Proton Drive client for Linux diff --git a/Cargo.lock b/Cargo.lock index 11ce2b7..a6f2f6a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3611,7 +3611,6 @@ dependencies = [ name = "pdfs-core" version = "3.9.0" dependencies = [ - "argon2", "async-trait", "base64 0.23.1", "chrono", @@ -3659,6 +3658,7 @@ dependencies = [ "pg-app", "pg-core", "proton-drive-rs", + "rustix", "serde", "serde_json", "sha1 0.11.0", @@ -3710,8 +3710,8 @@ checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" [[package]] name = "pg-app" -version = "0.2.0" -source = "git+https://github.com/narrrl/proton-gallery.git?rev=b841c37ad57694470f499f575f7a956425c28ade#b841c37ad57694470f499f575f7a956425c28ade" +version = "0.3.0" +source = "git+https://github.com/narrrl/proton-gallery.git?rev=858d2446f71214ec5357eb8b543d6b82abf47386#858d2446f71214ec5357eb8b543d6b82abf47386" dependencies = [ "async-trait", "hex", @@ -3730,8 +3730,8 @@ dependencies = [ [[package]] name = "pg-core" -version = "0.2.0" -source = "git+https://github.com/narrrl/proton-gallery.git?rev=b841c37ad57694470f499f575f7a956425c28ade#b841c37ad57694470f499f575f7a956425c28ade" +version = "0.3.0" +source = "git+https://github.com/narrrl/proton-gallery.git?rev=858d2446f71214ec5357eb8b543d6b82abf47386#858d2446f71214ec5357eb8b543d6b82abf47386" dependencies = [ "aes-gcm 0.11.1", "async-trait", @@ -3750,8 +3750,8 @@ dependencies = [ [[package]] name = "pg-drive" -version = "0.2.0" -source = "git+https://github.com/narrrl/proton-gallery.git?rev=b841c37ad57694470f499f575f7a956425c28ade#b841c37ad57694470f499f575f7a956425c28ade" +version = "0.3.0" +source = "git+https://github.com/narrrl/proton-gallery.git?rev=858d2446f71214ec5357eb8b543d6b82abf47386#858d2446f71214ec5357eb8b543d6b82abf47386" dependencies = [ "async-trait", "hex", diff --git a/Cargo.toml b/Cargo.toml index fbcfe1b..1be8eda 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 = "b841c37ad57694470f499f575f7a956425c28ade" } -pg-core = { git = "https://github.com/narrrl/proton-gallery.git", rev = "b841c37ad57694470f499f575f7a956425c28ade" } +pg-app = { git = "https://github.com/narrrl/proton-gallery.git", rev = "858d2446f71214ec5357eb8b543d6b82abf47386" } +pg-core = { git = "https://github.com/narrrl/proton-gallery.git", rev = "858d2446f71214ec5357eb8b543d6b82abf47386" } chrono = { version = "0.4", default-features = false, features = ["std"] } # Internal crates. diff --git a/crates/pdfs-core/Cargo.toml b/crates/pdfs-core/Cargo.toml index 46a80a3..9deceea 100644 --- a/crates/pdfs-core/Cargo.toml +++ b/crates/pdfs-core/Cargo.toml @@ -10,7 +10,6 @@ homepage.workspace = true description = "Core auth/session/config for the Proton Drive Linux client" [dependencies] -argon2 = "0.5" proton-sdk.workspace = true proton-drive-rs.workspace = true chrono.workspace = true diff --git a/crates/pdfs-core/src/auth.rs b/crates/pdfs-core/src/auth.rs index b22dd6d..fe57852 100644 --- a/crates/pdfs-core/src/auth.rs +++ b/crates/pdfs-core/src/auth.rs @@ -128,48 +128,6 @@ fn with_keyring(op: impl Fn(&Entry) -> keyring_core::Result) -> Result with_keyring_entry(KEYRING_SERVICE, KEYRING_USER, op) } -/// Verify the machine-local Gallery passphrase, setting it on first use. -pub fn unlock_gallery(username: &str, passphrase: &str) -> std::result::Result<(), String> { - use argon2::password_hash::{PasswordHash, PasswordHasher, PasswordVerifier, SaltString}; - use std::io::Read; - - if passphrase.is_empty() || passphrase.len() > 1024 { - return Err("Enter your Gallery passphrase.".into()); - } - static VERIFY: parking_lot::Mutex<()> = parking_lot::Mutex::new(()); - let _verify = VERIFY.lock(); - let service = "io.narl.protongallery"; - let user = format!("hidden-albums:{username}"); - let argon = argon2::Argon2::default(); - match with_keyring_entry(service, &user, Entry::get_password) { - Ok(stored) => { - let hash = PasswordHash::new(&stored) - .map_err(|_| "The saved Gallery passphrase is unreadable.")?; - argon - .verify_password(passphrase.as_bytes(), &hash) - .map_err(|_| "The Gallery passphrase is incorrect.".into()) - } - Err(Error::Keyring(keyring_core::Error::NoEntry)) => { - if passphrase.chars().count() < 12 { - return Err("Choose a Gallery passphrase with at least 12 characters.".into()); - } - let mut bytes = [0; 16]; - std::fs::File::open("/dev/urandom") - .and_then(|mut file| file.read_exact(&mut bytes)) - .map_err(|_| "Couldn’t generate the passphrase salt.")?; - let salt = SaltString::encode_b64(&bytes) - .map_err(|_| "Couldn’t generate the passphrase salt.")?; - let hash = argon - .hash_password(passphrase.as_bytes(), &salt) - .map_err(|_| "Couldn’t protect the Gallery passphrase.")? - .to_string(); - with_keyring_entry(service, &user, |entry| entry.set_password(&hash)) - .map_err(|_| "Couldn’t save the Gallery passphrase in the system keyring.".into()) - } - Err(_) => Err("The system keyring is locked or unavailable.".into()), - } -} - /// Run `op` on the entry `service`/`user`, reconnecting once if the Secret /// Service fails the call. /// diff --git a/crates/pdfs-core/src/control.rs b/crates/pdfs-core/src/control.rs index 506c3f5..688cd34 100644 --- a/crates/pdfs-core/src/control.rs +++ b/crates/pdfs-core/src/control.rs @@ -2019,9 +2019,7 @@ pub struct MappingProgress { /// Actions on saved Drive folder galleries. #[derive(Serialize, Deserialize, Debug, Clone)] pub enum GalleryAction { - Unlock { - passphrase: String, - }, + AuthenticateHidden, Lock, List { album: Option, diff --git a/crates/pdfs-fuse/Cargo.toml b/crates/pdfs-fuse/Cargo.toml index 28c1d0a..be377a8 100644 --- a/crates/pdfs-fuse/Cargo.toml +++ b/crates/pdfs-fuse/Cargo.toml @@ -27,6 +27,7 @@ tokio.workspace = true tracing.workspace = true fuser.workspace = true libc.workspace = true +rustix = { version = "1", features = ["net", "process"] } serde.workspace = true serde_json.workspace = true base64.workspace = true diff --git a/crates/pdfs-fuse/src/control.rs b/crates/pdfs-fuse/src/control.rs index 3047c3d..0fcc1b4 100644 --- a/crates/pdfs-fuse/src/control.rs +++ b/crates/pdfs-fuse/src/control.rs @@ -396,8 +396,8 @@ fn touched_topics(request: &CtlRequest) -> &'static [Topic] { use CtlRequest as R; match request { R::Pin { .. } | R::Unpin { .. } => &[Topic::Files], - // Unlock affects private requests only. Publishing the lock notification - // here for Unlock as well could close the view that just opened. + // Only locking invalidates a hidden view. Authentication does not + // change the public catalog and must not emit this notification. R::DriveGallery { action: pdfs_core::control::GalleryAction::Lock, } => &[Topic::GalleryVisibility], @@ -952,6 +952,11 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U }, None => CtlResponse::error(CoreError::invalid(format!("bad uid: {uid}"))), }, + Ok(CtlRequest::DriveGallery { + action: pdfs_core::control::GalleryAction::AuthenticateHidden, + }) => core + .authenticate_hidden_gallery(&stream) + .unwrap_or_else(CtlResponse::error), Ok(CtlRequest::DriveGallery { action }) => core .drive_gallery(action) .unwrap_or_else(CtlResponse::error), diff --git a/crates/pdfs-fuse/src/gallery.rs b/crates/pdfs-fuse/src/gallery.rs index 2ba81bb..bd136e6 100644 --- a/crates/pdfs-fuse/src/gallery.rs +++ b/crates/pdfs-fuse/src/gallery.rs @@ -431,20 +431,40 @@ impl Core { .ok_or_else(|| CoreError::remote("The Gallery session is unavailable")) } + pub(super) fn authenticate_hidden_gallery( + &self, + stream: &std::os::unix::net::UnixStream, + ) -> CoreResult { + let gallery = self.gallery_host()?; + let access = gallery.access.load(Ordering::SeqCst); + let peer = rustix::net::sockopt::socket_peercred(stream) + .map_err(|_| CoreError::invalid("Couldn’t identify the authentication requester."))?; + if peer.uid != rustix::process::geteuid() { + return Err(CoreError::invalid( + "Use your Linux sign-in to unlock Hidden albums.", + )); + } + let subject = pg_app::desktop_auth::Subject::new( + peer.pid.as_raw_nonzero().get() as u32, + peer.uid.as_raw(), + ) + .map_err(gallery_error)?; + self.rt + .block_on(subject.authenticate("io.narl.proton-drive-linux.unlock-hidden-albums")) + .map_err(gallery_error)?; + if gallery.cancel.is_cancelled() { + return Err(CoreError::invalid("The Gallery session has ended.")); + } + gallery + .access + .compare_exchange(access, access | 1, Ordering::SeqCst, Ordering::SeqCst) + .map_err(|_| CoreError::invalid("Hidden albums were locked"))?; + Ok(done()) + } + pub(super) fn drive_gallery(&self, action: GalleryAction) -> CoreResult { let gallery = self.gallery_host()?; 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 - .access - .compare_exchange(access, access | 1, Ordering::SeqCst, Ordering::SeqCst) - .map_err(|_| CoreError::invalid("Hidden albums were locked"))?; - return Ok(done()); - } GalleryAction::Lock => { gallery.lock(); return Ok(done()); @@ -457,7 +477,7 @@ impl Core { .ensure_visibility(self, app, matches!(action, GalleryAction::Refresh)) .await?; match action { - GalleryAction::Unlock { .. } | GalleryAction::Lock => unreachable!(), + GalleryAction::AuthenticateHidden | GalleryAction::Lock => unreachable!(), GalleryAction::List { album, offset, diff --git a/crates/pdfs-gui/src/app/pages/drive_galleries.rs b/crates/pdfs-gui/src/app/pages/drive_galleries.rs index 8edf00e..e35a041 100644 --- a/crates/pdfs-gui/src/app/pages/drive_galleries.rs +++ b/crates/pdfs-gui/src/app/pages/drive_galleries.rs @@ -31,6 +31,7 @@ pub(crate) struct Browser { root_reload: Cell, preview: glib::WeakRef, unlock_pending: Cell, + unlock_verified: Cell, rows: gio::ListStore, scroll: gtk4::ScrolledWindow, title: adw::WindowTitle, @@ -75,7 +76,9 @@ impl Browser { self.next_request(); self.loading.set(false); self.total.set(0); - if self.unlocked.replace(false) || self.unlock_pending.get() { + let was_unlocked = self.unlocked.replace(false); + let was_verified = self.unlock_verified.replace(false); + if was_unlocked || was_verified || self.unlock_pending.get() { self.lock(); } if let Some(preview) = self.preview.upgrade() { @@ -120,6 +123,15 @@ impl Browser { if !self.active() || self.chooser.borrow().is_some() || self.unlock_pending.get() { return; } + if self.unlock_verified.get() { + if locked { + self.close(); + } + return; + } + if !self.unlocked.get() && self.current().is_none() { + return; + } if let Some(preview) = self.preview.upgrade() { preview.force_close(); } @@ -393,7 +405,6 @@ impl Browser { } fn change(self: &Rc, action: GalleryAction) { - let unlock = matches!(action, GalleryAction::Unlock { .. }); let update_root = matches!( action, GalleryAction::Add { .. } @@ -401,9 +412,6 @@ impl Browser { | 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…")); @@ -414,25 +422,11 @@ 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(); - } return; } match result { Ok(Ok(Response::Ok { .. })) => { - if unlock { - browser.unlocked.set(true); - } let added = browser.chooser.borrow().is_some(); if update_root { browser.load_root(); @@ -467,36 +461,58 @@ impl Browser { } fn prompt_unlock(self: &Rc) { - if self.unlock_pending.get() { + if self.unlock_pending.replace(true) { return; } - let Some(parent) = ui_window(&self.ui) else { - return; - }; - let dialog = adw::AlertDialog::builder() - .heading(gettext("Unlock Hidden Albums")) - .body(gettext("Enter your Gallery passphrase. On first use, choose one with at least 12 characters.")) - .build(); - let password = gtk4::PasswordEntry::builder().show_peek_icon(true).build(); - dialog.set_extra_child(Some(&password)); - dialog.add_response("cancel", &gettext("Cancel")); - dialog.add_response("unlock", &gettext("Unlock")); - dialog.set_response_appearance("unlock", adw::ResponseAppearance::Suggested); - dialog.set_default_response(Some("unlock")); - let browser = Rc::downgrade(self); - dialog.connect_response(None, move |_, response| { - let passphrase = password.text().to_string(); - password.set_text(""); - 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 }); + self.enter(); + self.more.set_visible(false); + self.unlock.set_visible(false); + self.title.set_title(&gettext("Hidden albums")); + self.status + .set_label(&gettext("Use your Linux sign-in to unlock Hidden albums.")); + let generation = self.next_request(); + let rx = spawn_request( + self.ui.dirs.control_socket(), + Request::DriveGallery { + action: GalleryAction::AuthenticateHidden, + }, + ); + let browser = self.clone(); + glib::spawn_future_local(async move { + let result = rx.recv().await; + browser.unlock_pending.set(false); + if browser.generation.get() != generation { + if matches!(result, Ok(Ok(Response::Ok { .. }))) { + browser.lock(); + } + return; + } + match result { + Ok(Ok(Response::Ok { .. })) => { + browser.unlock_verified.set(true); + browser.reveal_verified(); + } + Ok(Ok(Response::Error { message, .. })) => { + browser.status.set_label(&message); + browser.unlock.set_visible(true); + } + _ => { + browser + .status + .set_label(&gettext("Couldn't reach Proton Drive.")); + browser.unlock.set_visible(true); + } } }); - dialog.present(Some(&parent)); + } + + fn reveal_verified(self: &Rc) { + if ui_window(&self.ui).is_some_and(|window| window.is_active()) + && self.unlock_verified.replace(false) + { + self.unlocked.set(true); + self.load(0, 0.0); + } } pub(crate) fn back(self: &Rc) { @@ -713,6 +729,7 @@ pub(crate) fn wire( root_loading: Cell::new(false), preview: glib::WeakRef::new(), unlock_pending: Cell::new(false), + unlock_verified: Cell::new(false), rows, scroll: scroll.clone(), title, @@ -737,10 +754,12 @@ pub(crate) fn wire( *ui.drive_galleries.borrow_mut() = Rc::downgrade(&browser); 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()) - { + let Some(browser) = weak.upgrade() else { + return; + }; + if window.is_active() { + browser.reveal_verified(); + } else if browser.unlocked.get() { browser.close(); } }); diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md index 2fd2f73..d00a5a0 100644 --- a/docs/CHANGELOG.md +++ b/docs/CHANGELOG.md @@ -20,7 +20,7 @@ Schema: **46**. Photos adds a local database migration for incremental metadata - 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. -- Unlock hidden albums from the Albums view with the local Gallery passphrase. +- Unlock hidden albums from the Albums view with your Linux sign-in. ### Changed diff --git a/docs/PHOTOS.md b/docs/PHOTOS.md index f64643c..75b70a4 100644 --- a/docs/PHOTOS.md +++ b/docs/PHOTOS.md @@ -9,10 +9,19 @@ 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. +**Hidden albums** opens with your Linux sign-in. The app uses the desktop +polkit prompt, so it needs a running authentication agent and the installed +polkit policy. Existing hidden albums remain hidden after upgrading. This view +includes hidden Proton albums and hidden Drive folders, including folders +inside public galleries. Leaving Hidden albums or switching away from the +window locks it and closes its previews. + +For a system package, the policy is installed with the app. For a source build +or a per-user tarball install, have your system administrator install +`packaging/io.narl.proton-drive-linux.policy` (or the corresponding file under the +tarball's `share/polkit-1/actions/`) into the system polkit actions directory. +On NixOS, enable `security.polkit` and install the package system-wide to +register its policy. 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 diff --git a/packaging/PKGBUILD b/packaging/PKGBUILD index f5ae332..7d8a29a 100644 --- a/packaging/PKGBUILD +++ b/packaging/PKGBUILD @@ -15,7 +15,7 @@ pkgdesc="Unofficial Proton Drive client for Linux: files-on-demand FUSE mount, C arch=('x86_64') url="https://proton-drive.narl.io" license=('MIT') -depends=('fuse3' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'perl-image-exiftool') +depends=('fuse3' 'polkit' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'perl-image-exiftool') makedepends=('cargo' 'git' 'gettext') provides=('pdfs') # Files-on-demand mount + keyring need these at runtime. @@ -77,6 +77,9 @@ package() { install -Dm644 "packaging/proton-drive.service" \ "$pkgdir/usr/lib/systemd/user/proton-drive.service" + install -Dm644 "packaging/io.narl.proton-drive-linux.policy" \ + "$pkgdir/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy" + # Translations: compiled from po/ into /usr/share/locale. po/build.sh "$pkgdir/usr/share/locale" diff --git a/packaging/aur/proton-drive-for-linux-bin/.SRCINFO b/packaging/aur/proton-drive-for-linux-bin/.SRCINFO index a2ce7d9..bb7c4e5 100644 --- a/packaging/aur/proton-drive-for-linux-bin/.SRCINFO +++ b/packaging/aur/proton-drive-for-linux-bin/.SRCINFO @@ -7,6 +7,7 @@ pkgbase = proton-drive-for-linux-bin arch = x86_64 license = MIT depends = fuse3 + depends = polkit depends = gtk4 depends = libadwaita depends = webkitgtk-6.0 diff --git a/packaging/aur/proton-drive-for-linux-bin/PKGBUILD b/packaging/aur/proton-drive-for-linux-bin/PKGBUILD index 2349a5f..894782a 100644 --- a/packaging/aur/proton-drive-for-linux-bin/PKGBUILD +++ b/packaging/aur/proton-drive-for-linux-bin/PKGBUILD @@ -8,7 +8,7 @@ arch=('x86_64') url="https://proton-drive.narl.io" _repo="https://github.com/narrrl/proton-drive-linux" license=('MIT') -depends=('fuse3' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'dbus' 'gcc-libs' 'glibc' +depends=('fuse3' 'polkit' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'dbus' 'gcc-libs' 'glibc' 'hicolor-icon-theme') optdepends=('perl-image-exiftool: thumbnails for camera RAW files' 'ffmpeg: video thumbnails' diff --git a/packaging/aur/proton-drive-for-linux-git/.SRCINFO b/packaging/aur/proton-drive-for-linux-git/.SRCINFO index 618bbbe..061e342 100644 --- a/packaging/aur/proton-drive-for-linux-git/.SRCINFO +++ b/packaging/aur/proton-drive-for-linux-git/.SRCINFO @@ -10,6 +10,7 @@ pkgbase = proton-drive-for-linux-git makedepends = git makedepends = gettext depends = fuse3 + depends = polkit depends = gtk4 depends = libadwaita depends = webkitgtk-6.0 diff --git a/packaging/aur/proton-drive-for-linux-git/PKGBUILD b/packaging/aur/proton-drive-for-linux-git/PKGBUILD index 766b830..f924141 100644 --- a/packaging/aur/proton-drive-for-linux-git/PKGBUILD +++ b/packaging/aur/proton-drive-for-linux-git/PKGBUILD @@ -8,7 +8,7 @@ arch=('x86_64') url="https://proton-drive.narl.io" _repo="https://github.com/narrrl/proton-drive-linux" license=('MIT') -depends=('fuse3' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'dbus' 'gcc-libs' 'glibc' +depends=('fuse3' 'polkit' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'dbus' 'gcc-libs' 'glibc' 'hicolor-icon-theme') makedepends=('cargo' 'git' 'gettext') optdepends=('perl-image-exiftool: thumbnails for camera RAW files' @@ -78,6 +78,9 @@ package() { install -Dm644 packaging/proton-drive.service \ "$pkgdir/usr/lib/systemd/user/proton-drive.service" + install -Dm644 "packaging/io.narl.proton-drive-linux.policy" \ + "$pkgdir/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy" + # Translations: compiled from po/ into /usr/share/locale. po/build.sh "$pkgdir/usr/share/locale" diff --git a/packaging/aur/proton-drive-for-linux/.SRCINFO b/packaging/aur/proton-drive-for-linux/.SRCINFO index ab35217..e7d78c5 100644 --- a/packaging/aur/proton-drive-for-linux/.SRCINFO +++ b/packaging/aur/proton-drive-for-linux/.SRCINFO @@ -9,6 +9,7 @@ pkgbase = proton-drive-for-linux makedepends = cargo makedepends = gettext depends = fuse3 + depends = polkit depends = gtk4 depends = libadwaita depends = webkitgtk-6.0 diff --git a/packaging/aur/proton-drive-for-linux/PKGBUILD b/packaging/aur/proton-drive-for-linux/PKGBUILD index b94dc45..6cd2de3 100644 --- a/packaging/aur/proton-drive-for-linux/PKGBUILD +++ b/packaging/aur/proton-drive-for-linux/PKGBUILD @@ -8,7 +8,7 @@ arch=('x86_64') url="https://proton-drive.narl.io" _repo="https://github.com/narrrl/proton-drive-linux" license=('MIT') -depends=('fuse3' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'dbus' 'gcc-libs' 'glibc' +depends=('fuse3' 'polkit' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'dbus' 'gcc-libs' 'glibc' 'hicolor-icon-theme') makedepends=('cargo' 'gettext') optdepends=('perl-image-exiftool: thumbnails for camera RAW files' @@ -73,6 +73,9 @@ package() { install -Dm644 packaging/proton-drive.service \ "$pkgdir/usr/lib/systemd/user/proton-drive.service" + install -Dm644 "packaging/io.narl.proton-drive-linux.policy" \ + "$pkgdir/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy" + # Translations: compiled from po/ into /usr/share/locale. po/build.sh "$pkgdir/usr/share/locale" diff --git a/packaging/io.narl.proton-drive-linux.policy b/packaging/io.narl.proton-drive-linux.policy new file mode 100644 index 0000000..a658152 --- /dev/null +++ b/packaging/io.narl.proton-drive-linux.policy @@ -0,0 +1,14 @@ + + + + + Unlock Hidden albums in Proton Drive + Authenticate to unlock Hidden albums in Proton Drive + + no + no + auth_self + + + diff --git a/packaging/nix/package.nix b/packaging/nix/package.nix index e9f4b4a..00e922a 100644 --- a/packaging/nix/package.nix +++ b/packaging/nix/package.nix @@ -15,6 +15,7 @@ webkitgtk_6_0, libsecret, dbus, + polkit, exiftool, ffmpeg-headless, withFfmpeg ? true, @@ -36,6 +37,7 @@ rustPlatform.buildRustPackage { ../../crates ../../po ../../LICENSE + ../io.narl.proton-drive-linux.policy ../proton-drive.service ../io.narl.proton-drive-linux.desktop ../io.narl.proton-drive-linux-tray.desktop @@ -103,6 +105,8 @@ rustPlatform.buildRustPackage { substituteInPlace $out/etc/xdg/autostart/io.narl.proton-drive-linux-tray.desktop \ --replace-fail "Exec=pdfs-tray" "Exec=$out/bin/pdfs-tray" + install -Dm644 packaging/io.narl.proton-drive-linux.policy \ + $out/share/polkit-1/actions/io.narl.proton-drive-linux.policy install -Dm644 packaging/proton-drive.service \ $out/lib/systemd/user/proton-drive.service substituteInPlace $out/lib/systemd/user/proton-drive.service \ @@ -123,7 +127,7 @@ rustPlatform.buildRustPackage { # it is the setuid wrapper in /run/wrappers/bin. preFixup = '' gappsWrapperArgs+=(--suffix PATH : ${ - lib.makeBinPath ([ exiftool ] ++ lib.optional withFfmpeg ffmpeg-headless) + lib.makeBinPath ([ exiftool polkit ] ++ lib.optional withFfmpeg ffmpeg-headless) }) ''; diff --git a/packaging/proton-drive-linux.spec b/packaging/proton-drive-linux.spec index 442c631..8ee61ab 100644 --- a/packaging/proton-drive-linux.spec +++ b/packaging/proton-drive-linux.spec @@ -39,6 +39,7 @@ BuildRequires: glib2-devel BuildRequires: webkitgtk6.0-devel BuildRequires: gettext +Requires: polkit Requires: fuse3 Requires: gtk4 Requires: libadwaita @@ -114,6 +115,8 @@ install -D -m0644 %{src}/packaging/io.narl.proton-drive-linux-tray.desktop \ %{buildroot}%{_sysconfdir}/xdg/autostart/io.narl.proton-drive-linux-tray.desktop install -D -m0644 %{src}/packaging/io.narl.proton-drive-linux.svg \ %{buildroot}%{_datadir}/icons/hicolor/scalable/apps/io.narl.proton-drive-linux.svg +install -D -m0644 %{src}/packaging/io.narl.proton-drive-linux.policy \ + %{buildroot}/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy install -D -m0644 %{src}/packaging/proton-drive.service \ %{buildroot}/usr/lib/systemd/user/proton-drive.service %{src}/po/build.sh %{buildroot}%{_datadir}/locale @@ -152,6 +155,7 @@ fi %{_sysconfdir}/xdg/autostart/io.narl.proton-drive-linux-tray.desktop %{_datadir}/icons/hicolor/scalable/apps/io.narl.proton-drive-linux.svg /usr/lib/systemd/user/proton-drive.service +%{_datadir}/polkit-1/actions/io.narl.proton-drive-linux.policy %{_datadir}/locale/*/LC_MESSAGES/pdfs.mo %{_datadir}/bash-completion/completions/pdfs %{_datadir}/zsh/site-functions/_pdfs diff --git a/packaging/tarball/build.sh b/packaging/tarball/build.sh index e58c5f3..711aa32 100755 --- a/packaging/tarball/build.sh +++ b/packaging/tarball/build.sh @@ -32,6 +32,8 @@ install -Dm644 "$repo/packaging/io.narl.proton-drive-linux-tray.desktop" \ "$root/etc/xdg/autostart/io.narl.proton-drive-linux-tray.desktop" install -Dm644 "$repo/packaging/io.narl.proton-drive-linux.svg" \ "$root/share/icons/hicolor/scalable/apps/io.narl.proton-drive-linux.svg" +install -Dm644 "$repo/packaging/io.narl.proton-drive-linux.policy" \ + "$root/share/polkit-1/actions/io.narl.proton-drive-linux.policy" install -Dm644 "$repo/packaging/proton-drive.service" \ "$root/lib/systemd/user/proton-drive.service" install -Dm644 "$repo/LICENSE" "$root/share/licenses/proton-drive-linux/LICENSE"