@mentra/engine 0.1.0-beta.0

package/src/services/asg/cameraRollExportLedger.ts

@@ -0,0 +1,122 @@
+import {storage} from "../../utils/storage"
+import {toPortableGalleryPath} from "./galleryPathMigration"
+import type {GalleryAssetReceipt} from "./galleryTransferLedger"
+
+export type CameraRollExportState =
+  | "NOT_REQUESTED"
+  | "LEGACY_UNKNOWN"
+  | "QUEUED"
+  | "RECONCILING"
+  | "EXPORTING"
+  | "EXPORTED"
+  | "BLOCKED_PERMISSION"
+  | "FAILED_RETRYABLE"
+  | "FAILED_PERMANENT"
+  | "MISSING_LOCAL"
+
+export type CameraRollExportPriority = "SOURCE_BARRIER" | "HISTORICAL_BACKFILL"
+
+export interface CameraRollExportEntry {
+  /** Stable identity for one local-file generation. */
+  id: string
+  mediaName: string
+  generation: string
+  filePath: string
+  size: number
+  modified: number
+  isVideo: boolean
+  captureId?: string
+  /** False while this generation is absent from the local index; exported receipts remain as hidden tombstones. */
+  localPresent?: boolean
+  /** True when an older client may already have exported this file without persisting a receipt. */
+  requiresFullLibraryReconciliation?: boolean
+  state: CameraRollExportState
+  priority: CameraRollExportPriority
+  receipt?: GalleryAssetReceipt
+  attempts: number
+  nextRetryAt?: number
+  lastError?: string
+  createdAt: number
+  updatedAt: number
+}
+
+const ENTRY_PREFIX = "asg_camera_roll_export_v1:"
+
+export function cameraRollGeneration(mediaName: string, size: number, modified: number): string {
+  return `${mediaName}:${size}:${modified}`
+}
+
+export function cameraRollEntryId(mediaName: string, size: number, modified: number): string {
+  return encodeURIComponent(cameraRollGeneration(mediaName, size, modified))
+}
+
+class CameraRollExportLedger {
+  private runtimeDocumentDirectory = ""
+
+  setDocumentDirectory(path: string): void {
+    this.runtimeDocumentDirectory = path
+  }
+
+  get(id: string): CameraRollExportEntry | undefined {
+    const result = storage.load<CameraRollExportEntry>(`${ENTRY_PREFIX}${id}`)
+    if (result.is_error()) return undefined
+    return this.toRuntimeEntry(result.value)
+  }
+
+  list(): CameraRollExportEntry[] {
+    return storage
+      .getAllKeys()
+      .filter((key) => key.startsWith(ENTRY_PREFIX))
+      .map((key) => {
+        const result = storage.load<CameraRollExportEntry>(key)
+        return result.is_error() ? undefined : this.toRuntimeEntry(result.value)
+      })
+      .filter((entry): entry is CameraRollExportEntry => !!entry)
+  }
+
+  put(entry: CameraRollExportEntry): CameraRollExportEntry {
+    const updated = {...entry, updatedAt: Date.now()}
+    const result = storage.save(`${ENTRY_PREFIX}${entry.id}`, this.toStoredEntry(updated))
+    if (result.is_error()) throw result.error
+    return updated
+  }
+
+  update(id: string, patch: Partial<CameraRollExportEntry>): CameraRollExportEntry {
+    const current = this.get(id)
+    if (!current) throw new Error(`Camera-roll export entry missing: ${id}`)
+    return this.put({...current, ...patch, id})
+  }
+
+  remove(id: string): void {
+    const result = storage.remove(`${ENTRY_PREFIX}${id}`)
+    if (result.is_error()) throw result.error
+  }
+
+  removeForMedia(mediaName: string): void {
+    for (const entry of this.list()) {
+      if (entry.mediaName === mediaName) this.remove(entry.id)
+    }
+  }
+
+  clear(): void {
+    const keys = storage.getAllKeys().filter((key) => key.startsWith(ENTRY_PREFIX))
+    if (keys.length === 0) return
+    const result = storage.removeMultiple(keys)
+    if (result.is_error()) throw result.error
+  }
+
+  private toStoredEntry(entry: CameraRollExportEntry): CameraRollExportEntry {
+    if (!this.runtimeDocumentDirectory) return entry
+    return {
+      ...entry,
+      filePath: toPortableGalleryPath(entry.filePath, this.runtimeDocumentDirectory) || entry.filePath,
+    }
+  }
+
+  private toRuntimeEntry(entry: CameraRollExportEntry): CameraRollExportEntry {
+    if (!this.runtimeDocumentDirectory || entry.filePath.startsWith("/")) return entry
+    return {...entry, filePath: `${this.runtimeDocumentDirectory}/${entry.filePath}`}
+  }
+}
+
+export const cameraRollExportLedger = new CameraRollExportLedger()

