π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
update(FileViewer):add-progres-for-video-fetching
Aswin Asok4bc9ddf45b1b
diff --git a/desktop/changes/viewer-download-progress.md b/desktop/changes/viewer-download-progress.mdnew file mode 100644index 0000000000..b2352f6a42--- /dev/null+++ b/desktop/changes/viewer-download-progress.md@@ -0,0 +1 @@+- Added download progress and a retry option when loading photos and videos in the viewer.diff --git a/web/apps/albums/src/public-album/viewer/components/PublicAlbumSingleFileViewer.tsx b/web/apps/albums/src/public-album/viewer/components/PublicAlbumSingleFileViewer.tsxindex d06106651b..7571adbe93 100644--- a/web/apps/albums/src/public-album/viewer/components/PublicAlbumSingleFileViewer.tsx+++ b/web/apps/albums/src/public-album/viewer/components/PublicAlbumSingleFileViewer.tsx@@ -131,10 +131,10 @@ export const PublicAlbumSingleFileViewer: React.FC<useEffect(() => {let classObserver: MutationObserver | undefined;- let preloaderObserver: MutationObserver | undefined;+ let progressObserver: MutationObserver | undefined;let errorObserver: MutationObserver | undefined;let pswpElement: HTMLElement | null = null;- let preloaderElement: HTMLElement | null = null;+ let progressElement: HTMLElement | null = null;let errorElement: HTMLElement | null = null;const updateVisibility = () => {@@ -145,8 +145,8 @@ export const PublicAlbumSingleFileViewer: React.FC<const updateLoading = () => {setIsPhotoSwipeContentLoading(- preloaderElement?.classList.contains(- "pswp__preloader--active",+ progressElement?.classList.contains(+ "pswp__ente-progress-text--active",) ?? false,);};@@ -158,22 +158,23 @@ export const PublicAlbumSingleFileViewer: React.FC<);};- const bindToPreloaderElement = () => {- const next =- pswpElement?.querySelector<HTMLElement>(".pswp__preloader");- if (next === preloaderElement) return;+ const bindToProgressElement = () => {+ const next = pswpElement?.querySelector<HTMLElement>(+ ".pswp__ente-progress-text",+ );+ if (next === progressElement) return;- preloaderObserver?.disconnect();- preloaderObserver = undefined;- preloaderElement = next ?? null;+ progressObserver?.disconnect();+ progressObserver = undefined;+ progressElement = next ?? null;- if (!preloaderElement) {+ if (!progressElement) {setIsPhotoSwipeContentLoading(false);return;}- preloaderObserver = new MutationObserver(updateLoading);- preloaderObserver.observe(preloaderElement, {+ progressObserver = new MutationObserver(updateLoading);+ progressObserver.observe(progressElement, {attributes: true,attributeFilter: ["class"],});@@ -210,11 +211,11 @@ export const PublicAlbumSingleFileViewer: React.FC<pswpElement = next;if (!pswpElement) {- preloaderObserver?.disconnect();- preloaderObserver = undefined;+ progressObserver?.disconnect();+ progressObserver = undefined;errorObserver?.disconnect();errorObserver = undefined;- preloaderElement = null;+ progressElement = null;errorElement = null;setIsPhotoSwipeUIVisible(true);setIsPhotoSwipeContentLoading(false);@@ -230,7 +231,7 @@ export const PublicAlbumSingleFileViewer: React.FC<updateVisibility();}- bindToPreloaderElement();+ bindToProgressElement();bindToErrorElement();};@@ -241,7 +242,7 @@ export const PublicAlbumSingleFileViewer: React.FC<return () => {treeObserver.disconnect();classObserver?.disconnect();- preloaderObserver?.disconnect();+ progressObserver?.disconnect();errorObserver?.disconnect();};}, []);@@ -525,7 +526,9 @@ export const PublicAlbumSingleFileViewer: React.FC<{ display: "none !important" },[`body.${bodyClassName} .pswp-ente-public-album .pswp__button--vol`]:{ display: "none !important" },- [`body.${bodyClassName} .pswp-ente-public-album .pswp__preloader`]:+ [`body.${bodyClassName} .pswp-ente-public-album .pswp__ente-progress-text`]:+ { display: "none !important" },+ [`body.${bodyClassName} .pswp-ente-public-album .pswp__ente-progress-bar`]:{ display: "none !important" },[`body.${bodyClassName} .pswp-ente-public-album .pswp__error`]:{ display: "none !important" },diff --git a/web/apps/albums/src/public-album/viewer/lib/photoswipe.ts b/web/apps/albums/src/public-album/viewer/lib/photoswipe.tsindex 7d8565dde4..d0e050e718 100644--- a/web/apps/albums/src/public-album/viewer/lib/photoswipe.ts+++ b/web/apps/albums/src/public-album/viewer/lib/photoswipe.ts@@ -1,3 +1,4 @@+import { downloadManager } from "@/public-album/download/services/download-manager";import {enteWordmarkSVGHTML,enteWordmarkViewBox,@@ -31,6 +32,10 @@ export type FileViewerPhotoSwipeOptions<>;const fileViewerPhotoSwipeDataSource = {+ fileDownloadProgressSubscribe: (onChange: () => void) =>+ downloadManager.fileDownloadProgressSubscribe(onChange),+ fileDownloadProgressSnapshot: () =>+ downloadManager.fileDownloadProgressSnapshot(),fileViewerDidClose,fileViewerWillOpen,forgetExifForItemData,diff --git a/web/apps/photos/tests/download-core.test.ts b/web/apps/photos/tests/download-core.test.tsnew file mode 100644index 0000000000..cff109544e--- /dev/null+++ b/web/apps/photos/tests/download-core.test.ts@@ -0,0 +1,157 @@+import { decryptStreamBytes } from "ente-base/crypto";+import {+ createDownloadManager,+ NetworkDownloadError,+ type FileDownloadProgress,+} from "ente-gallery/services/download-core";+import type { EnteFile } from "ente-media/file";+import { FileType } from "ente-media/file-type";+import { describe, expect, test, vi } from "vitest";++vi.mock("ente-base/crypto", () => ({+ decryptStreamBytes: vi.fn(),+ initChunkDecryption: vi+ .fn()+ .mockResolvedValue({ pullState: 0, decryptionChunkSize: 2 }),+ decryptStreamChunk: (data: Uint8Array<ArrayBuffer>) =>+ Promise.resolve(data),+}));+vi.mock("ente-base/blob-cache", () => ({ blobCache: vi.fn() }));+vi.mock("ente-base/log", () => ({+ default: { info: vi.fn(), error: vi.fn() },+}));++const file = {+ id: 42,+ metadata: { fileType: FileType.image },+ file: { decryptionHeader: "header" },+ key: "key",+ info: { fileSize: 5 },+} as EnteFile;++const managerFor = (response: Response) =>+ createDownloadManager({+ downloadFile: () => Promise.resolve(response),+ downloadThumbnail: vi.fn(),+ renderableImageBlob: vi.fn(),+ playableVideoURL: vi.fn(),+ });++describe("download byte progress", () => {+ test("notifies for every chunk and EOF, retaining 100% until decryption settles", async () => {+ const body = new ReadableStream<Uint8Array>({+ start(controller) {+ controller.enqueue(new Uint8Array([1, 2]));+ controller.enqueue(new Uint8Array([3, 4]));+ controller.enqueue(new Uint8Array([5, 6]));+ controller.close();+ },+ });+ const manager = managerFor(+ new Response(body, { headers: { "Content-Length": "6" } }),+ );+ const snapshots = [manager.fileDownloadProgressSnapshot()];+ const updates: (FileDownloadProgress | undefined)[] = [];+ manager.fileDownloadProgressSubscribe(() => {+ const snapshot = manager.fileDownloadProgressSnapshot();+ snapshots.push(snapshot);+ updates.push(snapshot.get(file.id));+ });+ const decrypting = Promise.withResolvers<undefined>();+ const decrypted = Promise.withResolvers<Uint8Array<ArrayBuffer>>();+ vi.mocked(decryptStreamBytes).mockImplementationOnce(() => {+ decrypting.resolve(undefined);+ return decrypted.promise;+ });+ const download = manager.fileStream(file);+ await decrypting.promise;+ expect(updates).toEqual([+ { loaded: 2, total: 6 },+ { loaded: 4, total: 6 },+ { loaded: 6, total: 6 },+ { loaded: 6, total: 6 },+ ]);+ decrypted.resolve(new Uint8Array([1, 2, 3]));+ await download;+ expect(updates).toHaveLength(5);+ expect(updates[4]).toBeUndefined();+ expect(new Set(snapshots).size).toBe(snapshots.length);+ expect(snapshots.map((snapshot) => snapshot.get(file.id))).toEqual([+ undefined,+ ...updates,+ ]);+ });++ test("a null body emits no synthetic progress or empty deletion", async () => {+ const manager = managerFor(new Response(null));+ const snapshot = manager.fileDownloadProgressSnapshot();+ const onChange = vi.fn();+ manager.fileDownloadProgressSubscribe(onChange);+ vi.mocked(decryptStreamBytes).mockResolvedValueOnce(new Uint8Array());+ await manager.fileStream(file);+ expect(onChange).not.toHaveBeenCalled();+ expect(manager.fileDownloadProgressSnapshot()).toBe(snapshot);+ });++ test("keeps video progress until EOF and closes the decrypted stream", async () => {+ const body = new ReadableStream<Uint8Array>({+ start(controller) {+ controller.enqueue(new Uint8Array([1, 2]));+ controller.enqueue(new Uint8Array([3, 4]));+ controller.enqueue(new Uint8Array([5, 6]));+ controller.close();+ },+ });+ const manager = managerFor(new Response(body));+ const updates: (FileDownloadProgress | undefined)[] = [];+ manager.fileDownloadProgressSubscribe(() => {+ updates.push(manager.fileDownloadProgressSnapshot().get(file.id));+ });+ const stream = await manager.fileStream({+ ...file,+ metadata: { ...file.metadata, fileType: FileType.video },+ });+ expect(+ new Uint8Array(await new Response(stream).arrayBuffer()),+ ).toEqual(new Uint8Array([1, 2, 3, 4, 5, 6]));+ expect(updates).toEqual([+ { loaded: 2, total: 5 },+ { loaded: 4, total: 5 },+ { loaded: 6, total: 5 },+ { loaded: 6, total: 6 },+ undefined,+ ]);+ });++ test.each([FileType.image, FileType.video])(+ "wraps a body read error and deletes progress for type %s",+ async (fileType) => {+ let reads = 0;+ const body = new ReadableStream<Uint8Array>({+ pull(controller) {+ if (reads++ == 0)+ controller.enqueue(new Uint8Array([1, 2]));+ else controller.error(new Error("connection lost"));+ },+ });+ const manager = managerFor(new Response(body));+ const updates: (FileDownloadProgress | undefined)[] = [];+ manager.fileDownloadProgressSubscribe(() => {+ updates.push(+ manager.fileDownloadProgressSnapshot().get(file.id),+ );+ });+ const download = manager+ .fileStream({+ ...file,+ metadata: { ...file.metadata, fileType },+ })+ .then((stream) => new Response(stream).arrayBuffer());+ await expect(download).rejects.toBeInstanceOf(NetworkDownloadError);+ expect(updates).toEqual([{ loaded: 2, total: 5 }, undefined]);+ expect(manager.fileDownloadProgressSnapshot().has(file.id)).toBe(+ false,+ );+ },+ );+});diff --git a/web/apps/photos/tests/download-progress.test.ts b/web/apps/photos/tests/download-progress.test.tsnew file mode 100644index 0000000000..21ee216355--- /dev/null+++ b/web/apps/photos/tests/download-progress.test.ts@@ -0,0 +1,121 @@+import { downloadProgressState } from "ente-gallery/components/viewer/download-progress";+import { describe, expect, test } from "vitest";++const loading = { isContentLoading: true };++describe("downloadProgressState", () => {+ test("keeps decrypting during the live-photo conversion tail", () => {+ const downloaded = downloadProgressState(+ loading,+ { loaded: 100, total: 100 },+ undefined,+ );+ expect(downloaded).toEqual({+ phase: "decrypting",+ pct: 100,+ loaded: 100,+ total: 100,+ });+ const tail = downloadProgressState(loading, undefined, downloaded);+ expect(tail).toEqual({ phase: "decrypting", pct: 100 });+ expect(downloadProgressState(loading, undefined, tail)).toEqual(tail);+ });++ test("prepares HLS auto video without a download entry, then hides", () => {+ const preparing = downloadProgressState(loading, undefined, undefined);+ expect(preparing).toEqual({ phase: "preparing", pct: 0 });+ expect(downloadProgressState({}, undefined, preparing)).toBeUndefined();+ });++ test("hides cached content regardless of previous progress or an entry", () => {+ expect(+ downloadProgressState(+ {},+ { loaded: 30, total: 100 },+ { phase: "downloading", pct: 30 },+ ),+ ).toBeUndefined();+ expect(+ downloadProgressState({}, undefined, { phase: "failed", pct: 70 }),+ ).toBeUndefined();+ });++ test("clamps ciphertext exceeding the plaintext size fallback", () => {+ expect(+ downloadProgressState(+ loading,+ { loaded: 117, total: 100 },+ undefined,+ ),+ ).toEqual({ phase: "decrypting", pct: 100, loaded: 117, total: 100 });+ });++ test("shows unknown totals as indeterminate and retains the download tail", () => {+ const state = downloadProgressState(+ loading,+ { loaded: 30, total: undefined },+ undefined,+ );+ expect(state).toEqual({+ phase: "downloading",+ pct: undefined,+ loaded: 30,+ });+ expect(downloadProgressState(loading, undefined, state)).toEqual({+ phase: "decrypting",+ pct: 100,+ });+ });++ test("failure takes precedence and keeps the previous percentage", () => {+ expect(+ downloadProgressState({ fetchFailed: true }, undefined, {+ phase: "downloading",+ pct: 42,+ }),+ ).toEqual({ phase: "failed", pct: 42 });+ expect(+ downloadProgressState(+ { ...loading, fetchFailed: true },+ { loaded: 100, total: 100 },+ undefined,+ ),+ ).toEqual({ phase: "failed", pct: 0 });+ });++ test("retry ignores the previous failed percentage", () => {+ expect(+ downloadProgressState(loading, undefined, {+ phase: "failed",+ pct: 42,+ }),+ ).toEqual({ phase: "preparing", pct: 0 });+ });++ test("opens on an in-flight download without previous state", () => {+ expect(+ downloadProgressState(+ loading,+ { loaded: 30, total: 100 },+ undefined,+ ),+ ).toEqual({ phase: "downloading", pct: 30, loaded: 30, total: 100 });+ });++ test("prepares a known total with no bytes and floors partial percentages", () => {+ expect(+ downloadProgressState(+ loading,+ { loaded: 0, total: 100 },+ undefined,+ ),+ ).toEqual({ phase: "preparing", pct: 0 });+ expect(+ downloadProgressState(+ loading,+ { loaded: 9999, total: 10000 },+ undefined,+ )?.pct,+ ).toBe(99);+ });+});diff --git a/web/packages/base/locales/en-US/translation.json b/web/packages/base/locales/en-US/translation.jsonindex 07c7946b86..dd632cdfa3 100644--- a/web/packages/base/locales/en-US/translation.json+++ b/web/packages/base/locales/en-US/translation.json@@ -942,6 +942,10 @@"downloading_album": "Downloading {{name}}","creating_zip": "Creating ZIP for {{name}}","downloading": "Downloading",+ "size_downloaded": "{{size}} downloaded",+ "preparing_download": "Preparing download",+ "decrypting": "Decrypting",+ "couldnt_download": "Couldn't download","preparing_part": "Preparing Part {{part}}","downloading_part": "Downloading Part {{part}}","downloading_file": "Downloading file",diff --git a/web/packages/gallery/components/viewer/download-progress.ts b/web/packages/gallery/components/viewer/download-progress.tsnew file mode 100644index 0000000000..7c879010d4--- /dev/null+++ b/web/packages/gallery/components/viewer/download-progress.ts@@ -0,0 +1,50 @@+import type { FileDownloadProgress } from "ente-gallery/services/download-core";+import type { ItemData } from "./data-source-core";++export type DownloadProgressPhase =+ | "preparing"+ | "downloading"+ | "decrypting"+ | "failed";++export interface DownloadProgressState {+ phase: DownloadProgressPhase;+ pct: number | undefined;+ loaded?: number;+ total?: number;+}++export const downloadProgressState = (+ itemData: Pick<ItemData, "isContentLoading" | "fetchFailed">,+ entry: FileDownloadProgress | undefined,+ previous: DownloadProgressState | undefined,+): DownloadProgressState | undefined => {+ if (itemData.fetchFailed)+ return { phase: "failed", pct: previous?.pct ?? 0 };+ if (!itemData.isContentLoading) return undefined;++ if (entry) {+ const { loaded, total } = entry;+ if (total !== undefined && total > 0) {+ if (loaded >= total)+ return { phase: "decrypting", pct: 100, loaded, total };+ if (loaded > 0)+ return {+ phase: "downloading",+ pct: Math.min(99, Math.floor((loaded * 100) / total)),+ loaded,+ total,+ };+ return { phase: "preparing", pct: 0 };+ }+ if (total === undefined && loaded > 0)+ return { phase: "downloading", pct: undefined, loaded };+ } else if (+ previous?.phase == "downloading" ||+ previous?.phase == "decrypting"+ ) {+ // ponytail: conversion shares the decrypting phase; split it when the data source reports conversion progress.+ return { phase: "decrypting", pct: 100 };+ }+ return { phase: "preparing", pct: 0 };+};diff --git a/web/packages/gallery/components/viewer/photoswipe-core.ts b/web/packages/gallery/components/viewer/photoswipe-core.tsindex 68d3e57290..7a919872c7 100644--- a/web/packages/gallery/components/viewer/photoswipe-core.ts+++ b/web/packages/gallery/components/viewer/photoswipe-core.ts@@ -1,5 +1,7 @@import { isNamedError } from "ente-base/error";import log from "ente-base/log";+import type { FileDownloadProgress } from "ente-gallery/services/download-core";+import { formattedByteSize } from "ente-gallery/utils/units";import type { EnteFile } from "ente-media/file";import { FileType } from "ente-media/file-type";import "hls-video-element";@@ -10,6 +12,10 @@ import "media-chrome/menu";import { MediaChromeMenu, MediaChromeMenuButton } from "media-chrome/menu";import PhotoSwipe, { type SlideData } from "photoswipe";import type { ItemData, ItemDataOpts } from "./data-source-core";+import {+ downloadProgressState,+ type DownloadProgressState,+} from "./download-progress";import {commentSVGPath,createPSRegisterElementIconHTML,@@ -28,6 +34,11 @@ export interface FileViewerPhotoSwipeAnnotatedFile {}export interface FileViewerPhotoSwipeDataSource {+ fileDownloadProgressSubscribe: (onChange: () => void) => () => void;+ fileDownloadProgressSnapshot: () => ReadonlyMap<+ number,+ FileDownloadProgress+ >;fileViewerDidClose: () => void;fileViewerWillOpen: () => void;forgetExifForItemData: (itemData: ItemData) => void;@@ -792,6 +803,12 @@ export class FileViewerPhotoSwipe<if (currentFileAnnotation().showDownload) handleDownload();};+ const refetchCurrentSlide = (fileID: number) => {+ dataSource.forgetItemDataForFileID(fileID);+ _currentAnnotatedFile = undefined;+ pswp.refreshSlideContent(pswp.currIndex);+ };+const onVideoQualityChange = () => {if (shouldIgnoreNextVideoQualityChange) {shouldIgnoreNextVideoQualityChange = false;@@ -801,14 +818,13 @@ export class FileViewerPhotoSwipe<toggleMediaChromeSettingsMenu();const fileID = currentAnnotatedFile().file.id;- dataSource.forgetItemDataForFileID(fileID);if (originalVideoFileIDs.has(fileID)) {originalVideoFileIDs.delete(fileID);} else {originalVideoFileIDs.add(fileID);}- pswp.refreshSlideContent(pswp.currIndex);+ refetchCurrentSlide(fileID);};const showIf = (element: HTMLElement, condition: boolean) =>@@ -816,11 +832,236 @@ export class FileViewerPhotoSwipe<? element.classList.remove("pswp__hidden"): element.classList.add("pswp__hidden");+ let unsubscribeDownloadProgress: (() => void) | undefined;+ let downloadProgressTimer: ReturnType<typeof setTimeout> | undefined;+pswp.on("uiRegister", () => {const ui = pswp.ui!;ui.uiElementsData.find((e) => e.name == "zoom")!.order = 6;- ui.uiElementsData.find((e) => e.name == "preloader")!.order = 10;+ const preloaderIndex = ui.uiElementsData.findIndex(+ (e) => e.name == "preloader",+ );+ if (preloaderIndex != -1)+ ui.uiElementsData.splice(preloaderIndex, 1);++ const lastProgressByFileID = new Map<+ number,+ DownloadProgressState+ >();+ const compactProgress = window.matchMedia("(width < 450px)");+ let progressText: HTMLElement;+ let progressValue: HTMLElement;+ let progressRing: SVGCircleElement;+ let progressBar: HTMLElement;+ let fill: HTMLElement;+ let pct: HTMLElement;+ let status: HTMLElement;+ let separator: HTMLElement;+ let size: HTMLElement;+ let retry: HTMLButtonElement;+ let progressClosed = false;++ const setText = (element: HTMLElement, text: string) => {+ if (element.textContent != text) element.textContent = text;+ };+ const setAttribute = (+ element: HTMLElement,+ name: string,+ value: string | undefined,+ ) => {+ if (element.getAttribute(name) == (value ?? null)) return;+ if (value === undefined) element.removeAttribute(name);+ else element.setAttribute(name, value);+ };+ const rememberDownloadProgress = () => {+ if (progressClosed || !pswp.currSlide) return;+ const itemData = currSlideData();+ const { fileID } = itemData;+ const state = downloadProgressState(+ itemData,+ dataSource.fileDownloadProgressSnapshot().get(fileID),+ lastProgressByFileID.get(fileID),+ );+ if (state) lastProgressByFileID.set(fileID, state);+ else lastProgressByFileID.delete(fileID);+ return state;+ };+ const renderDownloadProgress = () => {+ if (progressClosed || !pswp.currSlide) return;+ const state = rememberDownloadProgress();++ const failed = state?.phase == "failed";+ const pctText = state?.pct === undefined ? "" : `${state.pct}%`;+ const statusText = state+ ? t(+ {+ preparing: "preparing_download",+ downloading: "downloading",+ decrypting: "decrypting",+ failed: "couldnt_download",+ }[state.phase],+ )+ : "";+ const sizeText =+ state?.phase != "preparing" &&+ state?.total !== undefined &&+ state.loaded !== undefined+ ? compactProgress.matches+ ? t("size_downloaded", {+ size: `${formattedByteSize(state.loaded, 1)} / ${formattedByteSize(state.total, 1)}`,+ })+ : `${formattedByteSize(state.loaded, 1)} / ${formattedByteSize(state.total, 1)}`+ : "";+ setText(pct, pctText);+ setText(status, statusText);+ setText(size, sizeText);+ setText(retry, t("retry"));+ size.hidden = !sizeText;+ separator.hidden = !(sizeText || failed);+ retry.hidden = !failed;+ fill.style.width = `${Math.max(state?.pct ?? 0, 1)}%`;+ progressRing.style.strokeDashoffset = `${100 - (state?.pct ?? 0)}`;+ for (const [element, prefix] of [+ [progressText, "pswp__ente-progress-text"],+ [progressValue, "pswp__ente-progress-overlay"],+ [progressBar, "pswp__ente-progress-bar"],+ ] as const) {+ element.classList.toggle(`${prefix}--active`, !!state);+ element.classList.toggle(`${prefix}--failed`, failed);+ element.classList.toggle(+ `${prefix}--indeterminate`,+ !!state && state.pct === undefined,+ );+ }+ setAttribute(+ progressText,+ "aria-hidden",+ state ? undefined : "true",+ );+ setAttribute(+ progressValue,+ "aria-hidden",+ state ? undefined : "true",+ );+ setAttribute(+ progressValue,+ "aria-valuenow",+ state?.pct?.toString(),+ );+ setAttribute(+ progressValue,+ "aria-valuetext",+ [+ pctText,+ !(compactProgress.matches && sizeText) && statusText,+ !compactProgress.matches && (sizeText || failed) && "Β·",+ sizeText,+ failed && t("retry"),+ ]+ .filter(Boolean)+ .join(" "),+ );+ };++ ui.registerElement({+ name: "ente-progress-text",+ order: 10,+ isButton: false,+ html: `<span class="pswp__ente-progress-status"></span>+<span class="pswp__ente-progress-separator" hidden>Β·</span>+<span class="pswp__ente-progress-size" hidden></span>+<button type="button" class="pswp__ente-progress-retry" hidden></button>`,+ onInit: (element) => {+ progressText = element;+ status = element.querySelector<HTMLElement>(+ ".pswp__ente-progress-status",+ )!;+ separator = element.querySelector<HTMLElement>(+ ".pswp__ente-progress-separator",+ )!;+ size = element.querySelector<HTMLElement>(+ ".pswp__ente-progress-size",+ )!;+ retry = element.querySelector<HTMLButtonElement>(+ ".pswp__ente-progress-retry",+ )!;+ retry.addEventListener("click", () => {+ const { fileID } = currSlideData();+ lastProgressByFileID.delete(fileID);+ refetchCurrentSlide(fileID);+ });+ },+ });+ ui.registerElement({+ name: "ente-progress-overlay",+ appendTo: "root",+ order: 10,+ isButton: false,+ html: `<svg class="pswp__ente-progress-ring" viewBox="0 0 48 48" aria-hidden="true">+<circle cx="24" cy="24" r="20" pathLength="100" />+</svg>+<span class="pswp__ente-progress-pct"></span>`,+ onInit: (element) => {+ progressValue = element;+ progressRing = element.querySelector("circle")!;+ pct = element.querySelector<HTMLElement>(+ ".pswp__ente-progress-pct",+ )!;+ element.setAttribute("role", "progressbar");+ element.setAttribute("aria-label", t("download"));+ element.setAttribute("aria-valuemin", "0");+ element.setAttribute("aria-valuemax", "100");+ element.setAttribute("aria-hidden", "true");+ },+ });+ ui.registerElement({+ name: "ente-progress-bar",+ appendTo: "root",+ order: 0,+ html: '<div class="pswp__ente-progress-fill"></div>',+ onInit: (element) => {+ progressBar = element;+ fill = element.querySelector<HTMLElement>(+ ".pswp__ente-progress-fill",+ )!;+ element.setAttribute("aria-hidden", "true");+ const unsubscribe =+ dataSource.fileDownloadProgressSubscribe(() => {+ const state = rememberDownloadProgress();+ if (!state || downloadProgressTimer !== undefined)+ return;+ downloadProgressTimer = setTimeout(() => {+ downloadProgressTimer = undefined;+ renderDownloadProgress();+ }, 400);+ });+ compactProgress.addEventListener(+ "change",+ renderDownloadProgress,+ );+ unsubscribeDownloadProgress = () => {+ unsubscribe();+ compactProgress.removeEventListener(+ "change",+ renderDownloadProgress,+ );+ };+ pswp.on("change", renderDownloadProgress);+ pswp.on("close", () => {+ progressClosed = true;+ progressBar.classList.remove(+ "pswp__ente-progress-bar--active",+ );+ progressText.classList.remove(+ "pswp__ente-progress-text--active",+ );+ progressValue.classList.remove(+ "pswp__ente-progress-overlay--active",+ );+ });+ },+ });if (isPublicAlbum && publicAlbumLogoHTML) {ui.registerElement({@@ -1317,6 +1558,9 @@ export class FileViewerPhotoSwipe<});pswp.on("destroy", () => {+ unsubscribeDownloadProgress?.();+ if (downloadProgressTimer !== undefined)+ clearTimeout(downloadProgressTimer);pswp.element?.removeEventListener("mousedown",blurMediaChromeFocus,diff --git a/web/packages/gallery/components/viewer/photoswipe.ts b/web/packages/gallery/components/viewer/photoswipe.tsindex 736e9717b6..1ac2ad8a6f 100644--- a/web/packages/gallery/components/viewer/photoswipe.ts+++ b/web/packages/gallery/components/viewer/photoswipe.ts@@ -1,3 +1,4 @@+import { downloadManager } from "ente-gallery/services/download";import {fileViewerDidClose,fileViewerWillOpen,@@ -27,6 +28,10 @@ export type FileViewerPhotoSwipeOptions<>;const fileViewerPhotoSwipeDataSource = {+ fileDownloadProgressSubscribe: (onChange: () => void) =>+ downloadManager.fileDownloadProgressSubscribe(onChange),+ fileDownloadProgressSnapshot: () =>+ downloadManager.fileDownloadProgressSnapshot(),fileViewerDidClose,fileViewerWillOpen,forgetExifForItemData,diff --git a/web/packages/gallery/services/download-core.ts b/web/packages/gallery/services/download-core.tsindex f2f22c81bf..406dce7a19 100644--- a/web/packages/gallery/services/download-core.ts+++ b/web/packages/gallery/services/download-core.ts@@ -27,6 +27,11 @@ export type RenderableSourceURLs =videoURL: () => Promise<string>;};+export interface FileDownloadProgress {+ loaded: number;+ total: number | undefined;+}+export interface FileDownloadOpts {background?: boolean;}@@ -57,7 +62,7 @@ export class DownloadManagerCore {Promise<RenderableSourceURLs>>();- private fileDownloadProgress = new Map<number, number>();+ private fileDownloadProgress = new Map<number, FileDownloadProgress>();private fileDownloadProgressListeners: (() => void)[] = [];constructor(private transport: DownloadManagerTransport) {}@@ -92,13 +97,29 @@ export class DownloadManagerCore {};}- fileDownloadProgressSnapshot() {+ fileDownloadProgressSnapshot(): ReadonlyMap<number, FileDownloadProgress> {return this.fileDownloadProgress;}- private setFileDownloadProgress(progress: Map<number, number>) {- this.fileDownloadProgress = progress;- this.fileDownloadProgressListeners.forEach((l) => l());+ private setFileDownloadProgress(+ fileID: number,+ progress: FileDownloadProgress | undefined,+ ) {+ const next = new Map(this.fileDownloadProgress);+ if (progress) {+ next.set(fileID, progress);+ } else if (!next.delete(fileID)) {+ return;+ }+ this.fileDownloadProgress = next;+ this.fileDownloadProgressListeners.forEach((listener) => {+ try {+ listener();+ } catch (e) {+ // A UI observer must not interrupt the download stream.+ log.error("Failed to notify download progress listener", e);+ }+ });}// Returned object URLs are cache-owned; callers must not revoke them.@@ -239,99 +260,144 @@ export class DownloadManagerCore {): Promise<ReadableStream<Uint8Array> | null> {log.info(`download attempted for file id ${file.id}`);- const res = await wrapErrors(() =>- this.transport.downloadFile(file, opts),- );-- if (- file.metadata.fileType == FileType.image ||- file.metadata.fileType == FileType.livePhoto- ) {- const encryptedData = new Uint8Array(- await wrapErrors(() => res.arrayBuffer()),- );-- const decrypted = await decryptStreamBytes(- { encryptedData, decryptionHeader: file.file.decryptionHeader },- file.key,+ try {+ const res = await wrapErrors(() =>+ this.transport.downloadFile(file, opts),);- return new Response(decrypted).body;- }-- const body = res.body;- if (!body) return null;- const reader = body.getReader();-- const onDownloadProgress = this.trackDownloadProgress(- file.id,- file.info?.fileSize,- );-- const contentLength =- parseInt(res.headers.get("Content-Length") ?? "") || 0;- let downloadedBytes = 0;-- const { pullState, decryptionChunkSize } = await initChunkDecryption(- file.file.decryptionHeader,- file.key,- );-- let leftoverBytes: Uint8Array = new Uint8Array();-- return new ReadableStream({- pull: async (controller) => {- // Each pull must enqueue or close before returning.- let didEnqueue = false;- do {- const { done, value } = await wrapErrors(() =>- reader.read(),- );-- let data: Uint8Array;- if (done) {- data = leftoverBytes;- } else {- downloadedBytes += value.length;- onDownloadProgress({- loaded: downloadedBytes,- total: contentLength,+ const total =+ parseInt(res.headers.get("Content-Length") ?? "") ||+ file.info?.fileSize ||+ undefined;+ let loaded = 0;++ if (+ file.metadata.fileType == FileType.image ||+ file.metadata.fileType == FileType.livePhoto+ ) {+ const encryptedData = new Uint8Array(+ await wrapErrors(async () => {+ if (!res.body) return res.arrayBuffer();+ const counter = new TransformStream<+ Uint8Array,+ Uint8Array+ >({+ transform: (chunk, controller) => {+ loaded += chunk.byteLength;+ this.setFileDownloadProgress(file.id, {+ loaded,+ total,+ });+ controller.enqueue(chunk);+ },+ flush: () => {+ this.setFileDownloadProgress(file.id, {+ loaded,+ total: loaded,+ });+ },});+ return new Response(+ res.body.pipeThrough(counter),+ ).arrayBuffer();+ }),+ );+ const decrypted = await decryptStreamBytes(+ {+ encryptedData,+ decryptionHeader: file.file.decryptionHeader,+ },+ file.key,+ );+ this.setFileDownloadProgress(file.id, undefined);+ return new Response(decrypted).body;+ }- data = new Uint8Array(- leftoverBytes.length + value.length,- );- data.set(new Uint8Array(leftoverBytes), 0);- data.set(new Uint8Array(value), leftoverBytes.length);- }-- // A network read can contain several encrypted chunks.- while (data.length >= decryptionChunkSize) {- const decryptedData = await decryptStreamChunk(- data.slice(0, decryptionChunkSize),- pullState,- );- controller.enqueue(decryptedData);- didEnqueue = true;- data = data.slice(decryptionChunkSize);- }-- if (done) {- // Only EOF proves that a short remainder is the final chunk.- if (data.length) {- const decryptedData = await decryptStreamChunk(- data,- pullState,+ const body = res.body;+ if (!body) return null;+ const reader = body.getReader();+ const { pullState, decryptionChunkSize } =+ await initChunkDecryption(file.file.decryptionHeader, file.key);+ let leftoverBytes: Uint8Array = new Uint8Array();++ return new ReadableStream({+ pull: async (controller) => {+ try {+ // Each pull must enqueue or close before returning.+ let didEnqueue = false;+ do {+ const { done, value } = await wrapErrors(() =>+ reader.read(),);- controller.enqueue(decryptedData);- }- didEnqueue = true;- controller.close();- } else {- leftoverBytes = data;++ let data: Uint8Array;+ if (done) {+ this.setFileDownloadProgress(file.id, {+ loaded,+ total: loaded,+ });+ data = leftoverBytes;+ } else {+ loaded += value.length;+ this.setFileDownloadProgress(file.id, {+ loaded,+ total,+ });++ data = new Uint8Array(+ leftoverBytes.length + value.length,+ );+ data.set(new Uint8Array(leftoverBytes), 0);+ data.set(+ new Uint8Array(value),+ leftoverBytes.length,+ );+ }++ // A network read can contain several encrypted chunks.+ while (data.length >= decryptionChunkSize) {+ const decryptedData = await decryptStreamChunk(+ data.slice(0, decryptionChunkSize),+ pullState,+ );+ controller.enqueue(decryptedData);+ didEnqueue = true;+ data = data.slice(decryptionChunkSize);+ }++ if (done) {+ // Only EOF proves that a short remainder is the final chunk.+ if (data.length) {+ const decryptedData =+ await decryptStreamChunk(+ data,+ pullState,+ );+ controller.enqueue(decryptedData);+ }+ didEnqueue = true;+ controller.close();+ this.setFileDownloadProgress(+ file.id,+ undefined,+ );+ } else {+ leftoverBytes = data;+ }+ } while (!didEnqueue);+ } catch (e) {+ this.setFileDownloadProgress(file.id, undefined);+ throw e;}- } while (!didEnqueue);- },- });+ },+ cancel: (reason: unknown) => {+ this.setFileDownloadProgress(file.id, undefined);+ return reader.cancel(reason);+ },+ });+ } catch (e) {+ this.setFileDownloadProgress(file.id, undefined);+ throw e;+ }}private async blobWithInferredType(@@ -352,30 +418,6 @@ export class DownloadManagerCore {return blob;}}-- private trackDownloadProgress(- fileID: number,- fileSize: number | undefined,- ) {- return (event: { loaded: number; total: number }) => {- if (isNaN(event.total) || event.total === 0) {- if (!fileSize) {- return;- }- event.total = fileSize;- }- const progress = new Map(this.fileDownloadProgress);- if (event.loaded === event.total) {- progress.delete(fileID);- } else {- progress.set(- fileID,- Math.round((event.loaded * 100) / event.total),- );- }- this.setFileDownloadProgress(progress);- };- }}export const createDownloadManager = (transport: DownloadManagerTransport) =>diff --git a/web/packages/gallery/styles/photoswipe.css b/web/packages/gallery/styles/photoswipe.cssindex 2460a27468..c225ee80fe 100644--- a/web/packages/gallery/styles/photoswipe.css+++ b/web/packages/gallery/styles/photoswipe.css@@ -44,10 +44,6 @@pointer-events: auto;}-.pswp-ente .pswp__preloader--active .pswp__icn {- opacity: 0.4;-}-.pswp-ente .pswp__error {position: relative;overflow: hidden;@@ -106,10 +102,6 @@}}-.pswp-ente .pswp__preloader {- transform: translate(-2px, 2px);-}-.pswp-ente .pswp__error {transform: translate(-2px, 2px);}@@ -529,3 +521,219 @@ body:has(#pswp__icn-heart.pswp__hidden {display: none;}++/* Root progress survives PhotoSwipe chrome auto-hide, including fullscreen. */+.pswp.pswp-ente .pswp__ente-progress-bar {+ position: absolute;+ top: calc(env(titlebar-area-height, 0px) * 0.4);+ left: 0;+ right: 0;+ height: 3px;+ background: rgb(255 255 255 / 0.16);+ pointer-events: none;+ opacity: 0;+ transition: opacity 160ms linear;+ transition-delay: 0ms;+}++.pswp.pswp-ente .pswp__ente-progress-bar--active {+ opacity: 1;+ transition-delay: 400ms;+}++.pswp-ente .pswp__ente-progress-fill {+ height: 3px;+ width: 1%;+ background: var(--mui-palette-fixed-success);+ transition: width 400ms linear;+}++.pswp-ente .pswp__ente-progress-bar--failed .pswp__ente-progress-fill {+ background: var(--mui-palette-fixed-danger-main);+}++.pswp-ente .pswp__ente-progress-bar--indeterminate .pswp__ente-progress-fill {+ animation: ente-progress-pulse 1s ease-in-out infinite alternate;+}++@keyframes ente-progress-pulse {+ to {+ opacity: 0.35;+ }+}++.pswp-ente .pswp__ente-progress-text {+ margin-inline-start: 6px;+ margin-top: 22px;+ margin-inline-end: auto;+ display: flex;+ align-items: center;+ gap: 8px;+ height: 20px;+ min-width: 0;+ overflow: hidden;+ white-space: nowrap;+ text-shadow: 0 1px 3px rgb(0 0 0 / 0.6);+ font-size: 13px;+ line-height: 20px;+ color: rgb(255 255 255 / 0.6);+ opacity: 0;+ visibility: hidden;+ transition: opacity 160ms linear;+ transition-delay: 0ms;+}++.pswp-ente .pswp__ente-progress-text--active {+ opacity: 1;+ visibility: visible;+ transition-delay: 400ms;+}++.pswp-ente .pswp__ente-progress-status,+.pswp-ente .pswp__ente-progress-size {+ min-width: 0;+ overflow: hidden;+ text-overflow: ellipsis;+ flex: 0 1 auto;+}++.pswp-ente+ .pswp__ente-progress-text--active:not(.pswp__ente-progress-text--failed)+ .pswp__ente-progress-status::after {+ content: "";+ display: inline-block;+ width: 1.2em;+ text-align: left;+ animation: ente-progress-dots 1.2s steps(1, end) infinite;++ @media (prefers-reduced-motion: reduce) {+ content: "β¦";+ animation: none;+ }+}++@keyframes ente-progress-dots {+ 0%,+ 100% {+ content: "";+ }+ 25% {+ content: ".";+ }+ 50% {+ content: "..";+ }+ 75% {+ content: "...";+ }+}++.pswp-ente .pswp__ente-progress-separator,+.pswp-ente .pswp__ente-progress-retry {+ flex-shrink: 0;+}++.pswp.pswp-ente .pswp__ente-progress-overlay {+ position: absolute;+ top: 50%;+ left: 50%;+ transform: translate(-50%, -50%);+ display: grid;+ place-items: center;+ box-sizing: border-box;+ width: 48px;+ height: 48px;+ border: 1px solid rgb(255 255 255 / 0.16);+ border-radius: 50%;+ background: rgb(0 0 0 / 0.3);+ pointer-events: none;+ opacity: 0;+ visibility: hidden;+ transition: opacity 160ms linear;+}++.pswp.pswp-ente .pswp__ente-progress-overlay--active {+ opacity: 1;+ visibility: visible;+ transition-delay: 400ms;+}++.pswp-ente .pswp__ente-progress-ring {+ position: absolute;+ width: 100%;+ height: 100%;+ transform: rotate(-90deg);+ fill: none;+ stroke: var(--mui-palette-fixed-success);+ stroke-width: 2;+ stroke-linecap: round;+ stroke-dasharray: 100;+}++.pswp-ente .pswp__ente-progress-overlay--failed .pswp__ente-progress-ring {+ stroke: var(--mui-palette-fixed-danger-main);+}++.pswp-ente+ .pswp__ente-progress-overlay--indeterminate+ .pswp__ente-progress-ring {+ stroke-dasharray: 25 75;+ animation: ente-progress-spin 1s linear infinite;+}++@keyframes ente-progress-spin {+ to {+ transform: rotate(270deg);+ }+}++.pswp-ente .pswp__ente-progress-pct {+ color: #fff;+ font-size: 11px;+ font-weight: 600;+ font-variant-numeric: tabular-nums;+}++.pswp-ente .pswp__ente-progress-size {+ font-variant-numeric: tabular-nums;+}++.pswp-ente .pswp__ente-progress-retry {+ border: 0;+ padding: 0;+ background: none;+ color: #fff;+ font: inherit;+ text-shadow: inherit;+ cursor: pointer;+}++.pswp-ente .pswp__ente-progress-retry:hover {+ text-decoration: underline;+}++@media (width < 450px) {+ .pswp-ente .pswp__ente-progress-text::before {+ content: "Β·";+ flex-shrink: 0;+ color: rgb(255 255 255 / 0.4);+ }++ .pswp-ente+ .pswp__ente-progress-text:has(.pswp__ente-progress-size:not([hidden]))+ .pswp__ente-progress-status,+ .pswp-ente .pswp__ente-progress-separator {+ display: none;+ }+}++@media (prefers-reduced-motion: reduce) {+ .pswp.pswp-ente .pswp__ente-progress-bar,+ .pswp.pswp-ente .pswp__ente-progress-overlay,+ .pswp.pswp-ente .pswp__ente-progress-ring,+ .pswp-ente .pswp__ente-progress-text,+ .pswp.pswp-ente .pswp__ente-progress-fill {+ transition: none;+ animation: none;+ }+}