Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

update(FileViewer):add-progres-for-video-fetching

Aswin Asok4bc9ddf45b1b
diff --git a/desktop/changes/viewer-download-progress.md b/desktop/changes/viewer-download-progress.md
new file mode 100644
index 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.tsx
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.json
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.css
index 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;
+ }
+}