package/src/services/asg/galleryMediaValidation.ts

@@ -0,0 +1,183 @@
+/**
+ * Post-download validation for gallery media synced from glasses.
+ */
+
+import * as RNFS from "@dr.pogodin/react-native-fs"
+import {Buffer} from "@craftzdog/react-native-buffer"
+
+export const INVALID_DOWNLOADED_MEDIA = "Invalid downloaded media"
+
+export type MediaKind = "photo" | "video" | "unknown"
+
+export interface ValidateDownloadedMediaOptions {
+  path: string
+  name: string
+  expectedSize?: number
+  mediaKind?: MediaKind
+}
+
+// ISO BMFF brands that identify still-image (not video) containers. An mp4-like
+// header with one of these brands at bytes 8-11 must NOT pass video validation.
+const IMAGE_FTYP_BRANDS = new Set(["avif", "avis", "heic", "heix", "heim", "heis", "hevc", "hevx", "mif1", "msf1"])
+
+function isVideoFileName(name: string): boolean {
+  return /\.(mp4|mov|avi|webm|mkv|3gp)$/i.test(name)
+}
+
+function isPhotoFileName(name: string): boolean {
+  return /\.(jpg|jpeg|png|avif)$/i.test(name) || !name.includes(".")
+}
+
+function detectMediaKind(name: string, override?: MediaKind): MediaKind {
+  if (override && override !== "unknown") {
+    return override
+  }
+  if (isVideoFileName(name)) {
+    return "video"
+  }
+  if (isPhotoFileName(name)) {
+    return "photo"
+  }
+  return "unknown"
+}
+
+function decodeHeader(base64Header: string): Buffer {
+  // Use Buffer (from the "buffer" polyfill) for byte-safe decoding; RN's atob
+  // is host-dependent and some implementations mangle bytes ≥ 0x80, which would
+  // mis-validate JPEG (0xFF 0xD8) and binary AVI/EBML headers.
+  return Buffer.from(base64Header, "base64")
+}
+
+function readAscii(bytes: Buffer, start: number, length: number): string {
+  if (bytes.length < start + length) return ""
+  return bytes.toString("ascii", start, start + length)
+}
+
+function validatePhotoSignature(base64Header: string): boolean {
+  try {
+    const bytes = decodeHeader(base64Header)
+    if (bytes.length >= 12 && readAscii(bytes, 4, 4) === "ftyp") {
+      const brand = readAscii(bytes, 8, 4)
+      // Image-only ISO BMFF brands (AVIF, HEIC, HEIF variants) are valid photos.
+      if (IMAGE_FTYP_BRANDS.has(brand)) {
+        return true
+      }
+    }
+    // JPEG: 0xFF 0xD8
+    if (bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xd8) {
+      return true
+    }
+    // PNG: 89 50 4E 47 0D 0A 1A 0A
+    if (
+      bytes.length >= 8 &&
+      bytes[0] === 0x89 &&
+      bytes[1] === 0x50 &&
+      bytes[2] === 0x4e &&
+      bytes[3] === 0x47 &&
+      bytes[4] === 0x0d &&
+      bytes[5] === 0x0a &&
+      bytes[6] === 0x1a &&
+      bytes[7] === 0x0a
+    ) {
+      return true
+    }
+    return false
+  } catch {
+    return false
+  }
+}
+
+function validateVideoSignature(base64Header: string): boolean {
+  try {
+    const bytes = decodeHeader(base64Header)
+    if (bytes.length < 8) {
+      return false
+    }
+    // ISO BMFF (mp4, mov, 3gp): bytes 4-7 should be "ftyp" AND brand at 8-11 must
+    // not be an image-only brand (AVIF/HEIC share the ftyp container).
+    if (readAscii(bytes, 4, 4) === "ftyp") {
+      const brand = readAscii(bytes, 8, 4)
+      if (IMAGE_FTYP_BRANDS.has(brand)) {
+        return false
+      }
+      return true
+    }
+    // RIFF/AVI: bytes 0-3 "RIFF", bytes 8-11 "AVI "
+    if (bytes.length >= 12 && readAscii(bytes, 0, 4) === "RIFF" && readAscii(bytes, 8, 4) === "AVI ") {
+      return true
+    }
+    // EBML (WebM, MKV): bytes 0-3 are 0x1A 0x45 0xDF 0xA3
+    if (bytes.length >= 4 && bytes[0] === 0x1a && bytes[1] === 0x45 && bytes[2] === 0xdf && bytes[3] === 0xa3) {
+      return true
+    }
+    return false
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Validate a downloaded file on disk. Throws with INVALID_DOWNLOADED_MEDIA on failure.
+ */
+export async function validateDownloadedMediaFile(options: ValidateDownloadedMediaOptions): Promise<void> {
+  const {path, name, expectedSize = 0, mediaKind} = options
+
+  const exists = await RNFS.exists(path)
+  if (!exists) {
+    throw new Error(`${INVALID_DOWNLOADED_MEDIA}: missing file ${name}`)
+  }
+
+  const stat = await RNFS.stat(path)
+  if (stat.size === 0) {
+    throw new Error(`${INVALID_DOWNLOADED_MEDIA}: zero-byte file ${name}`)
+  }
+
+  if (expectedSize > 0 && stat.size !== expectedSize) {
+    throw new Error(`${INVALID_DOWNLOADED_MEDIA}: size mismatch for ${name}: expected ${expectedSize}, got ${stat.size}`)
+  }
+
+  const kind = detectMediaKind(name, mediaKind)
+  if (kind === "unknown") {
+    return
+  }
+
+  const headerBase64 = await RNFS.read(path, 12, 0, "base64")
+  if (kind === "video") {
+    if (!validateVideoSignature(headerBase64)) {
+      throw new Error(`${INVALID_DOWNLOADED_MEDIA}: invalid video container for ${name}`)
+    }
+    return
+  }
+
+  if (!validatePhotoSignature(headerBase64)) {
+    throw new Error(`${INVALID_DOWNLOADED_MEDIA}: invalid photo signature for ${name}`)
+  }
+}
+
+/**
+ * Pre-download check using sync metadata before hitting the network.
+ */
+export function validateCaptureMetadataForDownload(capture: {
+  capture_id: string
+  type: "photo" | "video"
+  total_size: number
+  files: Array<{name: string; size: number; role: string}>
+}): void {
+  if (capture.type !== "video") {
+    return
+  }
+
+  if (capture.total_size <= 0) {
+    throw new Error(`${INVALID_DOWNLOADED_MEDIA}: video capture ${capture.capture_id} has zero total_size`)
+  }
+
+  const primaryFile = capture.files.find((f) => f.role === "primary") ?? capture.files[0]
+  if (!primaryFile) {
+    throw new Error(`${INVALID_DOWNLOADED_MEDIA}: video capture ${capture.capture_id} has no files`)
+  }
+  if (primaryFile.size <= 0) {
+    throw new Error(
+      `${INVALID_DOWNLOADED_MEDIA}: video capture ${capture.capture_id} primary file ${primaryFile.name} has zero size`,
+    )
+  }
+}

package/src/services/asg/galleryNotices.ts

@@ -0,0 +1,61 @@
+/**
+ * Gallery notices — engine-owned. The gallery sync emits STRUCTURED notice codes
+ * (never localized strings or alerts) when it hits a user-actionable precondition;
+ * the host renders its own alert / settings deep-link from the code. This keeps the
+ * sync (engine runtime) free of host UI/i18n/navigation — exposed as
+ * `engine.gallery.onNotice(cb)`.
+ */
+export type GalleryNoticeCode =
+  | "glasses_disconnected"
+  | "bluetooth_off"
+  | "insufficient_storage"
+  | "wifi_initializing"
+  | "wifi_off"
+  | "location_services_off"
+  | "camera_roll_permission_required"
+  | "connect_to_glasses"
+
+export interface GalleryNotice {
+  code: GalleryNoticeCode
+  /** Optional extra context (e.g. ssid/platform) for the host's message. */
+  data?: Record<string, unknown>
+  /**
+   * Present only on notices the sync BLOCKS on (currently the one-time wifi-join
+   * explanation): the host calls this when the user acknowledges, letting the sync
+   * proceed. If no host is listening, the emitter's return value lets the sync fall
+   * through instead of hanging.
+   */
+  ack?: () => void
+}
+
+type Listener = (notice: GalleryNotice) => void
+
+const listeners = new Set<Listener>()
+
+/**
+ * Emit a notice to all subscribers; returns how many SUCCESSFULLY received it
+ * (0 = nobody listening, or every listener threw). Callers use 0 as the
+ * "no host will act on this" signal — e.g. gallery sync auto-proceeds on the
+ * blocking connect_to_glasses notice — so a throwing listener must not count
+ * as a delivery.
+ */
+export function emitGalleryNotice(notice: GalleryNotice): number {
+  let delivered = 0
+  listeners.forEach((l) => {
+    // Isolate listeners: one throwing host handler must not break delivery to the
+    // others or bubble an exception into the gallery sync.
+    try {
+      l(notice)
+      delivered += 1
+    } catch (error) {
+      console.error("galleryNotices: onNotice listener threw:", error)
+    }
+  })
+  return delivered
+}
+
+/** Subscribe to gallery notices; returns an unsubscribe. */
+export function onGalleryNotice(cb: Listener): () => void {
+  listeners.add(cb)
+  return () => listeners.delete(cb)
+}

package/src/services/asg/galleryPathMigration.ts

@@ -0,0 +1,22 @@
+/** Convert current or legacy app-container paths into a portable Documents-relative path. */
+export function toPortableGalleryPath(path: string, documentDirectoryPath: string): string | null {
+  if (!path) return null
+  const cleanPath = path.replace(/^file:\/\//, "")
+  const docPath = documentDirectoryPath.replace(/\/$/, "")
+  let candidate: string | null = null
+  if (cleanPath.startsWith(`${docPath}/`)) candidate = cleanPath.substring(docPath.length + 1)
+  else if (!cleanPath.startsWith("/")) candidate = cleanPath.replace(/^\/+/, "")
+
+  if (!candidate) {
+    const documentsMarker = "/Documents/"
+    const documentsIndex = cleanPath.indexOf(documentsMarker)
+    if (documentsIndex >= 0) candidate = cleanPath.substring(documentsIndex + documentsMarker.length)
+  }
+
+  if (!candidate || candidate.includes("\0")) return null
+  const segments = candidate.split("/")
+  if (segments[0] !== "MentraPhotos" || segments.some((segment) => !segment || segment === "." || segment === "..")) {
+    return null
+  }
+  return segments.join("/")
+}

package/src/services/asg/gallerySettingsService.ts

@@ -0,0 +1,68 @@
+import {storage} from "../../utils/storage/storage"
+
+export interface GallerySettings {
+  autoSaveToCameraRoll: boolean
+  autoSaveDisableWarningShown: boolean
+  imageProcessingEnabled: boolean
+}
+
+export class GallerySettingsService {
+  private static instance: GallerySettingsService
+  private readonly SETTINGS_KEY = "gallery_settings"
+  private readonly DEFAULT_SETTINGS: GallerySettings = {
+    autoSaveToCameraRoll: true, // Default ON
+    autoSaveDisableWarningShown: false,
+    imageProcessingEnabled: true, // Lens coefficients calibrated from chessboard photos
+  }
+
+  private constructor() {}
+
+  static getInstance(): GallerySettingsService {
+    if (!GallerySettingsService.instance) {
+      GallerySettingsService.instance = new GallerySettingsService()
+    }
+    return GallerySettingsService.instance
+  }
+
+  async getSettings(): Promise<GallerySettings> {
+    const res = storage.load<GallerySettings>(this.SETTINGS_KEY)
+    if (res.is_error()) {
+      // Not an error - just means settings haven't been saved yet (first use)
+      // Return defaults silently
+      return this.DEFAULT_SETTINGS
+    }
+    const stored = res.value
+    return {...this.DEFAULT_SETTINGS, ...stored}
+  }
+
+  async updateSettings(settings: Partial<GallerySettings>): Promise<void> {
+    const current = await this.getSettings()
+    const updated = {...current, ...settings}
+    const res = await storage.save(this.SETTINGS_KEY, updated)
+    if (res.is_error()) {
+      console.error("[GallerySettings] Error saving settings:", res.error)
+      throw res.error
+    }
+    console.log("[GallerySettings] Settings updated:", updated)
+  }
+
+  async getAutoSaveToCameraRoll(): Promise<boolean> {
+    const settings = await this.getSettings()
+    return settings.autoSaveToCameraRoll
+  }
+
+  async setAutoSaveToCameraRoll(enabled: boolean): Promise<void> {
+    await this.updateSettings({autoSaveToCameraRoll: enabled})
+  }
+
+  async getImageProcessingEnabled(): Promise<boolean> {
+    const settings = await this.getSettings()
+    return settings.imageProcessingEnabled
+  }
+
+  async setImageProcessingEnabled(enabled: boolean): Promise<void> {
+    await this.updateSettings({imageProcessingEnabled: enabled})
+  }
+}
+
+export const gallerySettingsService = GallerySettingsService.getInstance()

package/src/services/asg/gallerySyncNotifications.ts

@@ -0,0 +1,236 @@
+/**
+ * Gallery Sync Notifications
+ * Manages system notifications for gallery sync progress
+ *
+ * Platform differences:
+ * - Android: Supports ongoing/sticky notifications that update silently
+ * - iOS: Each notification update shows a banner, so we throttle updates
+ *        and only show start/complete notifications to avoid spam
+ */
+
+// import * as Notifications from "expo-notifications"
+import {Platform} from "react-native"
+
+// iOS throttling - only update every N seconds to avoid banner spam
+const IOS_UPDATE_THROTTLE_MS = 10000 // 10 seconds between updates on iOS
+
+// Configure notification handler
+// Notifications.setNotificationHandler({
+//   handleNotification: async () => ({
+//     shouldShowAlert: true,
+//     shouldPlaySound: false,
+//     shouldSetBadge: false,
+//     // On iOS, minimize banner popups for progress updates
+//     shouldShowBanner: Platform.OS === "android",
+//     shouldShowList: true,
+//   }),
+// })
+
+class GallerySyncNotifications {
+  private static instance: GallerySyncNotifications
+  private notificationActive = false
+  private lastUpdateTime = 0 // For iOS throttling
+
+  private constructor() {}
+
+  static getInstance(): GallerySyncNotifications {
+    if (!GallerySyncNotifications.instance) {
+      GallerySyncNotifications.instance = new GallerySyncNotifications()
+    }
+    return GallerySyncNotifications.instance
+  }
+
+  /**
+   * Initialize notification channel (Android only)
+   */
+  private async ensureChannel(): Promise<void> {
+    // if (this.channelCreated) return
+
+    // if (Platform.OS === "android") {
+    //   await Notifications.setNotificationChannelAsync(CHANNEL_ID, {
+    //     name: "Gallery Sync",
+    //     description: "Shows progress when syncing photos from your glasses",
+    //     importance: Notifications.AndroidImportance.LOW, // Low = no sound, shows in shade
+    //     vibrationPattern: [0], // No vibration
+    //     lightColor: "#4A90D9",
+    //     lockscreenVisibility: Notifications.AndroidNotificationVisibility.PUBLIC,
+    //     bypassDnd: false,
+    //     enableLights: false,
+    //     enableVibrate: false,
+    //     showBadge: false,
+    //   })
+    // }
+  }
+
+  /**
+   * Request notification permissions
+   */
+  async requestPermissions(): Promise<boolean> {
+    // const {status: existingStatus} = await Notifications.getPermissionsAsync()
+
+    // if (existingStatus === "granted") {
+    //   return true
+    // }
+
+    // const {status} = await Notifications.requestPermissionsAsync()
+    // return status === "granted"
+    return true // Always return true when notifications disabled
+  }
+
+  /**
+   * Show initial sync notification
+   */
+  async showSyncStarted(totalFiles: number): Promise<void> {
+    await this.ensureChannel()
+
+    const hasPermission = await this.requestPermissions()
+    if (!hasPermission) {
+      console.log("[SyncNotifications] No notification permission, skipping")
+      return
+    }
+
+    // await Notifications.scheduleNotificationAsync({
+    //   identifier: SYNC_NOTIFICATION_ID,
+    //   content: {
+    //     title: "Syncing photos from glasses",
+    //     body: `Preparing to download ${totalFiles} ${totalFiles === 1 ? "file" : "files"}...`,
+    //     data: {type: "gallery-sync"},
+    //     sticky: Platform.OS === "android", // Ongoing notification on Android
+    //   },
+    //   trigger: null, // Show immediately
+    // })
+
+    this.notificationActive = true
+    this.lastUpdateTime = Date.now() // Reset throttle timer
+    console.log(`[SyncNotifications] Started sync notification for ${totalFiles} files (notifications disabled)`)
+  }
+
+  /**
+   * Update sync progress notification
+   * On iOS, updates are throttled to avoid spamming the user with banner notifications
+   */
+  async updateProgress(
+    currentFile: number,
+    totalFiles: number,
+    _fileName: string,
+    fileProgress: number,
+  ): Promise<void> {
+    if (!this.notificationActive) return
+
+    // On iOS, throttle updates to avoid banner spam
+    // iOS doesn't support silent notification updates like Android's ongoing notifications
+    if (Platform.OS === "ios") {
+      const now = Date.now()
+      const timeSinceLastUpdate = now - this.lastUpdateTime
+
+      // Only update if enough time has passed OR if this is the last file completing
+      const isLastFileCompleting = currentFile === totalFiles && fileProgress >= 99
+      if (timeSinceLastUpdate < IOS_UPDATE_THROTTLE_MS && !isLastFileCompleting) {
+        return // Skip this update on iOS to avoid banner spam
+      }
+      this.lastUpdateTime = now
+    }
+
+    await this.ensureChannel()
+
+    // Notifications are disabled; the overall-progress + body computation that fed
+    // scheduleNotificationAsync (below, commented) is omitted to keep this a no-op.
+
+    // await Notifications.scheduleNotificationAsync({
+    //   identifier: SYNC_NOTIFICATION_ID,
+    //   content: {
+    //     title: "Syncing photos from glasses",
+    //     body,
+    //     data: {type: "gallery-sync", progress: overallProgress},
+    //     sticky: Platform.OS === "android", // Keep notification visible on Android
+    //   },
+    //   trigger: null,
+    // })
+  }
+
+  /**
+   * Show sync complete notification
+   */
+  async showSyncComplete(downloadedCount: number, failedCount: number = 0): Promise<void> {
+    await this.ensureChannel()
+
+    // Notifications are disabled; the title/body computation that fed
+    // scheduleNotificationAsync (below, commented) is omitted to keep this a no-op.
+
+    // await Notifications.scheduleNotificationAsync({
+    //   identifier: SYNC_NOTIFICATION_ID,
+    //   content: {
+    //     title,
+    //     body,
+    //     data: {type: "gallery-sync-complete"},
+    //   },
+    //   trigger: null,
+    // })
+
+    this.notificationActive = false
+    console.log(
+      `[SyncNotifications] Sync complete: ${downloadedCount} downloaded, ${failedCount} failed (notifications disabled)`,
+    )
+
+    // Auto-dismiss after 5 seconds
+    // setTimeout(() => {
+    //   this.dismiss()
+    // }, 5000)
+  }
+
+  /**
+   * Show sync error notification
+   */
+  async showSyncError(errorMessage: string): Promise<void> {
+    await this.ensureChannel()
+
+    // await Notifications.scheduleNotificationAsync({
+    //   identifier: SYNC_NOTIFICATION_ID,
+    //   content: {
+    //     title: "Sync failed",
+    //     body: errorMessage,
+    //     data: {type: "gallery-sync-error"},
+    //   },
+    //   trigger: null,
+    // })
+
+    this.notificationActive = false
+    console.log(`[SyncNotifications] Sync error: ${errorMessage} (notifications disabled)`)
+
+    // Auto-dismiss after 5 seconds
+    // setTimeout(() => {
+    //   this.dismiss()
+    // }, 5000)
+  }
+
+  /**
+   * Show sync cancelled notification
+   */
+  async showSyncCancelled(): Promise<void> {
+    await this.dismiss()
+    this.notificationActive = false
+    console.log("[SyncNotifications] Sync cancelled, notification dismissed")
+  }
+
+  /**
+   * Dismiss sync notification
+   */
+  async dismiss(): Promise<void> {
+    try {
+      // await Notifications.dismissNotificationAsync(SYNC_NOTIFICATION_ID)
+      this.notificationActive = false
+    } catch (error) {
+      // Notification may already be dismissed
+      console.log("[SyncNotifications] Error dismissing notification:", error)
+    }
+  }
+
+  /**
+   * Check if sync notification is currently active
+   */
+  isActive(): boolean {
+    return this.notificationActive
+  }
+}
+
+export const gallerySyncNotifications = GallerySyncNotifications.getInstance()