feat: Add deafen to pc, fix mobiel view, fix freeze on startup

toju-app/src/app/domains/attachment/application/services/attachment-persistence.service.ts

@@ -6,6 +6,11 @@ import { DatabaseService } from '../../../../infrastructure/persistence';
 import { AttachmentStorageService } from '../../infrastructure/services/attachment-storage.service';
 import type { Attachment, AttachmentMeta } from '../../domain/models/attachment.model';
 import { LEGACY_ATTACHMENTS_STORAGE_KEY } from '../../domain/constants/attachment-transfer.constants';
+import {
+  ATTACHMENT_BLOB_READ_CHUNK_SIZE_BYTES,
+  decodeBase64ToUint8Array,
+  yieldToAttachmentHydrationLoop
+} from '../../domain/logic/attachment-blob.rules';
 import { isBlobObjectUrl, needsBlobObjectUrlForInlineDisplay } from '../../domain/logic/attachment-display-url.rules';
 import { mergeAttachmentLocalPaths } from '../../domain/logic/attachment-persistence.rules';
 import { AttachmentRuntimeStore } from './attachment-runtime.store';
@@ -144,15 +149,11 @@ export class AttachmentPersistenceService {
       return false;
     }
 
-    const base64 = await this.attachmentStorage.readFile(diskPath);
-
-    if (!base64) {
-      return false;
-    }
-
     this.revokeAttachmentObjectUrl(attachment);
-    this.restoreAttachmentFromDisk(attachment, base64);
-    return true;
+
+    const restored = await this.restoreAttachmentBlobFromDiskPath(attachment, diskPath);
+
+    return restored;
   }
 
   async persistUploadCopyFromSourcePath(attachment: Attachment, sourcePath: string): Promise<string | null> {
@@ -263,30 +264,54 @@ export class AttachmentPersistenceService {
   private async runInitFromDatabase(): Promise<void> {
     await this.loadFromDatabase();
     await this.migrateFromLocalStorage();
-    await this.tryLoadSavedFiles();
   }
 
-  private async tryLoadSavedFiles(): Promise<void> {
-    try {
-      let hasChanges = false;
+  private async restoreAttachmentBlobFromDiskPath(attachment: Attachment, diskPath: string): Promise<boolean> {
+    if (this.attachmentStorage.canReadFileChunks()) {
+      const fileSize = await this.attachmentStorage.getFileSize(diskPath);
 
-      for (const [, attachments] of this.runtimeStore.getAttachmentEntries()) {
-        for (const attachment of attachments) {
-          if (await this.tryRestoreAttachmentFromLocal(attachment)) {
-            hasChanges = true;
-          }
+      if (!fileSize || fileSize < 1) {
+        return false;
+      }
+
+      const blobParts: Uint8Array[] = [];
+
+      for (let start = 0; start < fileSize; start += ATTACHMENT_BLOB_READ_CHUNK_SIZE_BYTES) {
+        const end = Math.min(start + ATTACHMENT_BLOB_READ_CHUNK_SIZE_BYTES, fileSize);
+        const chunkBase64 = await this.attachmentStorage.readFileChunk(diskPath, start, end);
+
+        if (!chunkBase64) {
+          return false;
+        }
+
+        blobParts.push(decodeBase64ToUint8Array(chunkBase64));
+
+        if (end < fileSize) {
+          await yieldToAttachmentHydrationLoop();
         }
       }
 
-      if (hasChanges)
-        this.runtimeStore.touch();
-    } catch { /* startup load is best-effort */ }
+      this.applyAttachmentBlob(attachment, new Blob(blobParts as BlobPart[], { type: attachment.mime }));
+      return true;
+    }
+
+    const base64 = await this.attachmentStorage.readFile(diskPath);
+
+    if (!base64) {
+      return false;
+    }
+
+    const bytes = decodeBase64ToUint8Array(base64);
+
+    this.applyAttachmentBlob(
+      attachment,
+      new Blob([bytes.buffer as ArrayBuffer], { type: attachment.mime })
+    );
+
+    return true;
   }
 
-  private restoreAttachmentFromDisk(attachment: Attachment, base64: string): void {
-    const bytes = this.base64ToUint8Array(base64);
-    const blob = new Blob([bytes.buffer as ArrayBuffer], { type: attachment.mime });
-
+  private applyAttachmentBlob(attachment: Attachment, blob: Blob): void {
     attachment.objectUrl = URL.createObjectURL(blob);
     attachment.available = true;
 
@@ -335,14 +360,4 @@ export class AttachmentPersistenceService {
     return retainedSavedPaths;
   }
 
-  private base64ToUint8Array(base64: string): Uint8Array {
-    const binary = atob(base64);
-    const bytes = new Uint8Array(binary.length);
-
-    for (let index = 0; index < binary.length; index++) {
-      bytes[index] = binary.charCodeAt(index);
-    }
-
-    return bytes;
-  }
 }