diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index d96d82a..468bd3e 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: | @@ -152,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 @@ -171,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 cdb2d44..a6f2f6a 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", @@ -3582,7 +3592,7 @@ checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4" [[package]] name = "pdfs-cli" -version = "3.8.1" +version = "3.9.0" dependencies = [ "anyhow", "clap", @@ -3599,7 +3609,7 @@ dependencies = [ [[package]] name = "pdfs-core" -version = "3.8.1" +version = "3.9.0" dependencies = [ "async-trait", "base64 0.23.1", @@ -3629,34 +3639,43 @@ dependencies = [ [[package]] name = "pdfs-fuse" -version = "3.8.1" +version = "3.9.0" dependencies = [ "async-trait", "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", + "rustix", "serde", "serde_json", "sha1 0.11.0", "tokio", "tracing", "tracing-subscriber", + "zeroize", "zip", ] [[package]] name = "pdfs-gui" -version = "3.8.1" +version = "3.9.0" 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.3.0" +source = "git+https://github.com/narrrl/proton-gallery.git?rev=858d2446f71214ec5357eb8b543d6b82abf47386#858d2446f71214ec5357eb8b543d6b82abf47386" +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.3.0" +source = "git+https://github.com/narrrl/proton-gallery.git?rev=858d2446f71214ec5357eb8b543d6b82abf47386#858d2446f71214ec5357eb8b543d6b82abf47386" +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.3.0" +source = "git+https://github.com/narrrl/proton-gallery.git?rev=858d2446f71214ec5357eb8b543d6b82abf47386#858d2446f71214ec5357eb8b543d6b82abf47386" +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]] @@ -5059,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", @@ -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..1be8eda 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 "] @@ -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 = "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-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/src/control.rs b/crates/pdfs-core/src/control.rs index e82fd9e..688cd34 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,15 @@ 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, + }, + /// 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. @@ -94,7 +108,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 +134,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 +152,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 +171,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 +221,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 +241,31 @@ 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, + #[serde(default)] + private: bool, + }, + OpenGalleryImage { + uid: String, + #[serde(default)] + private: bool, + }, + CloseGalleryVideo { + token: String, + }, + GalleryThumbnail { + uid: String, + #[serde(default)] + private: bool, + }, + DriveGallery { + action: GalleryAction, + }, /// Add or remove Proton's `Favorite` tag on a photo. Replies with /// [`Response::Ok`]. /// @@ -214,7 +273,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 +388,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 +407,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 +471,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 +517,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 +535,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 +548,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 +590,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 +657,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 +706,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 +760,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 +791,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 +864,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 +886,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 +904,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 +920,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 +940,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 +968,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 +2016,62 @@ pub struct MappingProgress { pub total: usize, } +/// Actions on saved Drive folder galleries. +#[derive(Serialize, Deserialize, Debug, Clone)] +pub enum GalleryAction { + AuthenticateHidden, + Lock, + List { + album: Option, + offset: usize, + limit: usize, + }, + PrivateList { + album: Option, + proton: bool, + 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, + #[serde(default)] + pub proton: bool, + 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 +2463,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 +2495,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 +2515,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 +2539,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. @@ -2302,12 +2567,19 @@ pub enum Response { #[serde(default)] summary: Option, }, + PhotoPresence { + present: bool, + }, /// 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 +2601,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 +2617,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 +2633,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 +2678,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 +2710,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 +2848,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..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. @@ -163,33 +244,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/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 d2562c7..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) } @@ -513,24 +782,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 +836,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 +867,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 +907,38 @@ 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, \ + "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{filter} GROUP BY y, m ORDER BY y DESC, m DESC" + 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)?; 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 +954,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 +970,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 +984,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 +995,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 +1027,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 +1230,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 +1241,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..82669f9 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 @@ -7845,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/Cargo.toml b/crates/pdfs-fuse/Cargo.toml index 6a36a0e..be377a8 100644 --- a/crates/pdfs-fuse/Cargo.toml +++ b/crates/pdfs-fuse/Cargo.toml @@ -14,12 +14,20 @@ 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 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/albums.rs b/crates/pdfs-fuse/src/albums.rs index b5c7b1b..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) } @@ -154,11 +154,21 @@ impl Core { album: &NodeUid, offset: usize, limit: usize, + 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(); @@ -172,7 +182,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()) } @@ -213,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(()) } @@ -283,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 0db3cf0..0fcc1b4 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], + // 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], R::CreateAlbum { .. } | R::RenameAlbum { .. } | R::DeleteAlbum { .. } @@ -552,6 +557,68 @@ 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 { .. } + | CtlRequest::PhotoDuplicates + | CtlRequest::PhotoSimilar + | CtlRequest::PhotoPlaces + | CtlRequest::PlacePhotos { .. } + | CtlRequest::PlaceLocations { .. } + | CtlRequest::PhotosOnThisDay { .. } + | CtlRequest::PhotoGroup { .. } + | CtlRequest::PhotoAlbums + | CtlRequest::AlbumPhotos { .. } + | CtlRequest::PhotoThumbs { .. } + | CtlRequest::OpenGalleryImage { private: false, .. } + | 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) => { @@ -627,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. @@ -668,11 +735,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 +761,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 +769,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 +783,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 +828,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 +873,28 @@ 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(), + 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(e) => CtlResponse::error(e.into()), + Err(error) => CtlResponse::error(error), }, + Ok(CtlRequest::PhotoMonths { .. }) => unreachable!("handled before visibility requests"), 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 +944,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 +952,38 @@ 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), + Ok(CtlRequest::OpenGalleryVideo { uid, private }) => core + .open_gallery_video(&uid, private) + .unwrap_or_else(CtlResponse::error), + 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)) + { + 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, 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 // `ImportStatus` rather than answered inline. @@ -986,7 +1100,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 { @@ -1929,9 +2044,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 +2060,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..bd136e6 --- /dev/null +++ b/crates/pdfs-fuse/src/gallery.rs @@ -0,0 +1,650 @@ +//! 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, RwLock, + atomic::{AtomicU64, 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, Notify, OnceCell}; + +use super::{Core, NodeUid, parse_uid}; + +pub(super) struct Gallery { + root: PathBuf, + session: ProtonApiSession, + cancel: CancellationToken, + app: OnceCell, + checked: Mutex>, + visibility: RwLock>>, + refresh: Notify, + access: AtomicU64, + 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), + visibility: RwLock::default(), + refresh: Notify::new(), + access: AtomicU64::new(0), + 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) = *checked + && instant.elapsed() + < if self.snapshot().is_some() { + Duration::from_secs(60) + } else { + Duration::from_secs(5) + } + { + return self.snapshot().ok_or_else(visibility_loading); + } + if self.snapshot().is_none() + && app + .gallery_visibility_cached() + .await + .map_err(gallery_error)? + { + self.publish_visibility(core, self.read_visibility(core, app).await?); + } + 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]); + } + } + + 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) { + let _ = self + .access + .try_update(Ordering::SeqCst, Ordering::SeqCst, |value| { + Some((value | 1).wrapping_add(1)) + }); + self.video.close_all(); + } + + 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) { + loop { + tokio::select! { + biased; + _ = self.cancel.cancelled() => break, + _ = self.refresh.notified() => {}, + _ = tokio::time::sleep(Duration::from_secs(60)) => {} + } + if let Ok(Ok(app)) = tokio::time::timeout(Duration::from_secs(5), self.app(&core)).await + { + 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_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()) +} + +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() +} + +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()); + } + let gallery = self.gallery_host()?; + self.rt.block_on(async { + let app = gallery.app(self).await?; + gallery.ensure_visibility(self, app, false).await + }) + } + + 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 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::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?; + match action { + GalleryAction::AuthenticateHidden | GalleryAction::Lock => unreachable!(), + GalleryAction::List { + album, + offset, + limit, + } => gallery.page(app, album, false, None, offset, limit).await, + GalleryAction::PrivateList { + album, + proton, + offset, + limit, + } => { + let access = gallery.private_access()?; + gallery + .page(app, album, proton, Some(access), offset, limit) + .await + } + 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)?; + 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_at(Some(root), 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, 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?; + 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)?; + 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)), + }) + }) + } + + 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, 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?; + 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/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..9521400 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. @@ -5770,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/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..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. @@ -1175,6 +1163,7 @@ impl Core { .unwrap_or_default() } + #[allow(clippy::too_many_arguments)] pub(crate) fn photos_timeline( &self, offset: usize, @@ -1183,21 +1172,29 @@ 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 { - // 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 @@ -1208,7 +1205,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 +1370,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 +1398,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 +1426,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()) } @@ -2477,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) @@ -2656,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-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..8fa4610 100644 --- a/crates/pdfs-gui/resources/style.css +++ b/crates/pdfs-gui/resources/style.css @@ -118,11 +118,15 @@ 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; } .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..0fd1caa 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,10 +136,45 @@ fn follow_changes(ui: &Rc, state: &FeedState, topics: &[Topic]) { refresh_file_thumbnails(ui); } let page = ui.stack.visible_child_name(); - // 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)) { + if changed(Topic::GalleryVisibility) || changed(Topic::GalleryVisibilitySynced) { + if let Some(browser) = ui.drive_galleries.borrow().upgrade() { + browser.refresh_visibility(changed(Topic::GalleryVisibility)); + } + for window in gtk4::Window::list_toplevels() { + if let Ok(window) = window.downcast::() + && window.has_css_class("photo-viewer-window") + { + 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), + } + } + } + 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 @@ -144,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 d3233a3..b2a5b99 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), @@ -559,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), @@ -615,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), @@ -626,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), @@ -787,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 @@ -796,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 => @@ -833,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. @@ -1673,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..c75edc2 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) @@ -172,10 +180,23 @@ fn album_card(ui: &Rc, album: &AlbumInfo) -> gtk4::Button { 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(&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 +714,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 new file mode 100644 index 0000000..e35a041 --- /dev/null +++ b/crates/pdfs-gui/src/app/pages/drive_galleries.rs @@ -0,0 +1,1182 @@ +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 { + 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, + 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, + unlock_verified: 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>>, + cover: RefCell>, + albums: RefCell>, + items: RefCell>, + width: Cell, + generation: Cell, + total: Cell, + 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 !self.active() { + return; + } + self.next_request(); + self.loading.set(false); + self.total.set(0); + 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() { + 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, locked: bool) { + 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 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(); + } + if self.unlocked.get() { + 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()); + } + } + + 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)), + ); + wire_thumbnail(self, &picture, album.cover.as_deref(), private, None); + button + } + + 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.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 { + 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(); + 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 }, + ); + 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().clear(); + } + 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 { + 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(); + browser.restore_offset(generation, 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, 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()); + self.more.set_visible(false); + self.unlock.set_visible(false); + self.choose.set_visible(parent.is_some()); + 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(), + 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.")); + 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 + .status + .set_label(&gettext("Couldn't reach Proton Drive.")), + } + }); + } + + 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 update_root = matches!( + action, + GalleryAction::Add { .. } + | GalleryAction::Remove { .. } + | GalleryAction::Refresh + | GalleryAction::Cover { .. } + ); + self.unlock.set_visible(false); + 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 { + return; + } + match result { + Ok(Ok(Response::Ok { .. })) => { + 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(); + 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 + .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) { + if self.unlock_pending.replace(true) { + return; + } + 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); + } + } + }); + } + + 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) { + let choosing = self.chooser.borrow().is_some(); + if choosing { + 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.close(); + } + 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.unlocked.get() || self.current().is_some()) + { + self.load(0, previous.parent_offset); + } else { + self.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 private = self.unlocked.get(); + let request = if video { + Request::OpenGalleryVideo { + uid: item.uid, + private, + } + } else { + Request::OpenGalleryImage { + uid: item.uid, + private, + } + }; + 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 = 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 = adw::Dialog::builder() + .title(item.name.unwrap_or_else(|| gettext("Preview"))) + .content_width(850) + .content_height(600) + .build(); + 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))); + player.set_vexpand(true); + content.append(&player); + let socket = browser.ui.dirs.control_socket(); + preview.connect_closed(move |_| { + player.set_media_stream(gtk4::MediaStream::NONE); + let _ = spawn_request( + socket.clone(), + Request::CloseGalleryVideo { + token: token.clone(), + }, + ); + }); + } + Ok(Ok(Response::FilePath { path })) => { + let picture = gtk4::Picture::for_filename(path); + 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); + return; + } + _ => { + browser + .status + .set_label(&gettext("Couldn't open the file.")); + return; + } + } + browser.preview.set(Some(&preview)); + preview.present(Some(&parent)); + }); + } +} + +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.append(&choose); + let more = gtk4::Button::from_icon_name("view-more-symbolic"); + more.set_tooltip_text(Some(&gettext("Gallery Options"))); + 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() + .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); + 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(), + 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), + unlock_verified: 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), + 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), + thumbnails: RefCell::default(), + thumb_pending: RefCell::default(), + }); + *ui.drive_galleries.borrow_mut() = Rc::downgrade(&browser); + let weak = Rc::downgrade(&browser); + window.connect_is_active_notify(move |window| { + let Some(browser) = weak.upgrade() else { + return; + }; + if window.is_active() { + browser.reveal_verified(); + } else if browser.unlocked.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; + }; + 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.scroll.vadjustment().value())); + } + browser.browse_folders(0.0); + } + } + }); + line.append(&button); + } + Row::Albums(albums, width) => { + for album in albums { + let button = browser.album_tile(album, *width, browser.unlocked.get()); + 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), + item.kind == PhotoKind::Video, + browser.unlocked.get(), + ); + 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); + } + }); + add.connect_clicked({ + let browser = browser.clone(); + move |_| { + browser.enter(); + *browser.chooser.borrow_mut() = Some(Vec::new()); + browser.browse_folders(0.0); + } + }); + 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(|(folder, _)| folder.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.close() + }); + } else { + menu.item(&gettext("Refresh galleries"), { + let browser = browser.clone(); + move || browser.change(GalleryAction::Refresh) + }); + } + if let Some(album) = browser.current().filter(|album| !album.proton) { + 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.", + )); + } + }); + if !browser.unlocked.get() { + 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() + }, + 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, + 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 + } + }); +} + +fn tile( + browser: &Rc, + title: &str, + uid: 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) + .build(); + let label = gtk4::Label::new(Some(title)); + label.set_ellipsize(gtk4::pango::EllipsizeMode::End); + label.set_max_width_chars((width / 9).max(1)); + 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"); + 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); + 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); + } + 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; + }; + 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: key.2.clone(), + private, + }, + ); + let response = request.recv().await; + 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) + { + 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)); + } + }); + } +} diff --git a/crates/pdfs-gui/src/app/pages/login.rs b/crates/pdfs-gui/src/app/pages/login.rs index e7b0dc8..cc24e30 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.reset(); + } // 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..834788e 100644 --- a/crates/pdfs-gui/src/app/pages/photo_viewer.rs +++ b/crates/pdfs-gui/src/app/pages/photo_viewer.rs @@ -31,6 +31,11 @@ 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, + presence_loading: Cell, + presence_pending: Cell, + album: Option, pub(crate) spinner: Spinner, pub(crate) status: gtk4::Label, pub(crate) title: gtk4::Label, @@ -272,12 +277,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 +309,25 @@ 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(), + private: false, + } + } 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 +341,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 +504,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 @@ -1210,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(); @@ -1473,6 +1543,16 @@ 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), + 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, @@ -1515,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); @@ -1700,7 +1781,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 +2036,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 +2083,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..fd0770b 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,6 +492,10 @@ impl GalleryRow { /// The widgets [`build_gallery_page`] hands back to [`build_window`]. pub(crate) struct GalleryWidgets { + 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, @@ -737,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); @@ -815,11 +845,7 @@ 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(); + albums.add_css_class("photo-album-grid"); let albums_status = adw::StatusPage::builder() .icon_name("pdfs-album-symbolic") .vexpand(true) @@ -827,7 +853,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( @@ -840,9 +866,47 @@ 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(); + 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")); + 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() @@ -944,6 +1008,10 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) { ( frame.upcast(), GalleryWidgets { + drive_galleries, + drive_status, + add_gallery, + hidden_albums, model, groups, content, @@ -994,6 +1062,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 { @@ -1049,8 +1130,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() @@ -1058,7 +1140,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); @@ -1148,15 +1230,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")]; @@ -1250,6 +1341,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, @@ -1279,6 +1435,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. @@ -1296,31 +1456,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 @@ -1334,22 +1484,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); } } }); @@ -1382,6 +1528,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); @@ -1398,9 +1545,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); @@ -1710,7 +1858,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) }) @@ -2203,16 +2352,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 +2373,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 @@ -2832,17 +2949,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; @@ -3126,19 +3245,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()); } } } @@ -3149,7 +3269,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 { @@ -3165,7 +3289,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() { @@ -3182,48 +3307,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(); @@ -3284,7 +3405,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 { @@ -3308,11 +3429,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 @@ -3331,9 +3451,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) => { @@ -3382,19 +3530,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 @@ -3410,59 +3558,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); @@ -3470,16 +3635,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 @@ -3499,52 +3667,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(); @@ -3569,22 +3804,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; @@ -3630,21 +3849,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 @@ -3820,8 +4050,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 @@ -3953,10 +4183,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), @@ -3980,11 +4207,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(); @@ -4074,7 +4297,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. @@ -4256,6 +4479,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 @@ -4280,7 +4524,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); @@ -4306,8 +4550,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 @@ -4339,6 +4592,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()); @@ -4387,14 +4644,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 @@ -4452,6 +4719,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 eb3ac26..d00a5a0 100644 --- a/docs/CHANGELOG.md +++ b/docs/CHANGELOG.md @@ -11,6 +11,31 @@ 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 your Linux sign-in. + +### 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 until unlocked. +- 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. @@ -2372,6 +2397,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/docs/PHOTOS.md b/docs/PHOTOS.md index 80be461..75b70a4 100644 --- a/docs/PHOTOS.md +++ b/docs/PHOTOS.md @@ -1,5 +1,39 @@ # 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 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 +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`. diff --git a/packaging/PKGBUILD b/packaging/PKGBUILD index 35e839d..7d8a29a 100644 --- a/packaging/PKGBUILD +++ b/packaging/PKGBUILD @@ -9,13 +9,13 @@ # 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') 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/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/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 c2bce34..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 @@ -44,7 +46,10 @@ rustPlatform.buildRustPackage { ]; }; - cargoLock.lockFile = ../../Cargo.lock; + cargoLock = { + lockFile = ../../Cargo.lock; + allowBuiltinFetchGit = true; + }; cargoBuildFlags = [ "--bin" @@ -100,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 \ @@ -120,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 d383a70..8ee61ab 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. @@ -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:.} @@ -39,6 +39,7 @@ BuildRequires: glib2-devel BuildRequires: webkitgtk6.0-devel BuildRequires: gettext +Requires: polkit Requires: fuse3 Requires: gtk4 Requires: libadwaita @@ -72,16 +73,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 @@ -111,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 @@ -149,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" 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