Remove dead code from cast

web/apps/cast/src/constants/file.ts

@@ -1,14 +1,3 @@
-export const MIN_EDITED_CREATION_TIME = new Date(1800, 0, 1);
-export const MAX_EDITED_CREATION_TIME = new Date();
-
-export const MAX_EDITED_FILE_NAME_LENGTH = 100;
-export const MAX_CAPTION_SIZE = 5000;
-
-export const TYPE_HEIC = "heic";
-export const TYPE_HEIF = "heif";
-export const TYPE_JPEG = "jpeg";
-export const TYPE_JPG = "jpg";
-
 export enum FILE_TYPE {
     IMAGE,
     VIDEO,
@@ -29,15 +18,3 @@ export const RAW_FORMATS = [
     "dng",
     "tif",
 ];
-export const SUPPORTED_RAW_FORMATS = [
-    "heic",
-    "rw2",
-    "tiff",
-    "arw",
-    "cr3",
-    "cr2",
-    "nef",
-    "psd",
-    "dng",
-    "tif",
-];

web/apps/cast/src/services/InMemoryStore.ts

@@ -1,31 +0,0 @@
-export enum MS_KEYS {
-    SRP_CONFIGURE_IN_PROGRESS = "srpConfigureInProgress",
-    REDIRECT_URL = "redirectUrl",
-}
-
-type StoreType = Map<Partial<MS_KEYS>, any>;
-
-class InMemoryStore {
-    private store: StoreType = new Map();
-
-    get(key: MS_KEYS) {
-        return this.store.get(key);
-    }
-
-    set(key: MS_KEYS, value: any) {
-        this.store.set(key, value);
-    }
-
-    delete(key: MS_KEYS) {
-        this.store.delete(key);
-    }
-
-    has(key: MS_KEYS) {
-        return this.store.has(key);
-    }
-    clear() {
-        this.store.clear();
-    }
-}
-
-export default new InMemoryStore();

web/apps/cast/src/services/heicConversionService.ts

@@ -1,14 +0,0 @@
-import { logError } from "@ente/shared/sentry";
-import WasmHEICConverterService from "./wasmHeicConverter/wasmHEICConverterService";
-
-class HeicConversionService {
-    async convert(heicFileData: Blob): Promise<Blob> {
-        try {
-            return await WasmHEICConverterService.convert(heicFileData);
-        } catch (e) {
-            logError(e, "failed to convert heic file");
-            throw e;
-        }
-    }
-}
-export default new HeicConversionService();

web/apps/cast/src/services/wasmHeicConverter/wasmHEICConverterClient.ts

@@ -1,13 +0,0 @@
-import * as HeicConvert from "heic-convert";
-import { getUint8ArrayView } from "services/readerService";
-
-export async function convertHEIC(
-    fileBlob: Blob,
-    format: string,
-): Promise<Blob> {
-    const filedata = await getUint8ArrayView(fileBlob);
-    const result = await HeicConvert({ buffer: filedata, format });
-    const convertedFileData = new Uint8Array(result);
-    const convertedFileBlob = new Blob([convertedFileData]);
-    return convertedFileBlob;
-}

web/apps/cast/src/services/wasmHeicConverter/wasmHEICConverterService.ts

@@ -1,114 +0,0 @@
-import { CustomError } from "@ente/shared/error";
-import { addLogLine } from "@ente/shared/logging";
-import { retryAsyncFunction } from "@ente/shared/promise";
-import { logError } from "@ente/shared/sentry";
-import QueueProcessor from "@ente/shared/utils/queueProcessor";
-import { convertBytesToHumanReadable } from "@ente/shared/utils/size";
-import { getDedicatedConvertWorker } from "utils/comlink/ComlinkConvertWorker";
-import { ComlinkWorker } from "utils/comlink/comlinkWorker";
-import { DedicatedConvertWorker } from "worker/convert.worker";
-
-const WORKER_POOL_SIZE = 2;
-const MAX_CONVERSION_IN_PARALLEL = 1;
-const WAIT_TIME_BEFORE_NEXT_ATTEMPT_IN_MICROSECONDS = [100, 100];
-const WAIT_TIME_IN_MICROSECONDS = 30 * 1000;
-const BREATH_TIME_IN_MICROSECONDS = 1000;
-const CONVERT_FORMAT = "JPEG";
-
-class HEICConverter {
-    private convertProcessor = new QueueProcessor<Blob>(
-        MAX_CONVERSION_IN_PARALLEL,
-    );
-    private workerPool: ComlinkWorker<typeof DedicatedConvertWorker>[] = [];
-    private ready: Promise<void>;
-
-    constructor() {
-        this.ready = this.init();
-    }
-    private async init() {
-        this.workerPool = [];
-        for (let i = 0; i < WORKER_POOL_SIZE; i++) {
-            this.workerPool.push(getDedicatedConvertWorker());
-        }
-    }
-    async convert(fileBlob: Blob): Promise<Blob> {
-        await this.ready;
-        const response = this.convertProcessor.queueUpRequest(() =>
-            retryAsyncFunction<Blob>(async () => {
-                const convertWorker = this.workerPool.shift();
-                const worker = await convertWorker.remote;
-                try {
-                    const convertedHEIC = await new Promise<Blob>(
-                        (resolve, reject) => {
-                            const main = async () => {
-                                try {
-                                    const timeout = setTimeout(() => {
-                                        reject(Error("wait time exceeded"));
-                                    }, WAIT_TIME_IN_MICROSECONDS);
-                                    const startTime = Date.now();
-                                    const convertedHEIC =
-                                        await worker.convertHEIC(
-                                            fileBlob,
-                                            CONVERT_FORMAT,
-                                        );
-                                    addLogLine(
-                                        `originalFileSize:${convertBytesToHumanReadable(
-                                            fileBlob?.size,
-                                        )},convertedFileSize:${convertBytesToHumanReadable(
-                                            convertedHEIC?.size,
-                                        )},  heic conversion time: ${
-                                            Date.now() - startTime
-                                        }ms `,
-                                    );
-                                    clearTimeout(timeout);
-                                    resolve(convertedHEIC);
-                                } catch (e) {
-                                    reject(e);
-                                }
-                            };
-                            main();
-                        },
-                    );
-                    if (!convertedHEIC || convertedHEIC?.size === 0) {
-                        logError(
-                            Error(`converted heic fileSize is Zero`),
-                            "converted heic fileSize is Zero",
-                            {
-                                originalFileSize: convertBytesToHumanReadable(
-                                    fileBlob?.size ?? 0,
-                                ),
-                                convertedFileSize: convertBytesToHumanReadable(
-                                    convertedHEIC?.size ?? 0,
-                                ),
-                            },
-                        );
-                    }
-                    await new Promise((resolve) => {
-                        setTimeout(
-                            () => resolve(null),
-                            BREATH_TIME_IN_MICROSECONDS,
-                        );
-                    });
-                    this.workerPool.push(convertWorker);
-                    return convertedHEIC;
-                } catch (e) {
-                    logError(e, "heic conversion failed");
-                    convertWorker.terminate();
-                    this.workerPool.push(getDedicatedConvertWorker());
-                    throw e;
-                }
-            }, WAIT_TIME_BEFORE_NEXT_ATTEMPT_IN_MICROSECONDS),
-        );
-        try {
-            return await response.promise;
-        } catch (e) {
-            if (e.message === CustomError.REQUEST_CANCELLED) {
-                // ignore
-                return null;
-            }
-            throw e;
-        }
-    }
-}
-
-export default new HEICConverter();

web/apps/cast/src/utils/comlink/ComlinkConvertWorker.ts

@@ -1,30 +0,0 @@
-import { runningInBrowser } from "@ente/shared/platform";
-import { Remote } from "comlink";
-import { DedicatedConvertWorker } from "worker/convert.worker";
-import { ComlinkWorker } from "./comlinkWorker";
-
-class ComlinkConvertWorker {
-    private comlinkWorkerInstance: Remote<DedicatedConvertWorker>;
-
-    async getInstance() {
-        if (!this.comlinkWorkerInstance) {
-            this.comlinkWorkerInstance =
-                await getDedicatedConvertWorker().remote;
-        }
-        return this.comlinkWorkerInstance;
-    }
-}
-
-export const getDedicatedConvertWorker = () => {
-    if (runningInBrowser()) {
-        const cryptoComlinkWorker = new ComlinkWorker<
-            typeof DedicatedConvertWorker
-        >(
-            "ente-convert-worker",
-            new Worker(new URL("worker/convert.worker.ts", import.meta.url)),
-        );
-        return cryptoComlinkWorker;
-    }
-};
-
-export default new ComlinkConvertWorker();

web/apps/cast/src/utils/comlink/comlinkWorker.ts

@@ -1,6 +1,5 @@
 import { addLocalLog } from "@ente/shared/logging";
 import { Remote, wrap } from "comlink";
-// import { WorkerElectronCacheStorageClient } from 'services/workerElectronCache/client';
 
 export class ComlinkWorker<T extends new () => InstanceType<T>> {
     public remote: Promise<Remote<InstanceType<T>>>;
@@ -17,7 +16,6 @@ export class ComlinkWorker<T extends new () => InstanceType<T>> {
         addLocalLog(() => `Initiated ${this.name}`);
         const comlink = wrap<T>(this.worker);
         this.remote = new comlink() as Promise<Remote<InstanceType<T>>>;
-        // expose(WorkerElectronCacheStorageClient, this.worker);
     }
 
     public terminate() {

web/apps/cast/src/utils/file/blob.ts

@@ -1,15 +0,0 @@
-export const readAsDataURL = (blob) =>
-    new Promise<string>((resolve, reject) => {
-        const fileReader = new FileReader();
-        fileReader.onload = () => resolve(fileReader.result as string);
-        fileReader.onerror = () => reject(fileReader.error);
-        fileReader.readAsDataURL(blob);
-    });
-
-export const readAsText = (blob) =>
-    new Promise<string>((resolve, reject) => {
-        const fileReader = new FileReader();
-        fileReader.onload = () => resolve(fileReader.result as string);
-        fileReader.onerror = () => reject(fileReader.error);
-        fileReader.readAsText(blob);
-    });

web/apps/cast/src/utils/file/index.ts

@@ -1,20 +1,8 @@
-import { CustomError } from "@ente/shared/error";
-import { addLocalLog, addLogLine } from "@ente/shared/logging";
-import { isPlaybackPossible } from "@ente/shared/media/video-playback";
 import { logError } from "@ente/shared/sentry";
 import { LS_KEYS, getData } from "@ente/shared/storage/localStorage";
 import { User } from "@ente/shared/user/types";
-import { convertBytesToHumanReadable } from "@ente/shared/utils/size";
-import {
-    FILE_TYPE,
-    RAW_FORMATS,
-    SUPPORTED_RAW_FORMATS,
-    TYPE_HEIC,
-    TYPE_HEIF,
-} from "constants/file";
+import { FILE_TYPE, RAW_FORMATS } from "constants/file";
 import CastDownloadManager from "services/castDownloadManager";
-import * as ffmpegService from "services/ffmpeg/ffmpegService";
-import heicConversionService from "services/heicConversionService";
 import { decodeLivePhoto } from "services/livePhotoService";
 import { getFileType } from "services/typeDetectionService";
 import {
@@ -23,7 +11,6 @@ import {
     FileMagicMetadata,
     FilePublicMagicMetadata,
 } from "types/file";
-import { FileTypeInfo } from "types/upload";
 import ComlinkCryptoWorker from "utils/comlink/ComlinkCryptoWorker";
 
 export function sortFiles(files: EnteFile[], sortAsc = false) {
@@ -135,160 +122,6 @@ export function generateStreamFromArrayBuffer(data: Uint8Array) {
     });
 }
 
-export async function getRenderableFileURL(file: EnteFile, fileBlob: Blob) {
-    switch (file.metadata.fileType) {
-        case FILE_TYPE.IMAGE: {
-            const convertedBlob = await getRenderableImage(
-                file.metadata.title,
-                fileBlob,
-            );
-            const { originalURL, convertedURL } = getFileObjectURLs(
-                fileBlob,
-                convertedBlob,
-            );
-            return {
-                converted: [convertedURL],
-                original: [originalURL],
-            };
-        }
-        case FILE_TYPE.LIVE_PHOTO: {
-            return await getRenderableLivePhotoURL(file, fileBlob);
-        }
-        case FILE_TYPE.VIDEO: {
-            const convertedBlob = await getPlayableVideo(
-                file.metadata.title,
-                fileBlob,
-            );
-            const { originalURL, convertedURL } = getFileObjectURLs(
-                fileBlob,
-                convertedBlob,
-            );
-            return {
-                converted: [convertedURL],
-                original: [originalURL],
-            };
-        }
-        default: {
-            const previewURL = await createTypedObjectURL(
-                fileBlob,
-                file.metadata.title,
-            );
-            return {
-                converted: [previewURL],
-                original: [previewURL],
-            };
-        }
-    }
-}
-
-async function getRenderableLivePhotoURL(
-    file: EnteFile,
-    fileBlob: Blob,
-): Promise<{ original: string[]; converted: string[] }> {
-    const livePhoto = await decodeLivePhoto(file, fileBlob);
-    const imageBlob = new Blob([livePhoto.image]);
-    const videoBlob = new Blob([livePhoto.video]);
-    const convertedImageBlob = await getRenderableImage(
-        livePhoto.imageNameTitle,
-        imageBlob,
-    );
-    const convertedVideoBlob = await getPlayableVideo(
-        livePhoto.videoNameTitle,
-        videoBlob,
-        true,
-    );
-    const { originalURL: originalImageURL, convertedURL: convertedImageURL } =
-        getFileObjectURLs(imageBlob, convertedImageBlob);
-
-    const { originalURL: originalVideoURL, convertedURL: convertedVideoURL } =
-        getFileObjectURLs(videoBlob, convertedVideoBlob);
-    return {
-        converted: [convertedImageURL, convertedVideoURL],
-        original: [originalImageURL, originalVideoURL],
-    };
-}
-
-export async function getPlayableVideo(
-    videoNameTitle: string,
-    videoBlob: Blob,
-    forceConvert = false,
-) {
-    try {
-        const isPlayable = await isPlaybackPossible(
-            URL.createObjectURL(videoBlob),
-        );
-        if (isPlayable && !forceConvert) {
-            return videoBlob;
-        } else {
-            if (!forceConvert) {
-                return null;
-            }
-            addLogLine(
-                "video format not supported, converting it name:",
-                videoNameTitle,
-            );
-            const mp4ConvertedVideo = await ffmpegService.convertToMP4(
-                new File([videoBlob], videoNameTitle),
-            );
-            addLogLine("video successfully converted", videoNameTitle);
-            return new Blob([await mp4ConvertedVideo.arrayBuffer()]);
-        }
-    } catch (e) {
-        addLogLine("video conversion failed", videoNameTitle);
-        logError(e, "video conversion failed");
-        return null;
-    }
-}
-
-export async function getRenderableImage(fileName: string, imageBlob: Blob) {
-    let fileTypeInfo: FileTypeInfo;
-    try {
-        const tempFile = new File([imageBlob], fileName);
-        fileTypeInfo = await getFileType(tempFile);
-        addLocalLog(() => `file type info: ${JSON.stringify(fileTypeInfo)}`);
-        const { exactType } = fileTypeInfo;
-        let convertedImageBlob: Blob;
-        if (isRawFile(exactType)) {
-            try {
-                if (!isSupportedRawFormat(exactType)) {
-                    throw Error(CustomError.UNSUPPORTED_RAW_FORMAT);
-                }
-
-                throw Error(CustomError.NOT_AVAILABLE_ON_WEB);
-            } catch (e) {
-                try {
-                    if (!isFileHEIC(exactType)) {
-                        throw e;
-                    }
-                    addLogLine(
-                        `HEICConverter called for ${fileName}-${convertBytesToHumanReadable(
-                            imageBlob.size,
-                        )}`,
-                    );
-                    convertedImageBlob =
-                        await heicConversionService.convert(imageBlob);
-                    addLogLine(`${fileName} successfully converted`);
-                } catch (e) {
-                    throw Error(CustomError.NON_PREVIEWABLE_FILE);
-                }
-            }
-            return convertedImageBlob;
-        } else {
-            return imageBlob;
-        }
-    } catch (e) {
-        logError(e, "get Renderable Image failed", { fileTypeInfo });
-        return null;
-    }
-}
-
-export function isFileHEIC(exactType: string) {
-    return (
-        exactType.toLowerCase().endsWith(TYPE_HEIC) ||
-        exactType.toLowerCase().endsWith(TYPE_HEIF)
-    );
-}
-
 export function isRawFile(exactType: string) {
     return RAW_FORMATS.includes(exactType.toLowerCase());
 }
@@ -302,10 +135,6 @@ export function isRawFileFromFileName(fileName: string) {
     return false;
 }
 
-export function isSupportedRawFormat(exactType: string) {
-    return SUPPORTED_RAW_FORMATS.includes(exactType.toLowerCase());
-}
-
 export function mergeMetadata(files: EnteFile[]): EnteFile[] {
     return files.map((file) => {
         if (file.pubMagicMetadata?.data.editedTime) {
@@ -376,13 +205,3 @@ export const getPreviewableImage = async (
         logError(e, "failed to download file");
     }
 };
-
-const getFileObjectURLs = (originalBlob: Blob, convertedBlob: Blob) => {
-    const originalURL = URL.createObjectURL(originalBlob);
-    const convertedURL = convertedBlob
-        ? convertedBlob === originalBlob
-            ? originalURL
-            : URL.createObjectURL(convertedBlob)
-        : null;
-    return { originalURL, convertedURL };
-};

web/apps/cast/src/worker/convert.worker.ts

@@ -1,10 +0,0 @@
-import * as Comlink from "comlink";
-import { convertHEIC } from "services/wasmHeicConverter/wasmHEICConverterClient";
-
-export class DedicatedConvertWorker {
-    async convertHEIC(fileBlob: Blob, format: string) {
-        return convertHEIC(fileBlob, format);
-    }
-}
-
-Comlink.expose(DedicatedConvertWorker, self);