π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
feat(streaming):show-precentage-progress
Aswin Asok0a7d3f93cb88
diff --git a/web/apps/photos/src/components/Sidebar.tsx b/web/apps/photos/src/components/Sidebar.tsxindex 1f6a829f56..8476e6bca3 100644--- a/web/apps/photos/src/components/Sidebar.tsx+++ b/web/apps/photos/src/components/Sidebar.tsx@@ -1215,6 +1215,9 @@ const Preferences: React.FC<PreferencesProps> = ({const hlsGenStatusSnapshot = useHLSGenerationStatusSnapshot();const isHLSGenerationEnabled = !!hlsGenStatusSnapshot?.enabled;+ const hlsProcessedFraction = hlsGenStatusSnapshot?.enabled+ ? hlsGenStatusSnapshot.processedFraction+ : undefined;useEffect(() => {if (open) void pullSettings();@@ -1299,13 +1302,41 @@ const Preferences: React.FC<PreferencesProps> = ({/>)}{isHLSGenerationSupported && (- <RowButtonGroup>- <RowSwitch- label={t("streamable_videos")}- checked={isHLSGenerationEnabled}- onClick={() => void toggleHLSGeneration()}- />- </RowButtonGroup>+ <Stack>+ <RowButtonGroup>+ <RowSwitch+ label={t("streamable_videos")}+ checked={isHLSGenerationEnabled}+ onClick={() => void toggleHLSGeneration()}+ />+ </RowButtonGroup>+ {isHLSGenerationEnabled && (+ <SpacedRow sx={{ gap: 2, px: 2, pt: 2, pb: 1 }}>+ <Typography sx={{ color: "text.faint" }}>+ {t("processed")}+ </Typography>+ {hlsProcessedFraction == undefined ? (+ <RowButtonEndActivityIndicator />+ ) : (+ <Typography sx={{ textAlign: "right" }}>+ {t("percent_complete", {+ percent: hlsProcessedFraction * 100,+ formatParams: {+ percent: {+ minimumFractionDigits:+ hlsProcessedFraction ==+ 0+ ? 0+ : 2,+ maximumFractionDigits: 2,+ },+ },+ })}+ </Typography>+ )}+ </SpacedRow>+ )}+ </Stack>)}</Stack><DomainSettingsdiff --git a/web/apps/photos/tests/video-streaming-percentage.test.ts b/web/apps/photos/tests/video-streaming-percentage.test.tsnew file mode 100644index 0000000000..742db398e8--- /dev/null+++ b/web/apps/photos/tests/video-streaming-percentage.test.ts@@ -0,0 +1,208 @@+import type { EnteFile } from "ente-media/file";+import { FileType } from "ente-media/file-type";+import { afterEach, describe, expect, test, vi } from "vitest";++const mocks = vi.hoisted(() => ({+ kv: new Map<string, unknown>(),+ collectionFiles: [] as EnteFile[],+ collectionFilesReadCount: 0,+ collectionFilesReadGate: undefined as Promise<void> | undefined,+ pulledFileIDs: new Set<number>(),+ previewStatusPullCount: 0,+ previewStatusPullGate: undefined as Promise<void> | undefined,+}));++vi.mock("ente-base/app", async (importOriginal) => ({+ ...(await importOriginal<typeof import("ente-base/app")>()),+ isDesktop: true,+}));+vi.mock("ente-base/kv", async (importOriginal) => ({+ ...(await importOriginal<typeof import("ente-base/kv")>()),+ getKV: (key: string) => Promise.resolve(mocks.kv.get(key)),+ getKVB: (key: string) => Promise.resolve(mocks.kv.get(key)),+ getKVN: (key: string) => Promise.resolve(mocks.kv.get(key)),+ setKV: (key: string, value: unknown) => {+ mocks.kv.set(key, value);+ return Promise.resolve();+ },+}));+vi.mock("ente-accounts/services/user", async (importOriginal) => ({+ ...(await importOriginal<typeof import("ente-accounts/services/user")>()),+ ensureLocalUser: () => ({ id: 1 }),+}));+vi.mock("ente-new/photos/services/photos-fdb", async (importOriginal) => ({+ ...(await importOriginal<+ typeof import("ente-new/photos/services/photos-fdb")+ >()),+ savedCollectionFiles: async () => {+ mocks.collectionFilesReadCount++;+ await mocks.collectionFilesReadGate;+ return mocks.collectionFiles;+ },+}));+vi.mock("ente-new/photos/services/trash", async (importOriginal) => ({+ ...(await importOriginal<+ typeof import("ente-new/photos/services/trash")+ >()),+ savedTrashItemFileIDs: () => Promise.resolve(new Set<number>()),+}));+vi.mock("ente-gallery/services/file-data", async (importOriginal) => ({+ ...(await importOriginal<+ typeof import("ente-gallery/services/file-data")+ >()),+ syncUpdatedFileDataFileIDs: async (+ _type: string,+ _lastUpdatedAt: number,+ onPage: (page: {+ fileIDs: Set<number>;+ lastUpdatedAt: number;+ }) => Promise<void>,+ ) => {+ mocks.previewStatusPullCount++;+ await mocks.previewStatusPullGate;+ return onPage({ fileIDs: mocks.pulledFileIDs, lastUpdatedAt: 1 });+ },+}));+vi.mock("ente-utils/promise", async (importOriginal) => ({+ ...(await importOriginal<typeof import("ente-utils/promise")>()),+ wait: () => new Promise<void>(() => undefined),+}));++const {+ hlsGenerationStatusSnapshot,+ initVideoProcessing,+ processedVideoFraction,+ resetVideoState,+ streamCandidateFiles,+ toggleHLSGeneration,+ videoProcessingSyncIfNeeded,+} = await import("ente-gallery/services/video");++const MiB = 1024 * 1024;++const file = (+ id: number,+ overrides: {+ ownerID?: number;+ fileType?: FileType;+ sv?: number;+ fileSize?: number;+ duration?: number;+ } = {},+) =>+ ({+ id,+ ownerID: overrides.ownerID ?? 1,+ metadata: {+ fileType: overrides.fileType ?? FileType.video,+ duration: overrides.duration ?? 30,+ },+ info: { fileSize: overrides.fileSize ?? 10 * MiB },+ ...(overrides.sv == undefined+ ? {}+ : { pubMagicMetadata: { data: { sv: overrides.sv } } }),+ }) as EnteFile;++describe("video streaming percentage", () => {+ afterEach(() => {+ resetVideoState();+ mocks.kv.clear();+ mocks.collectionFiles = [];+ mocks.collectionFilesReadCount = 0;+ mocks.collectionFilesReadGate = undefined;+ mocks.pulledFileIDs = new Set();+ mocks.previewStatusPullCount = 0;+ mocks.previewStatusPullGate = undefined;+ });++ test("calculates the processed fraction using mobile's limits", () => {+ expect(processedVideoFraction(new Set(), [])).toBe(1);+ expect(processedVideoFraction(new Set(), [file(1), file(2)])).toBe(0);+ expect(+ processedVideoFraction(new Set([1, 3]), [+ file(1),+ file(2),+ file(3),+ file(4),+ ]),+ ).toBe(0.5);++ const candidates = [+ file(1),+ file(2, { duration: 61 }),+ file(3, { fileSize: 500 * MiB + 1 }),+ ];+ expect(processedVideoFraction(new Set([2, 3]), candidates)).toBe(2 / 3);+ });++ test("reuses Desktop's backfill population", () => {+ const candidates = streamCandidateFiles(+ [+ file(1),+ file(1),+ file(2, { ownerID: 2 }),+ file(3),+ file(4, { fileType: FileType.image }),+ file(5, { sv: 1 }),+ file(6, { duration: 600 }),+ file(7, { fileSize: 600 * MiB }),+ ],+ new Set([3]),+ 1,+ );++ expect(candidates.map(({ id }) => id)).toEqual([1, 6, 7]);+ });++ test("syncs previews before calculating when enabled", async () => {+ mocks.collectionFiles = [file(1)];+ mocks.pulledFileIDs = new Set([1]);+ let releasePreviewStatusPull!: () => void;+ mocks.previewStatusPullGate = new Promise<void>((resolve) => {+ releasePreviewStatusPull = resolve;+ });++ // A normal pull while disabled deliberately skips preview status.+ await videoProcessingSyncIfNeeded();+ const toggle = toggleHLSGeneration();++ await vi.waitFor(() => expect(mocks.previewStatusPullCount).toBe(1));+ expect(hlsGenerationStatusSnapshot()).toEqual({ enabled: true });+ expect(mocks.collectionFilesReadCount).toBe(0);++ releasePreviewStatusPull();+ await toggle;++ await vi.waitFor(() =>+ expect(hlsGenerationStatusSnapshot()).toMatchObject({+ enabled: true,+ processedFraction: 1,+ }),+ );+ });++ test("coalesces overlapping fraction refresh requests", async () => {+ mocks.kv.set("generateHLS", true);+ mocks.collectionFiles = [file(1)];+ let releaseCollectionFilesRead!: () => void;+ mocks.collectionFilesReadGate = new Promise<void>((resolve) => {+ releaseCollectionFilesRead = resolve;+ });++ await initVideoProcessing();+ await initVideoProcessing();+ await initVideoProcessing();++ expect(mocks.collectionFilesReadCount).toBe(1);++ releaseCollectionFilesRead();++ await vi.waitFor(() => {+ expect(mocks.collectionFilesReadCount).toBe(2);+ expect(hlsGenerationStatusSnapshot()).toMatchObject({+ enabled: true,+ processedFraction: 0,+ });+ });+ });+});diff --git a/web/packages/gallery/services/video.ts b/web/packages/gallery/services/video.tsindex 7c75cc25b2..8faab87703 100644--- a/web/packages/gallery/services/video.ts+++ b/web/packages/gallery/services/video.ts@@ -45,7 +45,12 @@ export type HLSGenerationEnabledStatus = "processing" | "idle";export type HLSGenerationStatus =| { enabled: false }- | { enabled: true; status?: HLSGenerationEnabledStatus };+ | {+ enabled: true;+ status?: HLSGenerationEnabledStatus;+ /** `undefined` until the processed fraction has been calculated. */+ processedFraction?: number;+ };interface VideoProcessingQueueItem {file: EnteFile;@@ -60,6 +65,9 @@ class VideoState {hlsGenerationStatusListeners: (() => void)[] = [];hlsGenerationStatusSnapshot: HLSGenerationStatus | undefined;lastEnabledStatus: HLSGenerationEnabledStatus | undefined;+ processedFraction: number | undefined;+ processedFractionRefresh: Promise<void> | undefined;+ processedFractionRefreshRequests = 0;liveQueue: VideoProcessingQueueItem[] = [];queueProcessor: Promise<void> | undefined;tick: Promise<void> | undefined;@@ -93,13 +101,19 @@ const setHLSGenerationStatusSnapshot = (snapshot: HLSGenerationStatus) => {_state.hlsGenerationStatusListeners.forEach((l) => l());};+const publishEnabledSnapshot = () =>+ setHLSGenerationStatusSnapshot({+ enabled: true,+ status: _state.lastEnabledStatus,+ processedFraction: _state.processedFraction,+ });+const updateSnapshotIfNeeded = (status: HLSGenerationEnabledStatus | undefined,) => {- const enabled = _state.isHLSGenerationEnabled;- if (enabled && status != _state.lastEnabledStatus) {+ if (_state.isHLSGenerationEnabled && status != _state.lastEnabledStatus) {_state.lastEnabledStatus = status;- setHLSGenerationStatusSnapshot({ enabled, status });+ publishEnabledSnapshot();}};@@ -112,6 +126,8 @@ export const initVideoProcessing = async () => {_state.isHLSGenerationEnabled = enabled;setHLSGenerationStatusSnapshot({ enabled });++ if (enabled) refreshProcessedFractionIfNeeded();};const savedGenerateHLS = async () => await getKVB("generateHLS");@@ -127,13 +143,22 @@ export const toggleHLSGeneration = async () => {const enabled = !_state.isHLSGenerationEnabled;_state.lastEnabledStatus = undefined;+ _state.processedFraction = undefined;await saveGenerateHLS(enabled);_state.isHLSGenerationEnabled = enabled;setHLSGenerationStatusSnapshot({ enabled });- if (enabled) tickNow();+ if (enabled) {+ try {+ await pullProcessedFileIDs();+ refreshProcessedFractionIfNeeded();+ } catch (e) {+ log.error("Failed to sync video preview status", e);+ }+ tickNow();+ }};export interface HLSPlaylistData {@@ -288,6 +313,80 @@ export const videoPrunePermanentlyDeletedFileIDsIfNeeded = async (}};+const mobileStreamMaxSize = 500 * 1024 * 1024;+const mobileStreamMaxDuration = 60; /* seconds */++const isWithinMobileStreamLimits = (file: EnteFile) => {+ const size = file.info?.fileSize;+ const duration = file.metadata.duration;+ return (+ size != undefined &&+ size <= mobileStreamMaxSize &&+ duration != undefined &&+ duration > 0 &&+ duration <= mobileStreamMaxDuration+ );+};++export const processedVideoFraction = (+ processedFileIDs: Set<number>,+ candidateFiles: EnteFile[],+) => {+ const candidateFileIDs = new Set(candidateFiles.map((f) => f.id));+ const previewFileIDs = processedFileIDs.intersection(candidateFileIDs);+ const countedFileIDs = new Set(+ candidateFiles.filter(isWithinMobileStreamLimits).map((f) => f.id),+ );+ const total = previewFileIDs.union(countedFileIDs);+ return total.size == 0 ? 1 : previewFileIDs.size / total.size;+};++const refreshProcessedFractionIfNeeded = () => {+ if (!isHLSGenerationSupported || !isHLSGenerationEnabled()) return;++ const state = _state;+ state.processedFractionRefreshRequests++;+ if (state.processedFractionRefresh) return;++ let handledRequests = 0;+ state.processedFractionRefresh = (async () => {+ while (handledRequests != state.processedFractionRefreshRequests) {+ const request = state.processedFractionRefreshRequests;+ try {+ // ponytail: Recompute on rare events; use incremental counts+ // only if profiling shows the library scan is material.+ const [candidates, processedFileIDs] = await Promise.all([+ savedStreamCandidateFiles(ensureLocalUser().id),+ savedProcessedVideoFileIDs(),+ ]);+ const fraction = processedVideoFraction(+ processedFileIDs,+ candidates,+ );+ if (state != _state || !state.isHLSGenerationEnabled) return;+ if (+ request == state.processedFractionRefreshRequests &&+ fraction != state.processedFraction+ ) {+ state.processedFraction = fraction;+ publishEnabledSnapshot();+ }+ } catch (e) {+ log.error("Failed to compute video processed fraction", e);+ }+ handledRequests = request;+ }+ })().finally(() => {+ state.processedFractionRefresh = undefined;+ if (+ state == _state &&+ handledRequests != state.processedFractionRefreshRequests+ ) {+ refreshProcessedFractionIfNeeded();+ }+ });+};+export const videoProcessingSyncIfNeeded = async () => {if (!isHLSGenerationSupported) return;@@ -297,6 +396,7 @@ export const videoProcessingSyncIfNeeded = async () => {if (!isHLSGenerationEnabled()) return;await pullProcessedFileIDs();+ refreshProcessedFractionIfNeeded();tickNow();};@@ -360,6 +460,7 @@ const processQueue = async () => {try {await processQueueItem(item);await markProcessedVideoFileID(item.file.id);+ refreshProcessedFractionIfNeeded();_state.idleWait = idleWaitInitial;} catch (e) {log.error(`Failed to process video ${fileLogID(item.file)}`, e);@@ -384,21 +485,34 @@ const processQueue = async () => {_state.queueProcessor = undefined;};-const backfillQueue = async (+// Shared with backfill so the percentage and queue use the same population.+export const streamCandidateFiles = (+ files: EnteFile[],+ trashFileIDs: Set<number>,userID: number,-): Promise<VideoProcessingQueueItem[]> => {- const allCollectionFiles = await savedCollectionFiles();- const localTrashFileIDs = await savedTrashItemFileIDs();- const videoFiles = uniqueFilesByID(- allCollectionFiles.filter(+) =>+ uniqueFilesByID(+ files.filter((f) =>f.ownerID == userID &&f.metadata.fileType == FileType.video &&- !localTrashFileIDs.has(f.id) &&+ !trashFileIDs.has(f.id) &&f.pubMagicMetadata?.data.sv != 1,),);+const savedStreamCandidateFiles = async (userID: number) =>+ streamCandidateFiles(+ await savedCollectionFiles(),+ await savedTrashItemFileIDs(),+ userID,+ );++const backfillQueue = async (+ userID: number,+): Promise<VideoProcessingQueueItem[]> => {+ const videoFiles = await savedStreamCandidateFiles(userID);+const doneIDs = (await savedProcessedVideoFileIDs()).union(await savedFailedVideoFileIDs(),);