Source Code added

2026-02-02 15:06:40 +01:00 · 2026-02-02 15:06:40 +01:00 · 9efa9bc6dd
commit 9efa9bc6dd
parent 800376eafd
3912 changed files with 754770 additions and 2 deletions
--- a/mobile/lib/domain/README.md
+++ b/mobile/lib/domain/README.md
@ -0,0 +1,34 @@
+# Domain Layer
+
+This directory contains the domain layer of Immich. The domain layer is responsible for the business logic of the app. It includes interfaces for repositories, models, services and utilities. This layer should never depend on anything from the presentation layer or from the infrastructure layer.
+
+## Structure
+
+- **[Interfaces](./interfaces/)**: These are the interfaces that define the contract for data operations.
+- **[Models](./models/)**: These are the core data classes that represent the business models.
+- **[Services](./services/)**: These are the classes that contain the business logic and interact with the repositories.
+- **[Utils](./utils/)**: These are utility classes and functions that provide common functionalities used across the domain layer.
+
+```
+domain/
+├── interfaces/
+│   └── user.interface.dart
+├── models/
+│   └── user.model.dart
+├── services/
+│   └── user.service.dart
+└── utils/
+    └── date_utils.dart
+```
+
+## Usage
+
+The domain layer provides services that implement the business logic by consuming repositories through dependency injection. Services are exposed through Riverpod providers in the root `providers` directory.
+
+```dart
+// In presentation layer
+final userService = ref.watch(userServiceProvider);
+final user = await userService.getUser(userId);
+```
+
+The presentation layer should never directly use repositories, but instead interact with the domain layer through services.
--- a/mobile/lib/domain/interfaces/db.interface.dart
+++ b/mobile/lib/domain/interfaces/db.interface.dart
@ -0,0 +1,3 @@
+abstract interface class IDatabaseRepository {
+  Future<T> transaction<T>(Future<T> Function() callback);
+}
--- a/mobile/lib/domain/models/album/album.model.dart
+++ b/mobile/lib/domain/models/album/album.model.dart
@ -0,0 +1,124 @@
+enum AlbumAssetOrder {
+  // do not change this order!
+  asc,
+  desc,
+}
+
+enum AlbumUserRole {
+  // do not change this order!
+  editor,
+  viewer,
+}
+
+// Model for an album stored in the server
+class RemoteAlbum {
+  final String id;
+  final String name;
+  final String ownerId;
+  final String description;
+  final DateTime createdAt;
+  final DateTime updatedAt;
+  final String? thumbnailAssetId;
+  final bool isActivityEnabled;
+  final AlbumAssetOrder order;
+  final int assetCount;
+  final String ownerName;
+  final bool isShared;
+
+  const RemoteAlbum({
+    required this.id,
+    required this.name,
+    required this.ownerId,
+    required this.description,
+    required this.createdAt,
+    required this.updatedAt,
+    this.thumbnailAssetId,
+    required this.isActivityEnabled,
+    required this.order,
+    required this.assetCount,
+    required this.ownerName,
+    required this.isShared,
+  });
+
+  @override
+  String toString() {
+    return '''Album {
+    id: $id,
+    name: $name,
+    ownerId: $ownerId,
+    description: $description,
+    createdAt: $createdAt,
+    updatedAt: $updatedAt,
+    isActivityEnabled: $isActivityEnabled,
+    order: $order,
+    thumbnailAssetId: ${thumbnailAssetId ?? "<NA>"}
+    assetCount: $assetCount
+    ownerName: $ownerName
+    isShared: $isShared
+ }''';
+  }
+
+  @override
+  bool operator ==(Object other) {
+    if (other is! RemoteAlbum) return false;
+    if (identical(this, other)) return true;
+    return id == other.id &&
+        name == other.name &&
+        ownerId == other.ownerId &&
+        description == other.description &&
+        createdAt == other.createdAt &&
+        updatedAt == other.updatedAt &&
+        thumbnailAssetId == other.thumbnailAssetId &&
+        isActivityEnabled == other.isActivityEnabled &&
+        order == other.order &&
+        assetCount == other.assetCount &&
+        ownerName == other.ownerName &&
+        isShared == other.isShared;
+  }
+
+  @override
+  int get hashCode {
+    return id.hashCode ^
+        name.hashCode ^
+        ownerId.hashCode ^
+        description.hashCode ^
+        createdAt.hashCode ^
+        updatedAt.hashCode ^
+        thumbnailAssetId.hashCode ^
+        isActivityEnabled.hashCode ^
+        order.hashCode ^
+        assetCount.hashCode ^
+        ownerName.hashCode ^
+        isShared.hashCode;
+  }
+
+  RemoteAlbum copyWith({
+    String? id,
+    String? name,
+    String? ownerId,
+    String? description,
+    DateTime? createdAt,
+    DateTime? updatedAt,
+    String? thumbnailAssetId,
+    bool? isActivityEnabled,
+    AlbumAssetOrder? order,
+    int? assetCount,
+    String? ownerName,
+    bool? isShared,
+  }) {
+    return RemoteAlbum(
+      id: id ?? this.id,
+      name: name ?? this.name,
+      ownerId: ownerId ?? this.ownerId,
+      description: description ?? this.description,
+      createdAt: createdAt ?? this.createdAt,
+      updatedAt: updatedAt ?? this.updatedAt,
+      thumbnailAssetId: thumbnailAssetId ?? this.thumbnailAssetId,
+      isActivityEnabled: isActivityEnabled ?? this.isActivityEnabled,
+      order: order ?? this.order,
+      assetCount: assetCount ?? this.assetCount,
+      ownerName: ownerName ?? this.ownerName,
+      isShared: isShared ?? this.isShared,
+    );
+  }
+}
--- a/mobile/lib/domain/models/album/local_album.model.dart
+++ b/mobile/lib/domain/models/album/local_album.model.dart
@ -0,0 +1,87 @@
+enum BackupSelection {
+  // Used to sort albums based on the backupSelection
+  // selected -> none -> excluded
+  // Do not change the order of these values
+  selected,
+  none,
+  excluded,
+}
+
+class LocalAlbum {
+  final String id;
+  final String name;
+  final DateTime updatedAt;
+  final bool isIosSharedAlbum;
+
+  final int assetCount;
+  final BackupSelection backupSelection;
+  final String? linkedRemoteAlbumId;
+
+  const LocalAlbum({
+    required this.id,
+    required this.name,
+    required this.updatedAt,
+    this.assetCount = 0,
+    this.backupSelection = BackupSelection.none,
+    this.isIosSharedAlbum = false,
+    this.linkedRemoteAlbumId,
+  });
+
+  LocalAlbum copyWith({
+    String? id,
+    String? name,
+    DateTime? updatedAt,
+    int? assetCount,
+    BackupSelection? backupSelection,
+    bool? isIosSharedAlbum,
+    String? linkedRemoteAlbumId,
+  }) {
+    return LocalAlbum(
+      id: id ?? this.id,
+      name: name ?? this.name,
+      updatedAt: updatedAt ?? this.updatedAt,
+      assetCount: assetCount ?? this.assetCount,
+      backupSelection: backupSelection ?? this.backupSelection,
+      isIosSharedAlbum: isIosSharedAlbum ?? this.isIosSharedAlbum,
+      linkedRemoteAlbumId: linkedRemoteAlbumId ?? this.linkedRemoteAlbumId,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) {
+    if (other is! LocalAlbum) return false;
+    if (identical(this, other)) return true;
+
+    return other.id == id &&
+        other.name == name &&
+        other.updatedAt == updatedAt &&
+        other.assetCount == assetCount &&
+        other.backupSelection == backupSelection &&
+        other.isIosSharedAlbum == isIosSharedAlbum &&
+        other.linkedRemoteAlbumId == linkedRemoteAlbumId;
+  }
+
+  @override
+  int get hashCode {
+    return id.hashCode ^
+        name.hashCode ^
+        updatedAt.hashCode ^
+        assetCount.hashCode ^
+        backupSelection.hashCode ^
+        isIosSharedAlbum.hashCode ^
+        linkedRemoteAlbumId.hashCode;
+  }
+
+  @override
+  String toString() {
+    return '''LocalAlbum: {
+id: $id,
+name: $name,
+updatedAt: $updatedAt,
+assetCount: $assetCount,
+backupSelection: $backupSelection,
+isIosSharedAlbum: $isIosSharedAlbum
+linkedRemoteAlbumId: $linkedRemoteAlbumId,
+}''';
+  }
+}
--- a/mobile/lib/domain/models/asset/asset_metadata.model.dart
+++ b/mobile/lib/domain/models/asset/asset_metadata.model.dart
@ -0,0 +1,62 @@
+enum RemoteAssetMetadataKey {
+  mobileApp("mobile-app");
+
+  final String key;
+
+  const RemoteAssetMetadataKey(this.key);
+}
+
+abstract class RemoteAssetMetadataValue {
+  const RemoteAssetMetadataValue();
+
+  Map<String, dynamic> toJson();
+}
+
+class RemoteAssetMetadataItem {
+  final RemoteAssetMetadataKey key;
+  final RemoteAssetMetadataValue value;
+
+  const RemoteAssetMetadataItem({required this.key, required this.value});
+
+  Map<String, Object?> toJson() {
+    return {'key': key.key, 'value': value};
+  }
+}
+
+class RemoteAssetMobileAppMetadata extends RemoteAssetMetadataValue {
+  final String? cloudId;
+  final String? createdAt;
+  final String? adjustmentTime;
+  final String? latitude;
+  final String? longitude;
+
+  const RemoteAssetMobileAppMetadata({
+    this.cloudId,
+    this.createdAt,
+    this.adjustmentTime,
+    this.latitude,
+    this.longitude,
+  });
+
+  @override
+  Map<String, dynamic> toJson() {
+    final map = <String, Object?>{};
+    if (cloudId != null) {
+      map["iCloudId"] = cloudId;
+    }
+    if (createdAt != null) {
+      map["createdAt"] = createdAt;
+    }
+    if (adjustmentTime != null) {
+      map["adjustmentTime"] = adjustmentTime;
+    }
+    if (latitude != null) {
+      map["latitude"] = latitude;
+    }
+    if (longitude != null) {
+      map["longitude"] = longitude;
+    }
+
+    return map;
+  }
+}
--- a/mobile/lib/domain/models/asset/base_asset.model.dart
+++ b/mobile/lib/domain/models/asset/base_asset.model.dart
@ -0,0 +1,109 @@
+part 'local_asset.model.dart';
+part 'remote_asset.model.dart';
+
+enum AssetType {
+  // do not change this order!
+  other,
+  image,
+  video,
+  audio,
+}
+
+enum AssetState { local, remote, merged }
+
+sealed class BaseAsset {
+  final String name;
+  final String? checksum;
+  final AssetType type;
+  final DateTime createdAt;
+  final DateTime updatedAt;
+  final int? width;
+  final int? height;
+  final int? durationInSeconds;
+  final bool isFavorite;
+  final String? livePhotoVideoId;
+  final bool isEdited;
+
+  const BaseAsset({
+    required this.name,
+    required this.checksum,
+    required this.type,
+    required this.createdAt,
+    required this.updatedAt,
+    this.width,
+    this.height,
+    this.durationInSeconds,
+    this.isFavorite = false,
+    this.livePhotoVideoId,
+    required this.isEdited,
+  });
+
+  bool get isImage => type == AssetType.image;
+  bool get isVideo => type == AssetType.video;
+
+  bool get isMotionPhoto => livePhotoVideoId != null;
+
+  Duration get duration {
+    final durationInSeconds = this.durationInSeconds;
+    if (durationInSeconds != null) {
+      return Duration(seconds: durationInSeconds);
+    }
+    return const Duration();
+  }
+
+  bool get hasRemote => storage == AssetState.remote || storage == AssetState.merged;
+  bool get hasLocal => storage == AssetState.local || storage == AssetState.merged;
+  bool get isLocalOnly => storage == AssetState.local;
+  bool get isRemoteOnly => storage == AssetState.remote;
+
+  // Overridden in subclasses
+  AssetState get storage;
+  String? get localId;
+  String? get remoteId;
+  String get heroTag;
+
+  @override
+  String toString() {
+    return '''BaseAsset {
+  name: $name,
+  type: $type,
+  createdAt: $createdAt,
+  updatedAt: $updatedAt,
+  width: ${width ?? "<NA>"},
+  height: ${height ?? "<NA>"},
+  durationInSeconds: ${durationInSeconds ?? "<NA>"},
+  isFavorite: $isFavorite,
+  isEdited: $isEdited,
+}''';
+  }
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    if (other is BaseAsset) {
+      return name == other.name &&
+          type == other.type &&
+          createdAt == other.createdAt &&
+          updatedAt == other.updatedAt &&
+          width == other.width &&
+          height == other.height &&
+          durationInSeconds == other.durationInSeconds &&
+          isFavorite == other.isFavorite &&
+          isEdited == other.isEdited;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    return name.hashCode ^
+        type.hashCode ^
+        createdAt.hashCode ^
+        updatedAt.hashCode ^
+        width.hashCode ^
+        height.hashCode ^
+        durationInSeconds.hashCode ^
+        isFavorite.hashCode ^
+        isEdited.hashCode;
+  }
+}
--- a/mobile/lib/domain/models/asset/local_asset.model.dart
+++ b/mobile/lib/domain/models/asset/local_asset.model.dart
@ -0,0 +1,133 @@
+part of 'base_asset.model.dart';
+
+class LocalAsset extends BaseAsset {
+  final String id;
+  final String? remoteAssetId;
+  final String? cloudId;
+  final int orientation;
+
+  final DateTime? adjustmentTime;
+  final double? latitude;
+  final double? longitude;
+
+  const LocalAsset({
+    required this.id,
+    String? remoteId,
+    this.cloudId,
+    required super.name,
+    super.checksum,
+    required super.type,
+    required super.createdAt,
+    required super.updatedAt,
+    super.width,
+    super.height,
+    super.durationInSeconds,
+    super.isFavorite = false,
+    super.livePhotoVideoId,
+    this.orientation = 0,
+    this.adjustmentTime,
+    this.latitude,
+    this.longitude,
+    required super.isEdited,
+  }) : remoteAssetId = remoteId;
+
+  @override
+  String? get localId => id;
+
+  @override
+  String? get remoteId => remoteAssetId;
+
+  @override
+  AssetState get storage => remoteId == null ? AssetState.local : AssetState.merged;
+
+  @override
+  String get heroTag => '${id}_${remoteId ?? checksum}';
+
+  bool get hasCoordinates => latitude != null && longitude != null && latitude != 0 && longitude != 0;
+
+  @override
+  String toString() {
+    return '''LocalAsset {
+   id: $id,
+   name: $name,
+   type: $type,
+   createdAt: $createdAt,
+   updatedAt: $updatedAt,
+   width: ${width ?? "<NA>"},
+   height: ${height ?? "<NA>"},
+   durationInSeconds: ${durationInSeconds ?? "<NA>"},
+   remoteId: ${remoteId ?? "<NA>"},
+   cloudId: ${cloudId ?? "<NA>"},
+   checksum: ${checksum ?? "<NA>"},
+   isFavorite: $isFavorite,
+   orientation: $orientation,
+   adjustmentTime: $adjustmentTime,
+   latitude: ${latitude ?? "<NA>"},
+   longitude: ${longitude ?? "<NA>"},
+ }''';
+  }
+
+  // Not checking for remoteId here
+  @override
+  bool operator ==(Object other) {
+    if (other is! LocalAsset) return false;
+    if (identical(this, other)) return true;
+    return super == other &&
+        id == other.id &&
+        cloudId == other.cloudId &&
+        orientation == other.orientation &&
+        adjustmentTime == other.adjustmentTime &&
+        latitude == other.latitude &&
+        longitude == other.longitude;
+  }
+
+  @override
+  int get hashCode =>
+      super.hashCode ^
+      id.hashCode ^
+      remoteId.hashCode ^
+      orientation.hashCode ^
+      adjustmentTime.hashCode ^
+      latitude.hashCode ^
+      longitude.hashCode;
+
+  LocalAsset copyWith({
+    String? id,
+    String? remoteId,
+    String? cloudId,
+    String? name,
+    String? checksum,
+    AssetType? type,
+    DateTime? createdAt,
+    DateTime? updatedAt,
+    int? width,
+    int? height,
+    int? durationInSeconds,
+    bool? isFavorite,
+    int? orientation,
+    DateTime? adjustmentTime,
+    double? latitude,
+    double? longitude,
+    bool? isEdited,
+  }) {
+    return LocalAsset(
+      id: id ?? this.id,
+      remoteId: remoteId ?? this.remoteId,
+      cloudId: cloudId ?? this.cloudId,
+      name: name ?? this.name,
+      checksum: checksum ?? this.checksum,
+      type: type ?? this.type,
+      createdAt: createdAt ?? this.createdAt,
+      updatedAt: updatedAt ?? this.updatedAt,
+      width: width ?? this.width,
+      height: height ?? this.height,
+      durationInSeconds: durationInSeconds ?? this.durationInSeconds,
+      isFavorite: isFavorite ?? this.isFavorite,
+      orientation: orientation ?? this.orientation,
+      adjustmentTime: adjustmentTime ?? this.adjustmentTime,
+      latitude: latitude ?? this.latitude,
+      longitude: longitude ?? this.longitude,
+      isEdited: isEdited ?? this.isEdited,
+    );
+  }
+}
--- a/mobile/lib/domain/models/asset/remote_asset.model.dart
+++ b/mobile/lib/domain/models/asset/remote_asset.model.dart
@ -0,0 +1,130 @@
+part of 'base_asset.model.dart';
+
+enum AssetVisibility { timeline, hidden, archive, locked }
+
+// Model for an asset stored in the server
+class RemoteAsset extends BaseAsset {
+  final String id;
+  final String? localAssetId;
+  final String? thumbHash;
+  final AssetVisibility visibility;
+  final String ownerId;
+  final String? stackId;
+
+  const RemoteAsset({
+    required this.id,
+    String? localId,
+    required super.name,
+    required this.ownerId,
+    required super.checksum,
+    required super.type,
+    required super.createdAt,
+    required super.updatedAt,
+    super.width,
+    super.height,
+    super.durationInSeconds,
+    super.isFavorite = false,
+    this.thumbHash,
+    this.visibility = AssetVisibility.timeline,
+    super.livePhotoVideoId,
+    this.stackId,
+    required super.isEdited,
+  }) : localAssetId = localId;
+
+  @override
+  String? get localId => localAssetId;
+
+  @override
+  String? get remoteId => id;
+
+  @override
+  AssetState get storage => localId == null ? AssetState.remote : AssetState.merged;
+
+  @override
+  String get heroTag => '${localId ?? checksum}_$id';
+
+  @override
+  String toString() {
+    return '''Asset {
+    id: $id,
+    name: $name,
+    ownerId: $ownerId,
+    type: $type,
+    createdAt: $createdAt,
+    updatedAt: $updatedAt,
+    width: ${width ?? "<NA>"},
+    height: ${height ?? "<NA>"},
+    durationInSeconds: ${durationInSeconds ?? "<NA>"},
+    localId: ${localId ?? "<NA>"},
+    isFavorite: $isFavorite,
+    thumbHash: ${thumbHash ?? "<NA>"},
+    visibility: $visibility,
+    stackId: ${stackId ?? "<NA>"},
+    checksum: $checksum,
+    livePhotoVideoId: ${livePhotoVideoId ?? "<NA>"},
+ }''';
+  }
+
+  // Not checking for localId here
+  @override
+  bool operator ==(Object other) {
+    if (other is! RemoteAsset) return false;
+    if (identical(this, other)) return true;
+    return super == other &&
+        id == other.id &&
+        ownerId == other.ownerId &&
+        thumbHash == other.thumbHash &&
+        visibility == other.visibility &&
+        stackId == other.stackId;
+  }
+
+  @override
+  int get hashCode =>
+      super.hashCode ^
+      id.hashCode ^
+      ownerId.hashCode ^
+      localId.hashCode ^
+      thumbHash.hashCode ^
+      visibility.hashCode ^
+      stackId.hashCode;
+
+  RemoteAsset copyWith({
+    String? id,
+    String? localId,
+    String? name,
+    String? ownerId,
+    String? checksum,
+    AssetType? type,
+    DateTime? createdAt,
+    DateTime? updatedAt,
+    int? width,
+    int? height,
+    int? durationInSeconds,
+    bool? isFavorite,
+    String? thumbHash,
+    AssetVisibility? visibility,
+    String? livePhotoVideoId,
+    String? stackId,
+    bool? isEdited,
+  }) {
+    return RemoteAsset(
+      id: id ?? this.id,
+      localId: localId ?? this.localId,
+      name: name ?? this.name,
+      ownerId: ownerId ?? this.ownerId,
+      checksum: checksum ?? this.checksum,
+      type: type ?? this.type,
+      createdAt: createdAt ?? this.createdAt,
+      updatedAt: updatedAt ?? this.updatedAt,
+      width: width ?? this.width,
+      height: height ?? this.height,
+      durationInSeconds: durationInSeconds ?? this.durationInSeconds,
+      isFavorite: isFavorite ?? this.isFavorite,
+      thumbHash: thumbHash ?? this.thumbHash,
+      visibility: visibility ?? this.visibility,
+      livePhotoVideoId: livePhotoVideoId ?? this.livePhotoVideoId,
+      stackId: stackId ?? this.stackId,
+      isEdited: isEdited ?? this.isEdited,
+    );
+  }
+}
--- a/mobile/lib/domain/models/asset_face.model.dart
+++ b/mobile/lib/domain/models/asset_face.model.dart
@ -0,0 +1,98 @@
+// Model for an asset face stored in the server
+class AssetFace {
+  final String id;
+  final String assetId;
+  final String? personId;
+  final int imageWidth;
+  final int imageHeight;
+  final int boundingBoxX1;
+  final int boundingBoxY1;
+  final int boundingBoxX2;
+  final int boundingBoxY2;
+  final String sourceType;
+
+  const AssetFace({
+    required this.id,
+    required this.assetId,
+    this.personId,
+    required this.imageWidth,
+    required this.imageHeight,
+    required this.boundingBoxX1,
+    required this.boundingBoxY1,
+    required this.boundingBoxX2,
+    required this.boundingBoxY2,
+    required this.sourceType,
+  });
+
+  AssetFace copyWith({
+    String? id,
+    String? assetId,
+    String? personId,
+    int? imageWidth,
+    int? imageHeight,
+    int? boundingBoxX1,
+    int? boundingBoxY1,
+    int? boundingBoxX2,
+    int? boundingBoxY2,
+    String? sourceType,
+  }) {
+    return AssetFace(
+      id: id ?? this.id,
+      assetId: assetId ?? this.assetId,
+      personId: personId ?? this.personId,
+      imageWidth: imageWidth ?? this.imageWidth,
+      imageHeight: imageHeight ?? this.imageHeight,
+      boundingBoxX1: boundingBoxX1 ?? this.boundingBoxX1,
+      boundingBoxY1: boundingBoxY1 ?? this.boundingBoxY1,
+      boundingBoxX2: boundingBoxX2 ?? this.boundingBoxX2,
+      boundingBoxY2: boundingBoxY2 ?? this.boundingBoxY2,
+      sourceType: sourceType ?? this.sourceType,
+    );
+  }
+
+  @override
+  String toString() {
+    return '''AssetFace {
+    id: $id,
+    assetId: $assetId,
+    personId: ${personId ?? "<NA>"},
+    imageWidth: $imageWidth,
+    imageHeight: $imageHeight,
+    boundingBoxX1: $boundingBoxX1,
+    boundingBoxY1: $boundingBoxY1,
+    boundingBoxX2: $boundingBoxX2,
+    boundingBoxY2: $boundingBoxY2,
+    sourceType: $sourceType,
+}''';
+  }
+
+  @override
+  bool operator ==(covariant AssetFace other) {
+    if (identical(this, other)) return true;
+
+    return other.id == id &&
+        other.assetId == assetId &&
+        other.personId == personId &&
+        other.imageWidth == imageWidth &&
+        other.imageHeight == imageHeight &&
+        other.boundingBoxX1 == boundingBoxX1 &&
+        other.boundingBoxY1 == boundingBoxY1 &&
+        other.boundingBoxX2 == boundingBoxX2 &&
+        other.boundingBoxY2 == boundingBoxY2 &&
+        other.sourceType == sourceType;
+  }
+
+  @override
+  int get hashCode {
+    return id.hashCode ^
+        assetId.hashCode ^
+        personId.hashCode ^
+        imageWidth.hashCode ^
+        imageHeight.hashCode ^
+        boundingBoxX1.hashCode ^
+        boundingBoxY1.hashCode ^
+        boundingBoxX2.hashCode ^
+        boundingBoxY2.hashCode ^
+        sourceType.hashCode;
+  }
+}
--- a/mobile/lib/domain/models/device_asset.model.dart
+++ b/mobile/lib/domain/models/device_asset.model.dart
@ -0,0 +1,34 @@
+import 'dart:typed_data';
+
+class DeviceAsset {
+  final String assetId;
+  final Uint8List hash;
+  final DateTime modifiedTime;
+
+  const DeviceAsset({required this.assetId, required this.hash, required this.modifiedTime});
+
+  @override
+  bool operator ==(covariant DeviceAsset other) {
+    if (identical(this, other)) return true;
+
+    return other.assetId == assetId && other.hash == hash && other.modifiedTime == modifiedTime;
+  }
+
+  @override
+  int get hashCode {
+    return assetId.hashCode ^ hash.hashCode ^ modifiedTime.hashCode;
+  }
+
+  @override
+  String toString() {
+    return 'DeviceAsset(assetId: $assetId, hash: $hash, modifiedTime: $modifiedTime)';
+  }
+
+  DeviceAsset copyWith({String? assetId, Uint8List? hash, DateTime? modifiedTime}) {
+    return DeviceAsset(
+      assetId: assetId ?? this.assetId,
+      hash: hash ?? this.hash,
+      modifiedTime: modifiedTime ?? this.modifiedTime,
+    );
+  }
+}
--- a/mobile/lib/domain/models/events.model.dart
+++ b/mobile/lib/domain/models/events.model.dart
@ -0,0 +1,37 @@
+import 'package:immich_mobile/domain/utils/event_stream.dart';
+
+// Timeline Events
+class TimelineReloadEvent extends Event {
+  const TimelineReloadEvent();
+}
+
+class ScrollToTopEvent extends Event {
+  const ScrollToTopEvent();
+}
+
+class ScrollToDateEvent extends Event {
+  final DateTime date;
+
+  const ScrollToDateEvent(this.date);
+}
+
+// Asset Viewer Events
+class ViewerOpenBottomSheetEvent extends Event {
+  final bool activitiesMode;
+  const ViewerOpenBottomSheetEvent({this.activitiesMode = false});
+}
+
+class ViewerReloadAssetEvent extends Event {
+  const ViewerReloadAssetEvent();
+}
+
+// Multi-Select Events
+class MultiSelectToggleEvent extends Event {
+  final bool isEnabled;
+  const MultiSelectToggleEvent(this.isEnabled);
+}
+
+// Map Events
+class MapMarkerReloadEvent extends Event {
+  const MapMarkerReloadEvent();
+}
--- a/mobile/lib/domain/models/exif.model.dart
+++ b/mobile/lib/domain/models/exif.model.dart
@ -0,0 +1,186 @@
+class ExifInfo {
+  final int? assetId;
+  final int? fileSize;
+  final String? description;
+  final bool isFlipped;
+  final String? orientation;
+  final String? timeZone;
+  final DateTime? dateTimeOriginal;
+  final int? rating;
+
+  // GPS
+  final double? latitude;
+  final double? longitude;
+  final String? city;
+  final String? state;
+  final String? country;
+
+  // Camera related
+  final String? make;
+  final String? model;
+  final String? lens;
+  final double? f;
+  final double? mm;
+  final int? iso;
+  final double? exposureSeconds;
+
+  bool get hasCoordinates => latitude != null && longitude != null && latitude != 0 && longitude != 0;
+
+  String get exposureTime {
+    if (exposureSeconds == null) {
+      return "";
+    }
+    if (exposureSeconds! < 1) {
+      return "1/${(1.0 / exposureSeconds!).round()} s";
+    }
+    return "${exposureSeconds!.toStringAsFixed(1)} s";
+  }
+
+  String get fNumber => f == null ? "" : f!.toStringAsFixed(1);
+
+  String get focalLength => mm == null ? "" : mm!.toStringAsFixed(3);
+
+  const ExifInfo({
+    this.assetId,
+    this.fileSize,
+    this.description,
+    this.orientation,
+    this.timeZone,
+    this.dateTimeOriginal,
+    this.rating,
+    this.isFlipped = false,
+    this.latitude,
+    this.longitude,
+    this.city,
+    this.state,
+    this.country,
+    this.make,
+    this.model,
+    this.lens,
+    this.f,
+    this.mm,
+    this.iso,
+    this.exposureSeconds,
+  });
+
+  @override
+  bool operator ==(covariant ExifInfo other) {
+    if (identical(this, other)) return true;
+
+    return other.fileSize == fileSize &&
+        other.description == description &&
+        other.isFlipped == isFlipped &&
+        other.orientation == orientation &&
+        other.timeZone == timeZone &&
+        other.dateTimeOriginal == dateTimeOriginal &&
+        other.rating == rating &&
+        other.latitude == latitude &&
+        other.longitude == longitude &&
+        other.city == city &&
+        other.state == state &&
+        other.country == country &&
+        other.make == make &&
+        other.model == model &&
+        other.lens == lens &&
+        other.f == f &&
+        other.mm == mm &&
+        other.iso == iso &&
+        other.exposureSeconds == exposureSeconds &&
+        other.assetId == assetId;
+  }
+
+  @override
+  int get hashCode {
+    return fileSize.hashCode ^
+        description.hashCode ^
+        orientation.hashCode ^
+        isFlipped.hashCode ^
+        timeZone.hashCode ^
+        dateTimeOriginal.hashCode ^
+        rating.hashCode ^
+        latitude.hashCode ^
+        longitude.hashCode ^
+        city.hashCode ^
+        state.hashCode ^
+        country.hashCode ^
+        make.hashCode ^
+        model.hashCode ^
+        lens.hashCode ^
+        f.hashCode ^
+        mm.hashCode ^
+        iso.hashCode ^
+        exposureSeconds.hashCode ^
+        assetId.hashCode;
+  }
+
+  @override
+  String toString() {
+    return '''{
+fileSize: ${fileSize ?? 'NA'},
+description: ${description ?? 'NA'},
+orientation: ${orientation ?? 'NA'},
+isFlipped: $isFlipped,
+timeZone: ${timeZone ?? 'NA'},
+dateTimeOriginal: ${dateTimeOriginal ?? 'NA'},
+rating: ${rating ?? 'NA'},
+latitude: ${latitude ?? 'NA'},
+longitude: ${longitude ?? 'NA'},
+city: ${city ?? 'NA'},
+state: ${state ?? 'NA'},
+country: ${country ?? '<NA>'},
+make: ${make ?? 'NA'},
+model: ${model ?? 'NA'},
+lens: ${lens ?? 'NA'},
+f: ${f ?? 'NA'},
+mm: ${mm ?? '<NA>'},
+iso: ${iso ?? 'NA'},
+exposureSeconds: ${exposureSeconds ?? 'NA'},
+}''';
+  }
+
+  ExifInfo copyWith({
+    int? assetId,
+    int? fileSize,
+    String? description,
+    String? orientation,
+    String? timeZone,
+    DateTime? dateTimeOriginal,
+    int? rating,
+    double? latitude,
+    double? longitude,
+    String? city,
+    String? state,
+    String? country,
+    bool? isFlipped,
+    String? make,
+    String? model,
+    String? lens,
+    double? f,
+    double? mm,
+    int? iso,
+    double? exposureSeconds,
+  }) {
+    return ExifInfo(
+      assetId: assetId ?? this.assetId,
+      fileSize: fileSize ?? this.fileSize,
+      description: description ?? this.description,
+      orientation: orientation ?? this.orientation,
+      timeZone: timeZone ?? this.timeZone,
+      dateTimeOriginal: dateTimeOriginal ?? this.dateTimeOriginal,
+      rating: rating ?? this.rating,
+      isFlipped: isFlipped ?? this.isFlipped,
+      latitude: latitude ?? this.latitude,
+      longitude: longitude ?? this.longitude,
+      city: city ?? this.city,
+      state: state ?? this.state,
+      country: country ?? this.country,
+      make: make ?? this.make,
+      model: model ?? this.model,
+      lens: lens ?? this.lens,
+      f: f ?? this.f,
+      mm: mm ?? this.mm,
+      iso: iso ?? this.iso,
+      exposureSeconds: exposureSeconds ?? this.exposureSeconds,
+    );
+  }
+}
--- a/mobile/lib/domain/models/log.model.dart
+++ b/mobile/lib/domain/models/log.model.dart
@ -0,0 +1,49 @@
+/// Log levels according to dart logging [Level]
+enum LogLevel { all, finest, finer, fine, config, info, warning, severe, shout, off }
+
+class LogMessage {
+  final String message;
+  final LogLevel level;
+  final DateTime createdAt;
+  final String? logger;
+  final String? error;
+  final String? stack;
+
+  const LogMessage({
+    required this.message,
+    required this.level,
+    required this.createdAt,
+    this.logger,
+    this.error,
+    this.stack,
+  });
+
+  @override
+  bool operator ==(covariant LogMessage other) {
+    if (identical(this, other)) return true;
+
+    return other.message == message &&
+        other.level == level &&
+        other.createdAt == createdAt &&
+        other.logger == logger &&
+        other.error == error &&
+        other.stack == stack;
+  }
+
+  @override
+  int get hashCode {
+    return message.hashCode ^ level.hashCode ^ createdAt.hashCode ^ logger.hashCode ^ error.hashCode ^ stack.hashCode;
+  }
+
+  @override
+  String toString() {
+    return '''LogMessage: {
+message: $message,
+level: $level,
+createdAt: $createdAt,
+logger: ${logger ?? '<NA>'},
+error: ${error ?? '<NA>'},
+stack: ${stack ?? '<NA>'},
+}''';
+  }
+}
--- a/mobile/lib/domain/models/map.model.dart
+++ b/mobile/lib/domain/models/map.model.dart
@ -0,0 +1,18 @@
+import 'package:maplibre_gl/maplibre_gl.dart';
+
+class Marker {
+  final LatLng location;
+  final String assetId;
+
+  const Marker({required this.location, required this.assetId});
+
+  @override
+  bool operator ==(covariant Marker other) {
+    if (identical(this, other)) return true;
+
+    return other.location == location && other.assetId == assetId;
+  }
+
+  @override
+  int get hashCode => location.hashCode ^ assetId.hashCode;
+}
--- a/mobile/lib/domain/models/memory.model.dart
+++ b/mobile/lib/domain/models/memory.model.dart
@ -0,0 +1,169 @@
+// ignore_for_file: public_member_api_docs, sort_constructors_first
+import 'dart:convert';
+
+import 'package:collection/collection.dart';
+
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+
+enum MemoryTypeEnum {
+  // do not change this order!
+  onThisDay,
+}
+
+class MemoryData {
+  final int year;
+
+  const MemoryData({required this.year});
+
+  MemoryData copyWith({int? year}) {
+    return MemoryData(year: year ?? this.year);
+  }
+
+  Map<String, dynamic> toMap() {
+    return <String, dynamic>{'year': year};
+  }
+
+  factory MemoryData.fromMap(Map<String, dynamic> map) {
+    return MemoryData(year: map['year'] as int);
+  }
+
+  String toJson() => json.encode(toMap());
+
+  factory MemoryData.fromJson(String source) => MemoryData.fromMap(json.decode(source) as Map<String, dynamic>);
+
+  @override
+  String toString() => 'MemoryData(year: $year)';
+
+  @override
+  bool operator ==(covariant MemoryData other) {
+    if (identical(this, other)) return true;
+
+    return other.year == year;
+  }
+
+  @override
+  int get hashCode => year.hashCode;
+}
+
+// Model for a memory stored in the server
+class DriftMemory {
+  final String id;
+  final DateTime createdAt;
+  final DateTime updatedAt;
+  final DateTime? deletedAt;
+  final String ownerId;
+
+  // enum
+  final MemoryTypeEnum type;
+  final MemoryData data;
+  final bool isSaved;
+  final DateTime memoryAt;
+  final DateTime? seenAt;
+  final DateTime? showAt;
+  final DateTime? hideAt;
+  final List<RemoteAsset> assets;
+
+  const DriftMemory({
+    required this.id,
+    required this.createdAt,
+    required this.updatedAt,
+    this.deletedAt,
+    required this.ownerId,
+    required this.type,
+    required this.data,
+    required this.isSaved,
+    required this.memoryAt,
+    this.seenAt,
+    this.showAt,
+    this.hideAt,
+    required this.assets,
+  });
+
+  DriftMemory copyWith({
+    String? id,
+    DateTime? createdAt,
+    DateTime? updatedAt,
+    DateTime? deletedAt,
+    String? ownerId,
+    MemoryTypeEnum? type,
+    MemoryData? data,
+    bool? isSaved,
+    DateTime? memoryAt,
+    DateTime? seenAt,
+    DateTime? showAt,
+    DateTime? hideAt,
+    List<RemoteAsset>? assets,
+  }) {
+    return DriftMemory(
+      id: id ?? this.id,
+      createdAt: createdAt ?? this.createdAt,
+      updatedAt: updatedAt ?? this.updatedAt,
+      deletedAt: deletedAt ?? this.deletedAt,
+      ownerId: ownerId ?? this.ownerId,
+      type: type ?? this.type,
+      data: data ?? this.data,
+      isSaved: isSaved ?? this.isSaved,
+      memoryAt: memoryAt ?? this.memoryAt,
+      seenAt: seenAt ?? this.seenAt,
+      showAt: showAt ?? this.showAt,
+      hideAt: hideAt ?? this.hideAt,
+      assets: assets ?? this.assets,
+    );
+  }
+
+  @override
+  String toString() {
+    return '''Memory {
+    id: $id,
+    createdAt: $createdAt,
+    updatedAt: $updatedAt,
+    deletedAt: ${deletedAt ?? "<NA>"},
+    ownerId: $ownerId,
+    type: $type,
+    data: $data,
+    isSaved: $isSaved,
+    memoryAt: $memoryAt,
+    seenAt: ${seenAt ?? "<NA>"},
+    showAt: ${showAt ?? "<NA>"},
+    hideAt: ${hideAt ?? "<NA>"},
+    assets: $assets
+}''';
+  }
+
+  @override
+  bool operator ==(covariant DriftMemory other) {
+    if (identical(this, other)) return true;
+    final listEquals = const DeepCollectionEquality().equals;
+
+    return other.id == id &&
+        other.createdAt == createdAt &&
+        other.updatedAt == updatedAt &&
+        other.deletedAt == deletedAt &&
+        other.ownerId == ownerId &&
+        other.type == type &&
+        other.data == data &&
+        other.isSaved == isSaved &&
+        other.memoryAt == memoryAt &&
+        other.seenAt == seenAt &&
+        other.showAt == showAt &&
+        other.hideAt == hideAt &&
+        listEquals(other.assets, assets);
+  }
+
+  @override
+  int get hashCode {
+    return id.hashCode ^
+        createdAt.hashCode ^
+        updatedAt.hashCode ^
+        deletedAt.hashCode ^
+        ownerId.hashCode ^
+        type.hashCode ^
+        data.hashCode ^
+        isSaved.hashCode ^
+        memoryAt.hashCode ^
+        seenAt.hashCode ^
+        showAt.hashCode ^
+        hideAt.hashCode ^
+        assets.hashCode;
+  }
+}
--- a/mobile/lib/domain/models/person.model.dart
+++ b/mobile/lib/domain/models/person.model.dart
@ -0,0 +1,190 @@
+import 'dart:convert';
+
+// TODO: Remove PersonDto once Isar is removed
+class PersonDto {
+  const PersonDto({
+    required this.id,
+    this.birthDate,
+    required this.isHidden,
+    required this.name,
+    required this.thumbnailPath,
+    this.updatedAt,
+  });
+
+  final String id;
+  final DateTime? birthDate;
+  final bool isHidden;
+  final String name;
+  final String thumbnailPath;
+  final DateTime? updatedAt;
+
+  @override
+  String toString() {
+    return 'Person(id: $id, birthDate: $birthDate, isHidden: $isHidden, name: $name, thumbnailPath: $thumbnailPath, updatedAt: $updatedAt)';
+  }
+
+  PersonDto copyWith({
+    String? id,
+    DateTime? birthDate,
+    bool? isHidden,
+    String? name,
+    String? thumbnailPath,
+    DateTime? updatedAt,
+  }) {
+    return PersonDto(
+      id: id ?? this.id,
+      birthDate: birthDate ?? this.birthDate,
+      isHidden: isHidden ?? this.isHidden,
+      name: name ?? this.name,
+      thumbnailPath: thumbnailPath ?? this.thumbnailPath,
+      updatedAt: updatedAt ?? this.updatedAt,
+    );
+  }
+
+  Map<String, dynamic> toMap() {
+    return <String, dynamic>{
+      'id': id,
+      'birthDate': birthDate?.millisecondsSinceEpoch,
+      'isHidden': isHidden,
+      'name': name,
+      'thumbnailPath': thumbnailPath,
+      'updatedAt': updatedAt?.millisecondsSinceEpoch,
+    };
+  }
+
+  factory PersonDto.fromMap(Map<String, dynamic> map) {
+    return PersonDto(
+      id: map['id'] as String,
+      birthDate: map['birthDate'] != null ? DateTime.fromMillisecondsSinceEpoch(map['birthDate'] as int) : null,
+      isHidden: map['isHidden'] as bool,
+      name: map['name'] as String,
+      thumbnailPath: map['thumbnailPath'] as String,
+      updatedAt: map['updatedAt'] != null ? DateTime.fromMillisecondsSinceEpoch(map['updatedAt'] as int) : null,
+    );
+  }
+
+  String toJson() => json.encode(toMap());
+
+  factory PersonDto.fromJson(String source) => PersonDto.fromMap(json.decode(source) as Map<String, dynamic>);
+
+  @override
+  bool operator ==(covariant PersonDto other) {
+    if (identical(this, other)) return true;
+
+    return other.id == id &&
+        other.birthDate == birthDate &&
+        other.isHidden == isHidden &&
+        other.name == name &&
+        other.thumbnailPath == thumbnailPath &&
+        other.updatedAt == updatedAt;
+  }
+
+  @override
+  int get hashCode {
+    return id.hashCode ^
+        birthDate.hashCode ^
+        isHidden.hashCode ^
+        name.hashCode ^
+        thumbnailPath.hashCode ^
+        updatedAt.hashCode;
+  }
+}
+
+// Model for a person stored in the server
+class DriftPerson {
+  final String id;
+  final DateTime createdAt;
+  final DateTime updatedAt;
+  final String ownerId;
+  final String name;
+  final String? faceAssetId;
+  final bool isFavorite;
+  final bool isHidden;
+  final String? color;
+  final DateTime? birthDate;
+
+  const DriftPerson({
+    required this.id,
+    required this.createdAt,
+    required this.updatedAt,
+    required this.ownerId,
+    required this.name,
+    this.faceAssetId,
+    required this.isFavorite,
+    required this.isHidden,
+    required this.color,
+    this.birthDate,
+  });
+
+  DriftPerson copyWith({
+    String? id,
+    DateTime? createdAt,
+    DateTime? updatedAt,
+    String? ownerId,
+    String? name,
+    String? faceAssetId,
+    bool? isFavorite,
+    bool? isHidden,
+    String? color,
+    DateTime? birthDate,
+  }) {
+    return DriftPerson(
+      id: id ?? this.id,
+      createdAt: createdAt ?? this.createdAt,
+      updatedAt: updatedAt ?? this.updatedAt,
+      ownerId: ownerId ?? this.ownerId,
+      name: name ?? this.name,
+      faceAssetId: faceAssetId ?? this.faceAssetId,
+      isFavorite: isFavorite ?? this.isFavorite,
+      isHidden: isHidden ?? this.isHidden,
+      color: color ?? this.color,
+      birthDate: birthDate ?? this.birthDate,
+    );
+  }
+
+  @override
+  String toString() {
+    return '''Person {
+    id: $id,
+    createdAt: $createdAt,
+    updatedAt: $updatedAt,
+    ownerId: $ownerId,
+    name: $name,
+    faceAssetId: ${faceAssetId ?? "<NA>"},
+    isFavorite: $isFavorite,
+    isHidden: $isHidden,
+    color: ${color ?? "<NA>"},
+    birthDate: ${birthDate ?? "<NA>"}
+}''';
+  }
+
+  @override
+  bool operator ==(covariant DriftPerson other) {
+    if (identical(this, other)) return true;
+
+    return other.id == id &&
+        other.createdAt == createdAt &&
+        other.updatedAt == updatedAt &&
+        other.ownerId == ownerId &&
+        other.name == name &&
+        other.faceAssetId == faceAssetId &&
+        other.isFavorite == isFavorite &&
+        other.isHidden == isHidden &&
+        other.color == color &&
+        other.birthDate == birthDate;
+  }
+
+  @override
+  int get hashCode {
+    return id.hashCode ^
+        createdAt.hashCode ^
+        updatedAt.hashCode ^
+        ownerId.hashCode ^
+        name.hashCode ^
+        faceAssetId.hashCode ^
+        isFavorite.hashCode ^
+        isHidden.hashCode ^
+        color.hashCode ^
+        birthDate.hashCode;
+  }
+}
--- a/mobile/lib/domain/models/search_result.model.dart
+++ b/mobile/lib/domain/models/search_result.model.dart
@ -0,0 +1,32 @@
+import 'package:collection/collection.dart';
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+
+class SearchResult {
+  final List<BaseAsset> assets;
+  final double scrollOffset;
+  final int? nextPage;
+
+  const SearchResult({required this.assets, this.scrollOffset = 0.0, this.nextPage});
+
+  SearchResult copyWith({List<BaseAsset>? assets, int? nextPage, double? scrollOffset}) {
+    return SearchResult(
+      assets: assets ?? this.assets,
+      nextPage: nextPage ?? this.nextPage,
+      scrollOffset: scrollOffset ?? this.scrollOffset,
+    );
+  }
+
+  @override
+  String toString() => 'SearchResult(assets: ${assets.length}, nextPage: $nextPage, scrollOffset: $scrollOffset)';
+
+  @override
+  bool operator ==(covariant SearchResult other) {
+    if (identical(this, other)) return true;
+    final listEquals = const DeepCollectionEquality().equals;
+
+    return listEquals(other.assets, assets) && other.nextPage == nextPage && other.scrollOffset == scrollOffset;
+  }
+
+  @override
+  int get hashCode => assets.hashCode ^ nextPage.hashCode ^ scrollOffset.hashCode;
+}
--- a/mobile/lib/domain/models/setting.model.dart
+++ b/mobile/lib/domain/models/setting.model.dart
@ -0,0 +1,18 @@
+import 'package:immich_mobile/domain/models/store.model.dart';
+
+enum Setting<T> {
+  tilesPerRow<int>(StoreKey.tilesPerRow, 4),
+  groupAssetsBy<int>(StoreKey.groupAssetsBy, 0),
+  showStorageIndicator<bool>(StoreKey.storageIndicator, true),
+  loadOriginal<bool>(StoreKey.loadOriginal, false),
+  loadOriginalVideo<bool>(StoreKey.loadOriginalVideo, false),
+  autoPlayVideo<bool>(StoreKey.autoPlayVideo, true),
+  preferRemoteImage<bool>(StoreKey.preferRemoteImage, false),
+  advancedTroubleshooting<bool>(StoreKey.advancedTroubleshooting, false),
+  enableBackup<bool>(StoreKey.enableBackup, false);
+
+  const Setting(this.storeKey, this.defaultValue);
+
+  final StoreKey<T> storeKey;
+  final T defaultValue;
+}
--- a/mobile/lib/domain/models/stack.model.dart
+++ b/mobile/lib/domain/models/stack.model.dart
@ -0,0 +1,71 @@
+// Model for a stack stored in the server
+class Stack {
+  final String id;
+  final DateTime createdAt;
+  final DateTime updatedAt;
+  final String ownerId;
+  final String primaryAssetId;
+
+  const Stack({
+    required this.id,
+    required this.createdAt,
+    required this.updatedAt,
+    required this.ownerId,
+    required this.primaryAssetId,
+  });
+
+  Stack copyWith({String? id, DateTime? createdAt, DateTime? updatedAt, String? ownerId, String? primaryAssetId}) {
+    return Stack(
+      id: id ?? this.id,
+      createdAt: createdAt ?? this.createdAt,
+      updatedAt: updatedAt ?? this.updatedAt,
+      ownerId: ownerId ?? this.ownerId,
+      primaryAssetId: primaryAssetId ?? this.primaryAssetId,
+    );
+  }
+
+  @override
+  String toString() {
+    return '''Stack {
+    id: $id,
+    createdAt: $createdAt,
+    updatedAt: $updatedAt,
+    ownerId: $ownerId,
+    primaryAssetId: $primaryAssetId
+}''';
+  }
+
+  @override
+  bool operator ==(covariant Stack other) {
+    if (identical(this, other)) return true;
+
+    return other.id == id &&
+        other.createdAt == createdAt &&
+        other.updatedAt == updatedAt &&
+        other.ownerId == ownerId &&
+        other.primaryAssetId == primaryAssetId;
+  }
+
+  @override
+  int get hashCode {
+    return id.hashCode ^ createdAt.hashCode ^ updatedAt.hashCode ^ ownerId.hashCode ^ primaryAssetId.hashCode;
+  }
+}
+
+class StackResponse {
+  final String id;
+  final String primaryAssetId;
+  final List<String> assetIds;
+
+  const StackResponse({required this.id, required this.primaryAssetId, required this.assetIds});
+
+  @override
+  bool operator ==(covariant StackResponse other) {
+    if (identical(this, other)) return true;
+
+    return other.id == id && other.primaryAssetId == primaryAssetId && other.assetIds == assetIds;
+  }
+
+  @override
+  int get hashCode => id.hashCode ^ primaryAssetId.hashCode ^ assetIds.hashCode;
+}
--- a/mobile/lib/domain/models/store.model.dart
+++ b/mobile/lib/domain/models/store.model.dart
@ -0,0 +1,125 @@
+import 'package:immich_mobile/domain/models/user.model.dart';
+
+/// Key for each possible value in the `Store`.
+/// Defines the data type for each value
+enum StoreKey<T> {
+  version<int>._(0),
+  assetETag<String>._(1),
+  currentUser<UserDto>._(2),
+  deviceIdHash<int>._(3),
+  deviceId<String>._(4),
+  backupFailedSince<DateTime>._(5),
+  backupRequireWifi<bool>._(6),
+  backupRequireCharging<bool>._(7),
+  backupTriggerDelay<int>._(8),
+  serverUrl<String>._(10),
+  accessToken<String>._(11),
+  serverEndpoint<String>._(12),
+  autoBackup<bool>._(13),
+  backgroundBackup<bool>._(14),
+  sslClientCertData<String>._(15),
+  sslClientPasswd<String>._(16),
+  // user settings from [AppSettingsEnum] below:
+  loadPreview<bool>._(100),
+  loadOriginal<bool>._(101),
+  themeMode<String>._(102),
+  tilesPerRow<int>._(103),
+  dynamicLayout<bool>._(104),
+  groupAssetsBy<int>._(105),
+  uploadErrorNotificationGracePeriod<int>._(106),
+  backgroundBackupTotalProgress<bool>._(107),
+  backgroundBackupSingleProgress<bool>._(108),
+  storageIndicator<bool>._(109),
+  thumbnailCacheSize<int>._(110),
+  imageCacheSize<int>._(111),
+  albumThumbnailCacheSize<int>._(112),
+  selectedAlbumSortOrder<int>._(113),
+  advancedTroubleshooting<bool>._(114),
+  logLevel<int>._(115),
+  preferRemoteImage<bool>._(116),
+  loopVideo<bool>._(117),
+  // map related settings
+  mapShowFavoriteOnly<bool>._(118),
+  mapRelativeDate<int>._(119),
+  selfSignedCert<bool>._(120),
+  mapIncludeArchived<bool>._(121),
+  ignoreIcloudAssets<bool>._(122),
+  selectedAlbumSortReverse<bool>._(123),
+  mapThemeMode<int>._(124),
+  mapwithPartners<bool>._(125),
+  enableHapticFeedback<bool>._(126),
+  customHeaders<String>._(127),
+
+  // theme settings
+  primaryColor<String>._(128),
+  dynamicTheme<bool>._(129),
+  colorfulInterface<bool>._(130),
+
+  syncAlbums<bool>._(131),
+
+  // Auto endpoint switching
+  autoEndpointSwitching<bool>._(132),
+  preferredWifiName<String>._(133),
+  localEndpoint<String>._(134),
+  externalEndpointList<String>._(135),
+
+  // Video settings
+  loadOriginalVideo<bool>._(136),
+  manageLocalMediaAndroid<bool>._(137),
+
+  // Read-only Mode settings
+  readonlyModeEnabled<bool>._(138),
+
+  autoPlayVideo<bool>._(139),
+  albumGridView<bool>._(140),
+
+  // Experimental stuff
+  photoManagerCustomFilter<bool>._(1000),
+  betaPromptShown<bool>._(1001),
+  betaTimeline<bool>._(1002),
+  enableBackup<bool>._(1003),
+  useWifiForUploadVideos<bool>._(1004),
+  useWifiForUploadPhotos<bool>._(1005),
+  needBetaMigration<bool>._(1006),
+  // TODO: Remove this after patching open-api
+  shouldResetSync<bool>._(1007),
+
+  // Free up space
+  cleanupKeepFavorites<bool>._(1008),
+  cleanupKeepMediaType<int>._(1009),
+  cleanupKeepAlbumIds<String>._(1010),
+  cleanupCutoffDaysAgo<int>._(1011),
+  cleanupDefaultsInitialized<bool>._(1012),
+
+  syncMigrationStatus<String>._(1013);
+
+  const StoreKey._(this.id);
+  final int id;
+  Type get type => T;
+}
+
+class StoreDto<T> {
+  final StoreKey<T> key;
+  final T? value;
+
+  const StoreDto(this.key, this.value);
+
+  @override
+  String toString() {
+    return '''
+StoreDto: {
+  key: $key,
+  value: ${value ?? '<NA>'},
+}''';
+  }
+
+  @override
+  bool operator ==(covariant StoreDto<T> other) {
+    if (identical(this, other)) return true;
+
+    return other.key == key && other.value == value;
+  }
+
+  @override
+  int get hashCode => key.hashCode ^ value.hashCode;
+}
--- a/mobile/lib/domain/models/sync_event.model.dart
+++ b/mobile/lib/domain/models/sync_event.model.dart
@ -0,0 +1,12 @@
+import 'package:openapi/api.dart';
+
+class SyncEvent {
+  final SyncEntityType type;
+  final Object data;
+  final String ack;
+
+  const SyncEvent({required this.type, required this.data, required this.ack});
+
+  @override
+  String toString() => 'SyncEvent(type: $type, data: $data, ack: $ack)';
+}
--- a/mobile/lib/domain/models/timeline.model.dart
+++ b/mobile/lib/domain/models/timeline.model.dart
@ -0,0 +1,31 @@
+enum GroupAssetsBy { day, month, auto, none }
+
+enum HeaderType { none, month, day, monthAndDay }
+
+class Bucket {
+  final int assetCount;
+
+  const Bucket({required this.assetCount});
+
+  @override
+  bool operator ==(covariant Bucket other) {
+    return assetCount == other.assetCount;
+  }
+
+  @override
+  int get hashCode => assetCount.hashCode;
+}
+
+class TimeBucket extends Bucket {
+  final DateTime date;
+
+  const TimeBucket({required this.date, required super.assetCount});
+
+  @override
+  bool operator ==(covariant TimeBucket other) {
+    return super == other && date == other.date;
+  }
+
+  @override
+  int get hashCode => super.hashCode ^ date.hashCode;
+}
--- a/mobile/lib/domain/models/user.model.dart
+++ b/mobile/lib/domain/models/user.model.dart
@ -0,0 +1,235 @@
+// ignore_for_file: public_member_api_docs, sort_constructors_first
+import 'dart:convert';
+import 'dart:ui';
+
+enum AvatarColor {
+  // do not change this order or reuse indices for other purposes, adding is OK
+  primary("primary"),
+  pink("pink"),
+  red("red"),
+  yellow("yellow"),
+  blue("blue"),
+  green("green"),
+  purple("purple"),
+  orange("orange"),
+  gray("gray"),
+  amber("amber");
+
+  final String value;
+  const AvatarColor(this.value);
+
+  Color toColor({bool isDarkTheme = false}) => switch (this) {
+    AvatarColor.primary => isDarkTheme ? const Color(0xFFABCBFA) : const Color(0xFF4250AF),
+    AvatarColor.pink => const Color.fromARGB(255, 244, 114, 182),
+    AvatarColor.red => const Color.fromARGB(255, 239, 68, 68),
+    AvatarColor.yellow => const Color.fromARGB(255, 234, 179, 8),
+    AvatarColor.blue => const Color.fromARGB(255, 59, 130, 246),
+    AvatarColor.green => const Color.fromARGB(255, 22, 163, 74),
+    AvatarColor.purple => const Color.fromARGB(255, 147, 51, 234),
+    AvatarColor.orange => const Color.fromARGB(255, 234, 88, 12),
+    AvatarColor.gray => const Color.fromARGB(255, 75, 85, 99),
+    AvatarColor.amber => const Color.fromARGB(255, 217, 119, 6),
+  };
+}
+
+// TODO: Rename to User once Isar is removed
+class UserDto {
+  final String id;
+  final String email;
+  final String name;
+  final bool isAdmin;
+  final DateTime? updatedAt;
+
+  final AvatarColor avatarColor;
+
+  final bool memoryEnabled;
+  final bool inTimeline;
+
+  final bool isPartnerSharedBy;
+  final bool isPartnerSharedWith;
+
+  final int quotaUsageInBytes;
+  final int quotaSizeInBytes;
+
+  bool get hasQuota => quotaSizeInBytes > 0;
+
+  final bool hasProfileImage;
+  final DateTime profileChangedAt;
+
+  const UserDto({
+    required this.id,
+    required this.email,
+    required this.name,
+    this.isAdmin = false,
+    this.updatedAt,
+    required this.profileChangedAt,
+    this.avatarColor = AvatarColor.primary,
+    this.memoryEnabled = true,
+    this.inTimeline = false,
+    this.isPartnerSharedBy = false,
+    this.isPartnerSharedWith = false,
+    this.hasProfileImage = false,
+    this.quotaUsageInBytes = 0,
+    this.quotaSizeInBytes = 0,
+  });
+
+  @override
+  String toString() {
+    return '''User: {
+id: $id,
+email: $email,
+name: $name,
+isAdmin: $isAdmin,
+updatedAt: $updatedAt,
+avatarColor: $avatarColor,
+memoryEnabled: $memoryEnabled,
+inTimeline: $inTimeline,
+isPartnerSharedBy: $isPartnerSharedBy,
+isPartnerSharedWith: $isPartnerSharedWith,
+hasProfileImage: $hasProfileImage
+profileChangedAt: $profileChangedAt
+}''';
+  }
+
+  UserDto copyWith({
+    String? id,
+    String? email,
+    String? name,
+    bool? isAdmin,
+    DateTime? updatedAt,
+    AvatarColor? avatarColor,
+    bool? memoryEnabled,
+    bool? inTimeline,
+    bool? isPartnerSharedBy,
+    bool? isPartnerSharedWith,
+    bool? hasProfileImage,
+    DateTime? profileChangedAt,
+    int? quotaSizeInBytes,
+    int? quotaUsageInBytes,
+  }) => UserDto(
+    id: id ?? this.id,
+    email: email ?? this.email,
+    name: name ?? this.name,
+    isAdmin: isAdmin ?? this.isAdmin,
+    updatedAt: updatedAt ?? this.updatedAt,
+    avatarColor: avatarColor ?? this.avatarColor,
+    memoryEnabled: memoryEnabled ?? this.memoryEnabled,
+    inTimeline: inTimeline ?? this.inTimeline,
+    isPartnerSharedBy: isPartnerSharedBy ?? this.isPartnerSharedBy,
+    isPartnerSharedWith: isPartnerSharedWith ?? this.isPartnerSharedWith,
+    hasProfileImage: hasProfileImage ?? this.hasProfileImage,
+    profileChangedAt: profileChangedAt ?? this.profileChangedAt,
+    quotaSizeInBytes: quotaSizeInBytes ?? this.quotaSizeInBytes,
+    quotaUsageInBytes: quotaUsageInBytes ?? this.quotaUsageInBytes,
+  );
+
+  @override
+  bool operator ==(covariant UserDto other) {
+    if (identical(this, other)) return true;
+
+    return other.id == id &&
+        ((updatedAt == null && other.updatedAt == null) ||
+            (updatedAt != null && other.updatedAt != null && other.updatedAt!.isAtSameMomentAs(updatedAt!))) &&
+        other.avatarColor == avatarColor &&
+        other.email == email &&
+        other.name == name &&
+        other.isPartnerSharedBy == isPartnerSharedBy &&
+        other.isPartnerSharedWith == isPartnerSharedWith &&
+        other.isAdmin == isAdmin &&
+        other.memoryEnabled == memoryEnabled &&
+        other.inTimeline == inTimeline &&
+        other.hasProfileImage == hasProfileImage &&
+        other.profileChangedAt.isAtSameMomentAs(profileChangedAt) &&
+        other.quotaSizeInBytes == quotaSizeInBytes &&
+        other.quotaUsageInBytes == quotaUsageInBytes;
+  }
+
+  @override
+  int get hashCode =>
+      id.hashCode ^
+      name.hashCode ^
+      email.hashCode ^
+      updatedAt.hashCode ^
+      isAdmin.hashCode ^
+      avatarColor.hashCode ^
+      memoryEnabled.hashCode ^
+      inTimeline.hashCode ^
+      isPartnerSharedBy.hashCode ^
+      isPartnerSharedWith.hashCode ^
+      hasProfileImage.hashCode ^
+      profileChangedAt.hashCode ^
+      quotaSizeInBytes.hashCode ^
+      quotaUsageInBytes.hashCode;
+}
+
+class PartnerUserDto {
+  final String id;
+  final String email;
+  final String name;
+  final bool inTimeline;
+
+  final String? profileImagePath;
+
+  const PartnerUserDto({
+    required this.id,
+    required this.email,
+    required this.name,
+    required this.inTimeline,
+    this.profileImagePath,
+  });
+
+  PartnerUserDto copyWith({String? id, String? email, String? name, bool? inTimeline, String? profileImagePath}) {
+    return PartnerUserDto(
+      id: id ?? this.id,
+      email: email ?? this.email,
+      name: name ?? this.name,
+      inTimeline: inTimeline ?? this.inTimeline,
+      profileImagePath: profileImagePath ?? this.profileImagePath,
+    );
+  }
+
+  Map<String, dynamic> toMap() {
+    return <String, dynamic>{
+      'id': id,
+      'email': email,
+      'name': name,
+      'inTimeline': inTimeline,
+      'profileImagePath': profileImagePath,
+    };
+  }
+
+  factory PartnerUserDto.fromMap(Map<String, dynamic> map) {
+    return PartnerUserDto(
+      id: map['id'] as String,
+      email: map['email'] as String,
+      name: map['name'] as String,
+      inTimeline: map['inTimeline'] as bool,
+      profileImagePath: map['profileImagePath'] != null ? map['profileImagePath'] as String : null,
+    );
+  }
+
+  String toJson() => json.encode(toMap());
+
+  factory PartnerUserDto.fromJson(String source) => PartnerUserDto.fromMap(json.decode(source) as Map<String, dynamic>);
+
+  @override
+  String toString() {
+    return 'PartnerUserDto(id: $id, email: $email, name: $name, inTimeline: $inTimeline, profileImagePath: $profileImagePath)';
+  }
+
+  @override
+  bool operator ==(covariant PartnerUserDto other) {
+    if (identical(this, other)) return true;
+
+    return other.id == id &&
+        other.email == email &&
+        other.name == name &&
+        other.inTimeline == inTimeline &&
+        other.profileImagePath == profileImagePath;
+  }
+
+  @override
+  int get hashCode {
+    return id.hashCode ^ email.hashCode ^ name.hashCode ^ inTimeline.hashCode ^ profileImagePath.hashCode;
+  }
+}
--- a/mobile/lib/domain/models/user_metadata.model.dart
+++ b/mobile/lib/domain/models/user_metadata.model.dart
@ -0,0 +1,267 @@
+import 'package:immich_mobile/domain/models/user.model.dart';
+
+enum UserMetadataKey {
+  // do not change this order!
+  onboarding,
+  preferences,
+  license,
+}
+
+class Onboarding {
+  final bool isOnboarded;
+
+  const Onboarding({required this.isOnboarded});
+
+  Onboarding copyWith({bool? isOnboarded}) {
+    return Onboarding(isOnboarded: isOnboarded ?? this.isOnboarded);
+  }
+
+  Map<String, Object?> toMap() {
+    final onboarding = <String, Object?>{};
+    onboarding["isOnboarded"] = isOnboarded;
+    return onboarding;
+  }
+
+  factory Onboarding.fromMap(Map<String, Object?> map) {
+    return Onboarding(isOnboarded: map["isOnboarded"] as bool);
+  }
+
+  @override
+  String toString() {
+    return '''Onboarding {
+isOnboarded: $isOnboarded,
+}''';
+  }
+
+  @override
+  bool operator ==(covariant Onboarding other) {
+    if (identical(this, other)) return true;
+
+    return isOnboarded == other.isOnboarded;
+  }
+
+  @override
+  int get hashCode => isOnboarded.hashCode;
+}
+
+class Preferences {
+  final bool foldersEnabled;
+  final bool memoriesEnabled;
+  final bool peopleEnabled;
+  final bool ratingsEnabled;
+  final bool sharedLinksEnabled;
+  final bool tagsEnabled;
+  final AvatarColor userAvatarColor;
+  final bool showSupportBadge;
+
+  const Preferences({
+    this.foldersEnabled = false,
+    this.memoriesEnabled = true,
+    this.peopleEnabled = true,
+    this.ratingsEnabled = false,
+    this.sharedLinksEnabled = true,
+    this.tagsEnabled = false,
+    this.userAvatarColor = AvatarColor.primary,
+    this.showSupportBadge = true,
+  });
+
+  Preferences copyWith({
+    bool? foldersEnabled,
+    bool? memoriesEnabled,
+    bool? peopleEnabled,
+    bool? ratingsEnabled,
+    bool? sharedLinksEnabled,
+    bool? tagsEnabled,
+    AvatarColor? userAvatarColor,
+    bool? showSupportBadge,
+  }) {
+    return Preferences(
+      foldersEnabled: foldersEnabled ?? this.foldersEnabled,
+      memoriesEnabled: memoriesEnabled ?? this.memoriesEnabled,
+      peopleEnabled: peopleEnabled ?? this.peopleEnabled,
+      ratingsEnabled: ratingsEnabled ?? this.ratingsEnabled,
+      sharedLinksEnabled: sharedLinksEnabled ?? this.sharedLinksEnabled,
+      tagsEnabled: tagsEnabled ?? this.tagsEnabled,
+      userAvatarColor: userAvatarColor ?? this.userAvatarColor,
+      showSupportBadge: showSupportBadge ?? this.showSupportBadge,
+    );
+  }
+
+  Map<String, Object?> toMap() {
+    final preferences = <String, Object?>{};
+    preferences["folders-Enabled"] = foldersEnabled;
+    preferences["memories-Enabled"] = memoriesEnabled;
+    preferences["people-Enabled"] = peopleEnabled;
+    preferences["ratings-Enabled"] = ratingsEnabled;
+    preferences["sharedLinks-Enabled"] = sharedLinksEnabled;
+    preferences["tags-Enabled"] = tagsEnabled;
+    preferences["avatar-Color"] = userAvatarColor.value;
+    preferences["purchase-ShowSupportBadge"] = showSupportBadge;
+    return preferences;
+  }
+
+  factory Preferences.fromMap(Map<String, Object?> map) {
+    return Preferences(
+      foldersEnabled: (map["folders"] as Map<String, Object?>?)?["enabled"] as bool? ?? false,
+      memoriesEnabled: (map["memories"] as Map<String, Object?>?)?["enabled"] as bool? ?? true,
+      peopleEnabled: (map["people"] as Map<String, Object?>?)?["enabled"] as bool? ?? true,
+      ratingsEnabled: (map["ratings"] as Map<String, Object?>?)?["enabled"] as bool? ?? false,
+      sharedLinksEnabled: (map["sharedLinks"] as Map<String, Object?>?)?["enabled"] as bool? ?? true,
+      tagsEnabled: (map["tags"] as Map<String, Object?>?)?["enabled"] as bool? ?? false,
+      userAvatarColor: AvatarColor.values.firstWhere(
+        (e) => e.value == (map["avatar"] as Map<String, Object?>?)?["color"] as String?,
+        orElse: () => AvatarColor.primary,
+      ),
+      showSupportBadge: (map["purchase"] as Map<String, Object?>?)?["showSupportBadge"] as bool? ?? true,
+    );
+  }
+
+  @override
+  String toString() {
+    return '''Preferences: {
+foldersEnabled: $foldersEnabled,
+memoriesEnabled: $memoriesEnabled,
+peopleEnabled: $peopleEnabled,
+ratingsEnabled: $ratingsEnabled,
+sharedLinksEnabled: $sharedLinksEnabled,
+tagsEnabled: $tagsEnabled,
+userAvatarColor: $userAvatarColor,
+showSupportBadge: $showSupportBadge,
+}''';
+  }
+
+  @override
+  bool operator ==(covariant Preferences other) {
+    if (identical(this, other)) return true;
+
+    return other.foldersEnabled == foldersEnabled &&
+        other.memoriesEnabled == memoriesEnabled &&
+        other.peopleEnabled == peopleEnabled &&
+        other.ratingsEnabled == ratingsEnabled &&
+        other.sharedLinksEnabled == sharedLinksEnabled &&
+        other.tagsEnabled == tagsEnabled &&
+        other.userAvatarColor == userAvatarColor &&
+        other.showSupportBadge == showSupportBadge;
+  }
+
+  @override
+  int get hashCode {
+    return foldersEnabled.hashCode ^
+        memoriesEnabled.hashCode ^
+        peopleEnabled.hashCode ^
+        ratingsEnabled.hashCode ^
+        sharedLinksEnabled.hashCode ^
+        tagsEnabled.hashCode ^
+        userAvatarColor.hashCode ^
+        showSupportBadge.hashCode;
+  }
+}
+
+class License {
+  final DateTime activatedAt;
+  final String activationKey;
+  final String licenseKey;
+
+  const License({required this.activatedAt, required this.activationKey, required this.licenseKey});
+
+  License copyWith({DateTime? activatedAt, String? activationKey, String? licenseKey}) {
+    return License(
+      activatedAt: activatedAt ?? this.activatedAt,
+      activationKey: activationKey ?? this.activationKey,
+      licenseKey: licenseKey ?? this.licenseKey,
+    );
+  }
+
+  Map<String, Object?> toMap() {
+    final license = <String, Object?>{};
+    license["activatedAt"] = activatedAt;
+    license["activationKey"] = activationKey;
+    license["licenseKey"] = licenseKey;
+    return license;
+  }
+
+  factory License.fromMap(Map<String, Object?> map) {
+    return License(
+      activatedAt: DateTime.parse(map["activatedAt"] as String),
+      activationKey: map["activationKey"] as String,
+      licenseKey: map["licenseKey"] as String,
+    );
+  }
+
+  @override
+  String toString() {
+    return '''License {
+activatedAt: $activatedAt,
+activationKey: $activationKey,
+licenseKey: $licenseKey,
+}''';
+  }
+
+  @override
+  bool operator ==(covariant License other) {
+    if (identical(this, other)) return true;
+
+    return activatedAt == other.activatedAt && activationKey == other.activationKey && licenseKey == other.licenseKey;
+  }
+
+  @override
+  int get hashCode => activatedAt.hashCode ^ activationKey.hashCode ^ licenseKey.hashCode;
+}
+
+// Model for a user metadata stored in the server
+class UserMetadata {
+  final String userId;
+  final UserMetadataKey key;
+  final Onboarding? onboarding;
+  final Preferences? preferences;
+  final License? license;
+
+  const UserMetadata({required this.userId, required this.key, this.onboarding, this.preferences, this.license})
+    : assert(
+        onboarding != null || preferences != null || license != null,
+        'One of onboarding, preferences and license must be provided',
+      );
+
+  UserMetadata copyWith({
+    String? userId,
+    UserMetadataKey? key,
+    Onboarding? onboarding,
+    Preferences? preferences,
+    License? license,
+  }) {
+    return UserMetadata(
+      userId: userId ?? this.userId,
+      key: key ?? this.key,
+      onboarding: onboarding ?? this.onboarding,
+      preferences: preferences ?? this.preferences,
+      license: license ?? this.license,
+    );
+  }
+
+  @override
+  String toString() {
+    return '''UserMetadata: {
+userId: $userId,
+key: $key,
+onboarding: ${onboarding ?? "<NA>"},
+preferences: ${preferences ?? "<NA>"},
+license: ${license ?? "<NA>"},
+}''';
+  }
+
+  @override
+  bool operator ==(covariant UserMetadata other) {
+    if (identical(this, other)) return true;
+
+    return other.userId == userId &&
+        other.key == key &&
+        other.onboarding == onboarding &&
+        other.preferences == preferences &&
+        other.license == license;
+  }
+
+  @override
+  int get hashCode {
+    return userId.hashCode ^ key.hashCode ^ onboarding.hashCode ^ preferences.hashCode ^ license.hashCode;
+  }
+}
--- a/mobile/lib/domain/services/asset.service.dart
+++ b/mobile/lib/domain/services/asset.service.dart
@ -0,0 +1,119 @@
+import 'package:immich_mobile/domain/models/album/local_album.model.dart';
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/domain/models/exif.model.dart';
+import 'package:immich_mobile/extensions/platform_extensions.dart';
+import 'package:immich_mobile/infrastructure/repositories/local_asset.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/remote_asset.repository.dart';
+
+typedef _AssetVideoDimension = ({double? width, double? height, bool isFlipped});
+
+class AssetService {
+  final RemoteAssetRepository _remoteAssetRepository;
+  final DriftLocalAssetRepository _localAssetRepository;
+
+  const AssetService({
+    required RemoteAssetRepository remoteAssetRepository,
+    required DriftLocalAssetRepository localAssetRepository,
+  }) : _remoteAssetRepository = remoteAssetRepository,
+       _localAssetRepository = localAssetRepository;
+
+  Future<BaseAsset?> getAsset(BaseAsset asset) {
+    final id = asset is LocalAsset ? asset.id : (asset as RemoteAsset).id;
+    return asset is LocalAsset ? _localAssetRepository.get(id) : _remoteAssetRepository.get(id);
+  }
+
+  Stream<BaseAsset?> watchAsset(BaseAsset asset) {
+    final id = asset is LocalAsset ? asset.id : (asset as RemoteAsset).id;
+    return asset is LocalAsset ? _localAssetRepository.watch(id) : _remoteAssetRepository.watch(id);
+  }
+
+  Future<List<LocalAsset?>> getLocalAssetsByChecksum(String checksum) {
+    return _localAssetRepository.getByChecksum(checksum);
+  }
+
+  Future<RemoteAsset?> getRemoteAssetByChecksum(String checksum) {
+    return _remoteAssetRepository.getByChecksum(checksum);
+  }
+
+  Future<RemoteAsset?> getRemoteAsset(String id) {
+    return _remoteAssetRepository.get(id);
+  }
+
+  Future<List<RemoteAsset>> getStack(RemoteAsset asset) async {
+    if (asset.stackId == null) {
+      return const [];
+    }
+
+    final stack = await _remoteAssetRepository.getStackChildren(asset);
+    // Include the primary asset in the stack as the first item
+    return [asset, ...stack];
+  }
+
+  Future<ExifInfo?> getExif(BaseAsset asset) async {
+    if (!asset.hasRemote) {
+      return null;
+    }
+
+    final id = asset is LocalAsset ? asset.remoteId! : (asset as RemoteAsset).id;
+    return _remoteAssetRepository.getExif(id);
+  }
+
+  Future<double> getAspectRatio(BaseAsset asset) async {
+    final dimension = asset is LocalAsset
+        ? await _getLocalAssetDimensions(asset)
+        : await _getRemoteAssetDimensions(asset as RemoteAsset);
+
+    if (dimension.width == null || dimension.height == null || dimension.height == 0) {
+      return 1.0;
+    }
+
+    return dimension.isFlipped ? dimension.height! / dimension.width! : dimension.width! / dimension.height!;
+  }
+
+  Future<_AssetVideoDimension> _getLocalAssetDimensions(LocalAsset asset) async {
+    double? width = asset.width?.toDouble();
+    double? height = asset.height?.toDouble();
+    int orientation = asset.orientation;
+
+    if (width == null || height == null) {
+      final fetched = await _localAssetRepository.get(asset.id);
+      width = fetched?.width?.toDouble();
+      height = fetched?.height?.toDouble();
+      orientation = fetched?.orientation ?? 0;
+    }
+
+    // On Android, local assets need orientation correction for 90°/270° rotations
+    // On iOS, the Photos framework pre-corrects dimensions
+    final isFlipped = CurrentPlatform.isAndroid && (orientation == 90 || orientation == 270);
+    return (width: width, height: height, isFlipped: isFlipped);
+  }
+
+  Future<_AssetVideoDimension> _getRemoteAssetDimensions(RemoteAsset asset) async {
+    double? width = asset.width?.toDouble();
+    double? height = asset.height?.toDouble();
+
+    if (width == null || height == null) {
+      final fetched = await _remoteAssetRepository.get(asset.id);
+      width = fetched?.width?.toDouble();
+      height = fetched?.height?.toDouble();
+    }
+
+    return (width: width, height: height, isFlipped: false);
+  }
+
+  Future<List<(String, String)>> getPlaces(String userId) {
+    return _remoteAssetRepository.getPlaces(userId);
+  }
+
+  Future<(int local, int remote)> getAssetCounts() async {
+    return (await _localAssetRepository.getCount(), await _remoteAssetRepository.getCount());
+  }
+
+  Future<int> getLocalHashedCount() {
+    return _localAssetRepository.getHashedCount();
+  }
+
+  Future<List<LocalAlbum>> getSourceAlbums(String localAssetId, {BackupSelection? backupSelection}) {
+    return _localAssetRepository.getSourceAlbums(localAssetId, backupSelection: backupSelection);
+  }
+}
--- a/mobile/lib/domain/services/background_worker.service.dart
+++ b/mobile/lib/domain/services/background_worker.service.dart
@ -0,0 +1,311 @@
+import 'dart:async';
+import 'dart:io';
+import 'dart:ui';
+
+import 'package:background_downloader/background_downloader.dart';
+import 'package:cancellation_token_http/http.dart';
+import 'package:flutter/material.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/constants/constants.dart';
+import 'package:immich_mobile/domain/services/log.service.dart';
+import 'package:immich_mobile/entities/store.entity.dart';
+import 'package:immich_mobile/extensions/platform_extensions.dart';
+import 'package:immich_mobile/infrastructure/repositories/db.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/logger_db.repository.dart';
+import 'package:immich_mobile/platform/background_worker_api.g.dart';
+import 'package:immich_mobile/platform/background_worker_lock_api.g.dart';
+import 'package:immich_mobile/providers/app_settings.provider.dart';
+import 'package:immich_mobile/providers/background_sync.provider.dart';
+import 'package:immich_mobile/providers/backup/drift_backup.provider.dart';
+import 'package:immich_mobile/providers/db.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/db.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/platform.provider.dart' show nativeSyncApiProvider;
+import 'package:immich_mobile/providers/user.provider.dart';
+import 'package:immich_mobile/repositories/file_media.repository.dart';
+import 'package:immich_mobile/services/app_settings.service.dart';
+import 'package:immich_mobile/services/auth.service.dart';
+import 'package:immich_mobile/services/localization.service.dart';
+import 'package:immich_mobile/services/foreground_upload.service.dart';
+import 'package:immich_mobile/utils/bootstrap.dart';
+import 'package:immich_mobile/utils/debug_print.dart';
+import 'package:immich_mobile/utils/http_ssl_options.dart';
+import 'package:immich_mobile/wm_executor.dart';
+import 'package:isar/isar.dart';
+import 'package:logging/logging.dart';
+
+class BackgroundWorkerFgService {
+  final BackgroundWorkerFgHostApi _foregroundHostApi;
+
+  const BackgroundWorkerFgService(this._foregroundHostApi);
+
+  // TODO: Move this call to native side once old timeline is removed
+  Future<void> enable() => _foregroundHostApi.enable();
+
+  Future<void> saveNotificationMessage(String title, String body) =>
+      _foregroundHostApi.saveNotificationMessage(title, body);
+
+  Future<void> configure({int? minimumDelaySeconds, bool? requireCharging}) => _foregroundHostApi.configure(
+    BackgroundWorkerSettings(
+      minimumDelaySeconds:
+          minimumDelaySeconds ??
+          Store.get(AppSettingsEnum.backupTriggerDelay.storeKey, AppSettingsEnum.backupTriggerDelay.defaultValue),
+      requiresCharging:
+          requireCharging ??
+          Store.get(AppSettingsEnum.backupRequireCharging.storeKey, AppSettingsEnum.backupRequireCharging.defaultValue),
+    ),
+  );
+
+  Future<void> disable() => _foregroundHostApi.disable();
+}
+
+class BackgroundWorkerBgService extends BackgroundWorkerFlutterApi {
+  ProviderContainer? _ref;
+  final Isar _isar;
+  final Drift _drift;
+  final DriftLogger _driftLogger;
+  final BackgroundWorkerBgHostApi _backgroundHostApi;
+  final CancellationToken _cancellationToken = CancellationToken();
+  final Logger _logger = Logger('BackgroundWorkerBgService');
+
+  bool _isCleanedUp = false;
+
+  BackgroundWorkerBgService({required Isar isar, required Drift drift, required DriftLogger driftLogger})
+    : _isar = isar,
+      _drift = drift,
+      _driftLogger = driftLogger,
+      _backgroundHostApi = BackgroundWorkerBgHostApi() {
+    _ref = ProviderContainer(
+      overrides: [
+        dbProvider.overrideWithValue(isar),
+        isarProvider.overrideWithValue(isar),
+        driftProvider.overrideWith(driftOverride(drift)),
+      ],
+    );
+    BackgroundWorkerFlutterApi.setUp(this);
+  }
+
+  bool get _isBackupEnabled => _ref?.read(appSettingsServiceProvider).getSetting(AppSettingsEnum.enableBackup) ?? false;
+
+  Future<void> init() async {
+    try {
+      HttpSSLOptions.apply(applyNative: false);
+
+      await Future.wait(
+        [
+          loadTranslations(),
+          workerManagerPatch.init(dynamicSpawning: true),
+          _ref?.read(authServiceProvider).setOpenApiServiceEndpoint(),
+          // Initialize the file downloader
+          FileDownloader().configure(
+            globalConfig: [
+              // maxConcurrent: 6, maxConcurrentByHost(server):6, maxConcurrentByGroup: 3
+              (Config.holdingQueue, (6, 6, 3)),
+              // On Android, if files are larger than 256MB, run in foreground service
+              (Config.runInForegroundIfFileLargerThan, 256),
+            ],
+          ),
+          FileDownloader().trackTasksInGroup(kDownloadGroupLivePhoto, markDownloadedComplete: false),
+          FileDownloader().trackTasks(),
+          _ref?.read(fileMediaRepositoryProvider).enableBackgroundAccess(),
+        ].nonNulls,
+      );
+
+      configureFileDownloaderNotifications();
+
+      // Notify the host that the background worker service has been initialized and is ready to use
+      unawaited(_backgroundHostApi.onInitialized());
+    } catch (error, stack) {
+      _logger.severe("Failed to initialize background worker", error, stack);
+      unawaited(_backgroundHostApi.close());
+    }
+  }
+
+  @override
+  Future<void> onAndroidUpload() async {
+    _logger.info('Android background processing started');
+    final sw = Stopwatch()..start();
+    try {
+      if (!await _syncAssets(hashTimeout: Duration(minutes: _isBackupEnabled ? 3 : 6))) {
+        _logger.warning("Remote sync did not complete successfully, skipping backup");
+        return;
+      }
+      await _handleBackup();
+    } catch (error, stack) {
+      _logger.severe("Failed to complete Android background processing", error, stack);
+    } finally {
+      sw.stop();
+      _logger.info("Android background processing completed in ${sw.elapsed.inSeconds}s");
+      await _cleanup();
+    }
+  }
+
+  @override
+  Future<void> onIosUpload(bool isRefresh, int? maxSeconds) async {
+    _logger.info('iOS background upload started with maxSeconds: ${maxSeconds}s');
+    final sw = Stopwatch()..start();
+    try {
+      final timeout = isRefresh ? const Duration(seconds: 5) : Duration(minutes: _isBackupEnabled ? 3 : 6);
+      if (!await _syncAssets(hashTimeout: timeout)) {
+        _logger.warning("Remote sync did not complete successfully, skipping backup");
+        return;
+      }
+
+      final backupFuture = _handleBackup();
+      if (maxSeconds != null) {
+        await backupFuture.timeout(Duration(seconds: maxSeconds - 1), onTimeout: () {});
+      } else {
+        await backupFuture;
+      }
+    } catch (error, stack) {
+      _logger.severe("Failed to complete iOS background upload", error, stack);
+    } finally {
+      sw.stop();
+      _logger.info("iOS background upload completed in ${sw.elapsed.inSeconds}s");
+      await _cleanup();
+    }
+  }
+
+  @override
+  Future<void> cancel() async {
+    _logger.warning("Background worker cancelled");
+    try {
+      await _cleanup();
+    } catch (error, stack) {
+      dPrint(() => 'Failed to cleanup background worker: $error with stack: $stack');
+    }
+  }
+
+  Future<void> _cleanup() async {
+    await runZonedGuarded(_handleCleanup, (error, stack) {
+      dPrint(() => "Error during background worker cleanup: $error, $stack");
+    });
+  }
+
+  Future<void> _handleCleanup() async {
+    // If ref is null, it means the service was never initialized properly
+    if (_isCleanedUp || _ref == null) {
+      return;
+    }
+
+    try {
+      _isCleanedUp = true;
+      final backgroundSyncManager = _ref?.read(backgroundSyncProvider);
+      final nativeSyncApi = _ref?.read(nativeSyncApiProvider);
+
+      await _drift.close();
+      await _driftLogger.close();
+
+      _ref?.dispose();
+      _ref = null;
+
+      _cancellationToken.cancel();
+      _logger.info("Cleaning up background worker");
+
+      final cleanupFutures = [
+        nativeSyncApi?.cancelHashing(),
+        workerManagerPatch.dispose().catchError((_) async {
+          // Discard any errors on the dispose call
+          return;
+        }),
+        LogService.I.dispose(),
+        Store.dispose(),
+
+        backgroundSyncManager?.cancel(),
+      ];
+
+      if (_isar.isOpen) {
+        cleanupFutures.add(_isar.close());
+      }
+      await Future.wait(cleanupFutures.nonNulls);
+      _logger.info("Background worker resources cleaned up");
+    } catch (error, stack) {
+      dPrint(() => 'Failed to cleanup background worker: $error with stack: $stack');
+    }
+  }
+
+  Future<void> _handleBackup() async {
+    await runZonedGuarded(
+      () async {
+        if (_isCleanedUp) {
+          return;
+        }
+
+        if (!_isBackupEnabled) {
+          _logger.info("Backup is disabled. Skipping backup routine");
+          return;
+        }
+
+        final currentUser = _ref?.read(currentUserProvider);
+        if (currentUser == null) {
+          _logger.warning("No current user found. Skipping backup from background");
+          return;
+        }
+
+        if (Platform.isIOS) {
+          return _ref?.read(driftBackupProvider.notifier).startBackupWithURLSession(currentUser.id);
+        }
+
+        return _ref
+            ?.read(foregroundUploadServiceProvider)
+            .uploadCandidates(currentUser.id, _cancellationToken, useSequentialUpload: true);
+      },
+      (error, stack) {
+        dPrint(() => "Error in backup zone $error, $stack");
+      },
+    );
+  }
+
+  Future<bool> _syncAssets({Duration? hashTimeout}) async {
+    await _ref?.read(backgroundSyncProvider).syncLocal();
+    if (_isCleanedUp) {
+      return false;
+    }
+
+    final isSuccess = await _ref?.read(backgroundSyncProvider).syncRemote() ?? false;
+    if (_isCleanedUp) {
+      return isSuccess;
+    }
+
+    var hashFuture = _ref?.read(backgroundSyncProvider).hashAssets();
+    if (hashTimeout != null && hashFuture != null) {
+      hashFuture = hashFuture.timeout(
+        hashTimeout,
+        onTimeout: () {
+          // Consume cancellation errors as we want to continue processing
+        },
+      );
+    }
+
+    await hashFuture;
+    return isSuccess;
+  }
+}
+
+class BackgroundWorkerLockService {
+  final BackgroundWorkerLockApi _hostApi;
+  const BackgroundWorkerLockService(this._hostApi);
+
+  Future<void> lock() async {
+    if (CurrentPlatform.isAndroid) {
+      return _hostApi.lock();
+    }
+  }
+
+  Future<void> unlock() async {
+    if (CurrentPlatform.isAndroid) {
+      return _hostApi.unlock();
+    }
+  }
+}
+
+/// Native entry invoked from the background worker. If renaming or moving this to a different
+/// library, make sure to update the entry points and URI in native workers as well
+@pragma('vm:entry-point')
+Future<void> backgroundSyncNativeEntrypoint() async {
+  WidgetsFlutterBinding.ensureInitialized();
+  DartPluginRegistrant.ensureInitialized();
+
+  final (isar, drift, logDB) = await Bootstrap.initDB();
+  await Bootstrap.initDomain(isar, drift, logDB, shouldBufferLogs: false, listenStoreUpdates: false);
+  await BackgroundWorkerBgService(isar: isar, drift: drift, driftLogger: logDB).init();
+}
--- a/mobile/lib/domain/services/hash.service.dart
+++ b/mobile/lib/domain/services/hash.service.dart
@ -0,0 +1,145 @@
+import 'package:flutter/services.dart';
+import 'package:immich_mobile/constants/constants.dart';
+import 'package:immich_mobile/domain/models/album/local_album.model.dart';
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/extensions/platform_extensions.dart';
+import 'package:immich_mobile/infrastructure/repositories/local_album.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/local_asset.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/trashed_local_asset.repository.dart';
+import 'package:immich_mobile/platform/native_sync_api.g.dart';
+import 'package:logging/logging.dart';
+
+const String _kHashCancelledCode = "HASH_CANCELLED";
+
+class HashService {
+  final int _batchSize;
+  final DriftLocalAlbumRepository _localAlbumRepository;
+  final DriftLocalAssetRepository _localAssetRepository;
+  final DriftTrashedLocalAssetRepository _trashedLocalAssetRepository;
+  final NativeSyncApi _nativeSyncApi;
+  final bool Function()? _cancelChecker;
+  final _log = Logger('HashService');
+
+  HashService({
+    required DriftLocalAlbumRepository localAlbumRepository,
+    required DriftLocalAssetRepository localAssetRepository,
+    required DriftTrashedLocalAssetRepository trashedLocalAssetRepository,
+    required NativeSyncApi nativeSyncApi,
+    bool Function()? cancelChecker,
+    int? batchSize,
+  }) : _localAlbumRepository = localAlbumRepository,
+       _localAssetRepository = localAssetRepository,
+       _trashedLocalAssetRepository = trashedLocalAssetRepository,
+       _cancelChecker = cancelChecker,
+       _nativeSyncApi = nativeSyncApi,
+       _batchSize = batchSize ?? kBatchHashFileLimit;
+
+  bool get isCancelled => _cancelChecker?.call() ?? false;
+
+  Future<void> hashAssets() async {
+    _log.info("Starting hashing of assets");
+    final Stopwatch stopwatch = Stopwatch()..start();
+    try {
+      // Migrate hashes from cloud ID to local ID so we don't have to re-hash them
+      await _localAssetRepository.reconcileHashesFromCloudId();
+
+      // Sorted by backupSelection followed by isCloud
+      final localAlbums = await _localAlbumRepository.getBackupAlbums();
+
+      for (final album in localAlbums) {
+        if (isCancelled) {
+          _log.warning("Hashing cancelled. Stopped processing albums.");
+          break;
+        }
+
+        final assetsToHash = await _localAlbumRepository.getAssetsToHash(album.id);
+        if (assetsToHash.isNotEmpty) {
+          await _hashAssets(album, assetsToHash);
+        }
+      }
+      if (CurrentPlatform.isAndroid && localAlbums.isNotEmpty) {
+        final backupAlbumIds = localAlbums.map((e) => e.id);
+        final trashedToHash = await _trashedLocalAssetRepository.getAssetsToHash(backupAlbumIds);
+        if (trashedToHash.isNotEmpty) {
+          final pseudoAlbum = LocalAlbum(id: '-pseudoAlbum', name: 'Trash', updatedAt: DateTime.now());
+          await _hashAssets(pseudoAlbum, trashedToHash, isTrashed: true);
+        }
+      }
+    } on PlatformException catch (e) {
+      if (e.code == _kHashCancelledCode) {
+        _log.warning("Hashing cancelled by platform");
+        return;
+      }
+    } catch (e, s) {
+      _log.severe("Error during hashing", e, s);
+    }
+
+    stopwatch.stop();
+    _log.info("Hashing took - ${stopwatch.elapsedMilliseconds}ms");
+  }
+
+  /// Processes a list of [LocalAsset]s, storing their hash and updating the assets in the DB
+  /// with hash for those that were successfully hashed. Hashes are looked up in a table
+  /// [LocalAssetHashEntity] by local id. Only missing entries are newly hashed and added to the DB.
+  Future<void> _hashAssets(LocalAlbum album, List<LocalAsset> assetsToHash, {bool isTrashed = false}) async {
+    final toHash = <String, LocalAsset>{};
+
+    for (final asset in assetsToHash) {
+      if (isCancelled) {
+        _log.warning("Hashing cancelled. Stopped processing assets.");
+        return;
+      }
+
+      toHash[asset.id] = asset;
+      if (toHash.length == _batchSize) {
+        await _processBatch(album, toHash, isTrashed);
+        toHash.clear();
+      }
+    }
+
+    await _processBatch(album, toHash, isTrashed);
+  }
+
+  /// Processes a batch of assets.
+  Future<void> _processBatch(LocalAlbum album, Map<String, LocalAsset> toHash, bool isTrashed) async {
+    if (toHash.isEmpty) {
+      return;
+    }
+
+    _log.fine("Hashing ${toHash.length} files");
+
+    final hashed = <String, String>{};
+    final hashResults = await _nativeSyncApi.hashAssets(
+      toHash.keys.toList(),
+      allowNetworkAccess: album.backupSelection == BackupSelection.selected,
+    );
+    assert(
+      hashResults.length == toHash.length,
+      "Hashes length does not match toHash length: ${hashResults.length} != ${toHash.length}",
+    );
+
+    for (int i = 0; i < hashResults.length; i++) {
+      if (isCancelled) {
+        _log.warning("Hashing cancelled. Stopped processing batch.");
+        return;
+      }
+
+      final hashResult = hashResults[i];
+      if (hashResult.hash != null) {
+        hashed[hashResult.assetId] = hashResult.hash!;
+      } else {
+        final asset = toHash[hashResult.assetId];
+        _log.warning(
+          "Failed to hash asset with id: ${hashResult.assetId}, name: ${asset?.name}, createdAt: ${asset?.createdAt}, from album: ${album.name}. Error: ${hashResult.error ?? "unknown"}",
+        );
+      }
+    }
+
+    _log.fine("Hashed ${hashed.length}/${toHash.length} assets");
+    if (isTrashed) {
+      await _trashedLocalAssetRepository.updateHashes(hashed);
+    } else {
+      await _localAssetRepository.updateHashes(hashed);
+    }
+  }
+}
--- a/mobile/lib/domain/services/local_album.service.dart
+++ b/mobile/lib/domain/services/local_album.service.dart
@ -0,0 +1,37 @@
+import 'package:immich_mobile/domain/models/album/local_album.model.dart';
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/infrastructure/repositories/local_album.repository.dart';
+
+class LocalAlbumService {
+  final DriftLocalAlbumRepository _repository;
+
+  const LocalAlbumService(this._repository);
+
+  Future<List<LocalAlbum>> getAll({Set<SortLocalAlbumsBy> sortBy = const {}}) {
+    return _repository.getAll(sortBy: sortBy);
+  }
+
+  Future<LocalAsset?> getThumbnail(String albumId) {
+    return _repository.getThumbnail(albumId);
+  }
+
+  Future<void> update(LocalAlbum album) {
+    return _repository.upsert(album);
+  }
+
+  Future<int> getCount() {
+    return _repository.getCount();
+  }
+
+  Future<void> unlinkRemoteAlbum(String id) async {
+    return _repository.unlinkRemoteAlbum(id);
+  }
+
+  Future<void> linkRemoteAlbum(String localAlbumId, String remoteAlbumId) async {
+    return _repository.linkRemoteAlbum(localAlbumId, remoteAlbumId);
+  }
+
+  Future<List<LocalAlbum>> getBackupAlbums() {
+    return _repository.getBackupAlbums();
+  }
+}
--- a/mobile/lib/domain/services/local_sync.service.dart
+++ b/mobile/lib/domain/services/local_sync.service.dart
@ -0,0 +1,441 @@
+import 'dart:async';
+
+import 'package:collection/collection.dart';
+import 'package:flutter/foundation.dart';
+import 'package:immich_mobile/domain/models/album/local_album.model.dart';
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/domain/models/store.model.dart';
+import 'package:immich_mobile/entities/store.entity.dart';
+import 'package:immich_mobile/extensions/platform_extensions.dart';
+import 'package:immich_mobile/infrastructure/repositories/local_album.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/local_asset.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/storage.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/trashed_local_asset.repository.dart';
+import 'package:immich_mobile/platform/native_sync_api.g.dart';
+import 'package:immich_mobile/repositories/local_files_manager.repository.dart';
+import 'package:immich_mobile/utils/datetime_helpers.dart';
+import 'package:immich_mobile/utils/diff.dart';
+import 'package:logging/logging.dart';
+
+class LocalSyncService {
+  final DriftLocalAlbumRepository _localAlbumRepository;
+  final DriftLocalAssetRepository _localAssetRepository;
+  final NativeSyncApi _nativeSyncApi;
+  final DriftTrashedLocalAssetRepository _trashedLocalAssetRepository;
+  final LocalFilesManagerRepository _localFilesManager;
+  final StorageRepository _storageRepository;
+  final Logger _log = Logger("DeviceSyncService");
+
+  LocalSyncService({
+    required DriftLocalAlbumRepository localAlbumRepository,
+    required DriftLocalAssetRepository localAssetRepository,
+    required DriftTrashedLocalAssetRepository trashedLocalAssetRepository,
+    required LocalFilesManagerRepository localFilesManager,
+    required StorageRepository storageRepository,
+    required NativeSyncApi nativeSyncApi,
+  }) : _localAlbumRepository = localAlbumRepository,
+       _localAssetRepository = localAssetRepository,
+       _trashedLocalAssetRepository = trashedLocalAssetRepository,
+       _localFilesManager = localFilesManager,
+       _storageRepository = storageRepository,
+       _nativeSyncApi = nativeSyncApi;
+
+  Future<void> sync({bool full = false}) async {
+    final Stopwatch stopwatch = Stopwatch()..start();
+    try {
+      if (CurrentPlatform.isAndroid && Store.get(StoreKey.manageLocalMediaAndroid, false)) {
+        final hasPermission = await _localFilesManager.hasManageMediaPermission();
+        if (hasPermission) {
+          await _syncTrashedAssets();
+        } else {
+          _log.warning("syncTrashedAssets cannot proceed because MANAGE_MEDIA permission is missing");
+        }
+      }
+
+      if (CurrentPlatform.isIOS) {
+        final assets = await _localAssetRepository.getEmptyCloudIdAssets();
+        await _mapIosCloudIds(assets);
+      }
+
+      if (full || await _nativeSyncApi.shouldFullSync()) {
+        _log.fine("Full sync request from ${full ? "user" : "native"}");
+        return await fullSync();
+      }
+
+      final delta = await _nativeSyncApi.getMediaChanges();
+      if (!delta.hasChanges) {
+        _log.fine("No media changes detected. Skipping sync");
+        return;
+      }
+
+      _log.fine("Delta updated: ${delta.updates.length}");
+      _log.fine("Delta deleted: ${delta.deletes.length}");
+
+      final deviceAlbums = await _nativeSyncApi.getAlbums();
+      await _localAlbumRepository.updateAll(deviceAlbums.toLocalAlbums());
+      final newAssets = delta.updates.toLocalAssets();
+      await _localAlbumRepository.processDelta(
+        updates: newAssets,
+        deletes: delta.deletes,
+        assetAlbums: delta.assetAlbums,
+      );
+
+      final dbAlbums = await _localAlbumRepository.getAll();
+      // On Android, we need to sync all albums since it is not possible to
+      // detect album deletions from the native side
+      if (CurrentPlatform.isAndroid) {
+        for (final album in dbAlbums) {
+          final deviceIds = await _nativeSyncApi.getAssetIdsForAlbum(album.id);
+          await _localAlbumRepository.syncDeletes(album.id, deviceIds);
+        }
+      }
+
+      if (CurrentPlatform.isIOS) {
+        // On iOS, we need to full sync albums that are marked as cloud as the delta sync
+        // does not include changes for cloud albums. If ignoreIcloudAssets is enabled,
+        // remove the albums from the local database from the previous sync
+        final cloudAlbums = deviceAlbums.where((a) => a.isCloud).toLocalAlbums();
+        for (final album in cloudAlbums) {
+          final dbAlbum = dbAlbums.firstWhereOrNull((a) => a.id == album.id);
+          if (dbAlbum == null) {
+            _log.warning("Cloud album ${album.name} not found in local database. Skipping sync.");
+            continue;
+          }
+          await updateAlbum(dbAlbum, album);
+        }
+
+        await _mapIosCloudIds(newAssets);
+      }
+      await _nativeSyncApi.checkpointSync();
+    } catch (e, s) {
+      _log.severe("Error performing device sync", e, s);
+    } finally {
+      stopwatch.stop();
+      _log.info("Device sync took - ${stopwatch.elapsedMilliseconds}ms");
+    }
+  }
+
+  Future<void> fullSync() async {
+    try {
+      final Stopwatch stopwatch = Stopwatch()..start();
+
+      final deviceAlbums = await _nativeSyncApi.getAlbums();
+      final dbAlbums = await _localAlbumRepository.getAll(sortBy: {SortLocalAlbumsBy.id});
+
+      await diffSortedLists(
+        dbAlbums,
+        deviceAlbums.toLocalAlbums(),
+        compare: (a, b) => a.id.compareTo(b.id),
+        both: updateAlbum,
+        onlyFirst: removeAlbum,
+        onlySecond: addAlbum,
+      );
+
+      await _nativeSyncApi.checkpointSync();
+      stopwatch.stop();
+      _log.info("Full device sync took - ${stopwatch.elapsedMilliseconds}ms");
+    } catch (e, s) {
+      _log.severe("Error performing full device sync", e, s);
+    }
+  }
+
+  Future<void> addAlbum(LocalAlbum album) async {
+    try {
+      _log.fine("Adding device album ${album.name}");
+
+      final assets = album.assetCount > 0
+          ? await _nativeSyncApi.getAssetsForAlbum(album.id).then((a) => a.toLocalAssets())
+          : <LocalAsset>[];
+
+      await _localAlbumRepository.upsert(album, toUpsert: assets);
+      await _mapIosCloudIds(assets);
+      _log.fine("Successfully added device album ${album.name}");
+    } catch (e, s) {
+      _log.warning("Error while adding device album", e, s);
+    }
+  }
+
+  Future<void> removeAlbum(LocalAlbum a) async {
+    _log.fine("Removing device album ${a.name}");
+    try {
+      // Asset deletion is handled in the repository
+      await _localAlbumRepository.delete(a.id);
+    } catch (e, s) {
+      _log.warning("Error while removing device album", e, s);
+    }
+  }
+
+  // The deviceAlbum is ignored since we are going to refresh it anyways
+  FutureOr<bool> updateAlbum(LocalAlbum dbAlbum, LocalAlbum deviceAlbum) async {
+    try {
+      _log.fine("Syncing device album ${dbAlbum.name}");
+
+      if (_albumsEqual(deviceAlbum, dbAlbum)) {
+        _log.fine("Device album ${dbAlbum.name} has not changed. Skipping sync.");
+        return false;
+      }
+
+      _log.fine("Device album ${dbAlbum.name} has changed. Syncing...");
+
+      // Faster path - only new assets added
+      if (await checkAddition(dbAlbum, deviceAlbum)) {
+        _log.fine("Fast synced device album ${dbAlbum.name}");
+        return true;
+      }
+
+      // Slower path - full sync
+      return await fullDiff(dbAlbum, deviceAlbum);
+    } catch (e, s) {
+      _log.warning("Error while diff device album", e, s);
+    }
+    return true;
+  }
+
+  @visibleForTesting
+  // The [deviceAlbum] is expected to be refreshed before calling this method
+  // with modified time and asset count
+  Future<bool> checkAddition(LocalAlbum dbAlbum, LocalAlbum deviceAlbum) async {
+    try {
+      _log.fine("Fast syncing device album ${dbAlbum.name}");
+      // Assets has been modified
+      if (deviceAlbum.assetCount <= dbAlbum.assetCount) {
+        _log.fine("Local album has modifications. Proceeding to full sync");
+        return false;
+      }
+
+      final updatedTime = (dbAlbum.updatedAt.millisecondsSinceEpoch ~/ 1000) + 1;
+      final newAssetsCount = await _nativeSyncApi.getAssetsCountSince(deviceAlbum.id, updatedTime);
+
+      // Early return if no new assets were found
+      if (newAssetsCount == 0) {
+        _log.fine("No new assets found despite album having changes. Proceeding to full sync for ${dbAlbum.name}");
+        return false;
+      }
+
+      // Check whether there is only addition or if there has been deletions
+      if (deviceAlbum.assetCount != dbAlbum.assetCount + newAssetsCount) {
+        _log.fine("Local album has modifications. Proceeding to full sync");
+        return false;
+      }
+
+      final newAssets = await _nativeSyncApi
+          .getAssetsForAlbum(deviceAlbum.id, updatedTimeCond: updatedTime)
+          .then((a) => a.toLocalAssets());
+
+      await _localAlbumRepository.upsert(
+        deviceAlbum.copyWith(backupSelection: dbAlbum.backupSelection),
+        toUpsert: newAssets,
+      );
+
+      await _mapIosCloudIds(newAssets);
+      return true;
+    } catch (e, s) {
+      _log.warning("Error on fast syncing local album: ${dbAlbum.name}", e, s);
+    }
+    return false;
+  }
+
+  @visibleForTesting
+  // The [deviceAlbum] is expected to be refreshed before calling this method
+  // with modified time and asset count
+  Future<bool> fullDiff(LocalAlbum dbAlbum, LocalAlbum deviceAlbum) async {
+    try {
+      final assetsInDevice = deviceAlbum.assetCount > 0
+          ? await _nativeSyncApi.getAssetsForAlbum(deviceAlbum.id).then((a) => a.toLocalAssets())
+          : <LocalAsset>[];
+      final assetsInDb = dbAlbum.assetCount > 0 ? await _localAlbumRepository.getAssets(dbAlbum.id) : <LocalAsset>[];
+
+      if (deviceAlbum.assetCount == 0) {
+        _log.fine("Device album ${deviceAlbum.name} is empty. Removing assets from DB.");
+        await _localAlbumRepository.upsert(
+          deviceAlbum.copyWith(backupSelection: dbAlbum.backupSelection),
+          toDelete: assetsInDb.map((a) => a.id),
+        );
+        return true;
+      }
+
+      final updatedDeviceAlbum = deviceAlbum.copyWith(backupSelection: dbAlbum.backupSelection);
+
+      if (dbAlbum.assetCount == 0) {
+        _log.fine("Device album ${deviceAlbum.name} is empty. Adding assets to DB.");
+        await _localAlbumRepository.upsert(updatedDeviceAlbum, toUpsert: assetsInDevice);
+        await _mapIosCloudIds(assetsInDevice);
+        return true;
+      }
+
+      assert(assetsInDb.isSortedBy((a) => a.id));
+      assetsInDevice.sort((a, b) => a.id.compareTo(b.id));
+
+      final assetsToUpsert = <LocalAsset>[];
+      final assetsToDelete = <String>[];
+
+      diffSortedListsSync(
+        assetsInDb,
+        assetsInDevice,
+        compare: (a, b) => a.id.compareTo(b.id),
+        both: (dbAsset, deviceAsset) {
+          // Custom comparison to check if the asset has been modified without
+          // comparing the checksum
+          if (!_assetsEqual(dbAsset, deviceAsset)) {
+            assetsToUpsert.add(deviceAsset);
+            return true;
+          }
+          return false;
+        },
+        onlyFirst: (dbAsset) => assetsToDelete.add(dbAsset.id),
+        onlySecond: (deviceAsset) => assetsToUpsert.add(deviceAsset),
+      );
+
+      _log.fine(
+        "Syncing ${deviceAlbum.name}. ${assetsToUpsert.length} assets to add/update and ${assetsToDelete.length} assets to delete",
+      );
+
+      if (assetsToUpsert.isEmpty && assetsToDelete.isEmpty) {
+        _log.fine("No asset changes detected in album ${deviceAlbum.name}. Updating metadata.");
+        await _localAlbumRepository.upsert(updatedDeviceAlbum);
+        return true;
+      }
+
+      await _localAlbumRepository.upsert(updatedDeviceAlbum, toUpsert: assetsToUpsert, toDelete: assetsToDelete);
+      await _mapIosCloudIds(assetsToUpsert);
+
+      return true;
+    } catch (e, s) {
+      _log.warning("Error on full syncing local album: ${dbAlbum.name}", e, s);
+    }
+    return true;
+  }
+
+  Future<void> _mapIosCloudIds(List<LocalAsset> assets) async {
+    if (!CurrentPlatform.isIOS || assets.isEmpty) {
+      return;
+    }
+
+    final assetIds = assets.map((a) => a.id).toList();
+    final cloudMapping = <String, String>{};
+    final cloudIds = await _nativeSyncApi.getCloudIdForAssetIds(assetIds);
+    for (int i = 0; i < cloudIds.length; i++) {
+      final cloudIdResult = cloudIds[i];
+      if (cloudIdResult.cloudId != null) {
+        cloudMapping[cloudIdResult.assetId] = cloudIdResult.cloudId!;
+      } else {
+        final asset = assets.firstWhereOrNull((a) => a.id == cloudIdResult.assetId);
+        _log.fine(
+          "Cannot fetch cloudId for asset with id: ${cloudIdResult.assetId}, name: ${asset?.name}, createdAt: ${asset?.createdAt}. Error: ${cloudIdResult.error ?? "unknown"}",
+        );
+      }
+    }
+
+    await _localAlbumRepository.updateCloudMapping(cloudMapping);
+  }
+
+  bool _assetsEqual(LocalAsset a, LocalAsset b) {
+    if (CurrentPlatform.isAndroid) {
+      return a.updatedAt.isAtSameMomentAs(b.updatedAt) &&
+          a.createdAt.isAtSameMomentAs(b.createdAt) &&
+          a.width == b.width &&
+          a.height == b.height &&
+          a.durationInSeconds == b.durationInSeconds;
+    }
+
+    final firstAdjustment = a.adjustmentTime?.millisecondsSinceEpoch ?? 0;
+    final secondAdjustment = b.adjustmentTime?.millisecondsSinceEpoch ?? 0;
+    return firstAdjustment == secondAdjustment &&
+        a.createdAt.isAtSameMomentAs(b.createdAt) &&
+        a.width == b.width &&
+        a.height == b.height &&
+        a.durationInSeconds == b.durationInSeconds &&
+        a.latitude == b.latitude &&
+        a.longitude == b.longitude;
+  }
+
+  bool _albumsEqual(LocalAlbum a, LocalAlbum b) {
+    return a.name == b.name && a.assetCount == b.assetCount && a.updatedAt.isAtSameMomentAs(b.updatedAt);
+  }
+
+  Future<void> _syncTrashedAssets() async {
+    final trashedAssetMap = await _nativeSyncApi.getTrashedAssets();
+    await processTrashedAssets(trashedAssetMap);
+  }
+
+  @visibleForTesting
+  Future<void> processTrashedAssets(Map<String, List<PlatformAsset>> trashedAssetMap) async {
+    if (trashedAssetMap.isEmpty) {
+      _log.info("syncTrashedAssets, No trashed assets found");
+    }
+    final trashedAssets = trashedAssetMap.cast<String, List<Object?>>().entries.expand(
+      (entry) => entry.value.cast<PlatformAsset>().toTrashedAssets(entry.key),
+    );
+
+    _log.fine("syncTrashedAssets, trashedAssets: ${trashedAssets.map((e) => e.asset.id)}");
+    await _trashedLocalAssetRepository.processTrashSnapshot(trashedAssets);
+
+    final assetsToRestore = await _trashedLocalAssetRepository.getToRestore();
+    if (assetsToRestore.isNotEmpty) {
+      final restoredIds = await _localFilesManager.restoreAssetsFromTrash(assetsToRestore);
+      await _trashedLocalAssetRepository.applyRestoredAssets(restoredIds);
+    } else {
+      _log.info("syncTrashedAssets, No remote assets found for restoration");
+    }
+
+    final localAssetsToTrash = await _trashedLocalAssetRepository.getToTrash();
+    if (localAssetsToTrash.isNotEmpty) {
+      final mediaUrls = await Future.wait(
+        localAssetsToTrash.values
+            .expand((e) => e)
+            .map((localAsset) => _storageRepository.getAssetEntityForAsset(localAsset).then((e) => e?.getMediaUrl())),
+      );
+      _log.info("Moving to trash ${mediaUrls.join(", ")} assets");
+      final result = await _localFilesManager.moveToTrash(mediaUrls.nonNulls.toList());
+      if (result) {
+        await _trashedLocalAssetRepository.trashLocalAsset(localAssetsToTrash);
+      }
+    } else {
+      _log.info("syncTrashedAssets, No assets found in backup-enabled albums for move to trash");
+    }
+  }
+}
+
+extension on Iterable<PlatformAlbum> {
+  List<LocalAlbum> toLocalAlbums() {
+    return map(
+      (e) => LocalAlbum(
+        id: e.id,
+        name: e.name,
+        updatedAt: tryFromSecondsSinceEpoch(e.updatedAt, isUtc: true) ?? DateTime.timestamp(),
+        assetCount: e.assetCount,
+        isIosSharedAlbum: e.isCloud,
+      ),
+    ).toList();
+  }
+}
+
+extension on Iterable<PlatformAsset> {
+  List<LocalAsset> toLocalAssets() {
+    return map((e) => e.toLocalAsset()).toList();
+  }
+
+  Iterable<TrashedAsset> toTrashedAssets(String albumId) {
+    return map((e) => (albumId: albumId, asset: e.toLocalAsset()));
+  }
+}
+
+extension PlatformToLocalAsset on PlatformAsset {
+  LocalAsset toLocalAsset() => LocalAsset(
+    id: id,
+    name: name,
+    checksum: null,
+    type: AssetType.values.elementAtOrNull(type) ?? AssetType.other,
+    createdAt: tryFromSecondsSinceEpoch(createdAt, isUtc: true) ?? DateTime.timestamp(),
+    updatedAt: tryFromSecondsSinceEpoch(updatedAt, isUtc: true) ?? DateTime.timestamp(),
+    width: width,
+    height: height,
+    durationInSeconds: durationInSeconds,
+    isFavorite: isFavorite,
+    orientation: orientation,
+    adjustmentTime: tryFromSecondsSinceEpoch(adjustmentTime, isUtc: true),
+    latitude: latitude,
+    longitude: longitude,
+    isEdited: false,
+  );
+}
--- a/mobile/lib/domain/services/log.service.dart
+++ b/mobile/lib/domain/services/log.service.dart
@ -0,0 +1,148 @@
+import 'dart:async';
+
+import 'package:immich_mobile/constants/constants.dart';
+import 'package:immich_mobile/domain/models/log.model.dart';
+import 'package:immich_mobile/domain/models/store.model.dart';
+import 'package:immich_mobile/infrastructure/repositories/log.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/store.repository.dart';
+import 'package:immich_mobile/utils/debug_print.dart';
+import 'package:logging/logging.dart';
+
+/// Service responsible for handling application logging.
+///
+/// It listens to Dart's [Logger.root], buffers logs in memory (optionally),
+/// writes them to a persistent [ILogRepository], and manages log levels
+/// via [IStoreRepository]
+class LogService {
+  final LogRepository _logRepository;
+  final IStoreRepository _storeRepository;
+
+  final List<LogMessage> _msgBuffer = [];
+
+  /// Whether to buffer logs in memory before writing to the database.
+  /// This is useful when logging in quick succession, as it increases performance
+  /// and reduces NAND wear. However, it may cause the logs to be lost in case of a crash / in isolates.
+  final bool _shouldBuffer;
+
+  Timer? _flushTimer;
+
+  late final StreamSubscription<LogRecord> _logSubscription;
+
+  static LogService? _instance;
+  static LogService get I {
+    if (_instance == null) {
+      throw const LoggerUnInitializedException();
+    }
+    return _instance!;
+  }
+
+  static Future<LogService> init({
+    required LogRepository logRepository,
+    required IStoreRepository storeRepository,
+    bool shouldBuffer = true,
+  }) async {
+    _instance ??= await create(
+      logRepository: logRepository,
+      storeRepository: storeRepository,
+      shouldBuffer: shouldBuffer,
+    );
+    return _instance!;
+  }
+
+  static Future<LogService> create({
+    required LogRepository logRepository,
+    required IStoreRepository storeRepository,
+    bool shouldBuffer = true,
+  }) async {
+    final instance = LogService._(logRepository, storeRepository, shouldBuffer);
+    await logRepository.truncate(limit: kLogTruncateLimit);
+    final level = await instance._storeRepository.tryGet(StoreKey.logLevel) ?? LogLevel.info.index;
+    Logger.root.level = Level.LEVELS.elementAtOrNull(level) ?? Level.INFO;
+    return instance;
+  }
+
+  LogService._(this._logRepository, this._storeRepository, this._shouldBuffer) {
+    _logSubscription = Logger.root.onRecord.listen(_handleLogRecord);
+  }
+
+  void _handleLogRecord(LogRecord r) {
+    dPrint(
+      () =>
+          '[${r.level.name}] [${r.time}] [${r.loggerName}] ${r.message}'
+          '${r.error == null ? '' : '\nError: ${r.error}'}'
+          '${r.stackTrace == null ? '' : '\nStack: ${r.stackTrace}'}',
+    );
+
+    final record = LogMessage(
+      message: r.message,
+      level: r.level.toLogLevel(),
+      createdAt: r.time,
+      logger: r.loggerName,
+      error: r.error?.toString(),
+      stack: r.stackTrace?.toString(),
+    );
+
+    if (_shouldBuffer) {
+      _msgBuffer.add(record);
+      _flushTimer ??= Timer(const Duration(seconds: 5), () => unawaited(_flushBuffer()));
+    } else {
+      unawaited(_logRepository.insert(record));
+    }
+  }
+
+  Future<void> setLogLevel(LogLevel level) async {
+    await _storeRepository.upsert(StoreKey.logLevel, level.index);
+    Logger.root.level = level.toLevel();
+  }
+
+  Future<List<LogMessage>> getMessages() async {
+    final logsFromDb = await _logRepository.getAll();
+    return [..._msgBuffer.reversed, ...logsFromDb];
+  }
+
+  Future<void> clearLogs() async {
+    _flushTimer?.cancel();
+    _flushTimer = null;
+    _msgBuffer.clear();
+    await _logRepository.deleteAll();
+  }
+
+  Future<void> flush() {
+    _flushTimer?.cancel();
+    return _flushBuffer();
+  }
+
+  Future<void> dispose() {
+    _flushTimer?.cancel();
+    _logSubscription.cancel();
+    return _flushBuffer();
+  }
+
+  Future<void> _flushBuffer() async {
+    _flushTimer = null;
+    final buffer = [..._msgBuffer];
+    _msgBuffer.clear();
+
+    if (buffer.isEmpty) {
+      return;
+    }
+
+    await _logRepository.insertAll(buffer);
+  }
+}
+
+class LoggerUnInitializedException implements Exception {
+  const LoggerUnInitializedException();
+
+  @override
+  String toString() => 'Logger is not initialized. Call init()';
+}
+
+/// Log levels according to dart logging [Level]
+extension LevelDomainToInfraExtension on Level {
+  LogLevel toLogLevel() => LogLevel.values.elementAtOrNull(Level.LEVELS.indexOf(this)) ?? LogLevel.info;
+}
+
+extension on LogLevel {
+  Level toLevel() => Level.LEVELS.elementAtOrNull(index) ?? Level.INFO;
+}
--- a/mobile/lib/domain/services/map.service.dart
+++ b/mobile/lib/domain/services/map.service.dart
@ -0,0 +1,25 @@
+import 'package:immich_mobile/domain/models/map.model.dart';
+import 'package:immich_mobile/infrastructure/repositories/map.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/timeline.repository.dart';
+import 'package:maplibre_gl/maplibre_gl.dart';
+
+typedef MapMarkerSource = Future<List<Marker>> Function(LatLngBounds? bounds);
+
+typedef MapQuery = ({MapMarkerSource markerSource});
+
+class MapFactory {
+  final DriftMapRepository _mapRepository;
+
+  const MapFactory({required DriftMapRepository mapRepository}) : _mapRepository = mapRepository;
+
+  MapService remote(List<String> ownerIds, TimelineMapOptions options) =>
+      MapService(_mapRepository.remote(ownerIds, options));
+}
+
+class MapService {
+  final MapMarkerSource _markerSource;
+
+  MapService(MapQuery query) : _markerSource = query.markerSource;
+
+  Future<List<Marker>> Function(LatLngBounds? bounds) get getMarkers => _markerSource;
+}
--- a/mobile/lib/domain/services/memory.service.dart
+++ b/mobile/lib/domain/services/memory.service.dart
@ -0,0 +1,23 @@
+import 'package:immich_mobile/domain/models/memory.model.dart';
+import 'package:immich_mobile/infrastructure/repositories/memory.repository.dart';
+import 'package:logging/logging.dart';
+
+class DriftMemoryService {
+  final log = Logger("DriftMemoryService");
+
+  final DriftMemoryRepository _repository;
+
+  DriftMemoryService(this._repository);
+
+  Future<List<DriftMemory>> getMemoryLane(String ownerId) {
+    return _repository.getAll(ownerId);
+  }
+
+  Future<DriftMemory?> get(String memoryId) {
+    return _repository.get(memoryId);
+  }
+
+  Future<int> getCount() {
+    return _repository.getCount();
+  }
+}
--- a/mobile/lib/domain/services/partner.service.dart
+++ b/mobile/lib/domain/services/partner.service.dart
@ -0,0 +1,51 @@
+import 'package:immich_mobile/domain/models/user.model.dart';
+import 'package:immich_mobile/infrastructure/repositories/partner.repository.dart';
+import 'package:immich_mobile/repositories/partner_api.repository.dart';
+import 'package:immich_mobile/utils/debug_print.dart';
+
+class DriftPartnerService {
+  final DriftPartnerRepository _driftPartnerRepository;
+  final PartnerApiRepository _partnerApiRepository;
+
+  const DriftPartnerService(this._driftPartnerRepository, this._partnerApiRepository);
+
+  Future<List<PartnerUserDto>> getSharedWith(String userId) {
+    return _driftPartnerRepository.getSharedWith(userId);
+  }
+
+  Future<List<PartnerUserDto>> getSharedBy(String userId) {
+    return _driftPartnerRepository.getSharedBy(userId);
+  }
+
+  Future<List<PartnerUserDto>> getAvailablePartners(String currentUserId) async {
+    final otherUsers = await _driftPartnerRepository.getAvailablePartners(currentUserId);
+    final currentPartners = await _driftPartnerRepository.getSharedBy(currentUserId);
+    final available = otherUsers.where((user) {
+      return !currentPartners.any((partner) => partner.id == user.id);
+    }).toList();
+
+    return available;
+  }
+
+  Future<void> toggleShowInTimeline(String partnerId, String userId) async {
+    final partner = await _driftPartnerRepository.getPartner(partnerId, userId);
+    if (partner == null) {
+      dPrint(() => "Partner not found: $partnerId for user: $userId");
+      return;
+    }
+
+    await _partnerApiRepository.update(partnerId, inTimeline: !partner.inTimeline);
+
+    await _driftPartnerRepository.toggleShowInTimeline(partner, userId);
+  }
+
+  Future<void> addPartner(String partnerId, String userId) async {
+    await _partnerApiRepository.create(partnerId);
+    await _driftPartnerRepository.create(partnerId, userId);
+  }
+
+  Future<void> removePartner(String partnerId, String userId) async {
+    await _partnerApiRepository.delete(partnerId);
+    await _driftPartnerRepository.delete(partnerId, userId);
+  }
+}
--- a/mobile/lib/domain/services/people.service.dart
+++ b/mobile/lib/domain/services/people.service.dart
@ -0,0 +1,30 @@
+import 'dart:async';
+
+import 'package:immich_mobile/domain/models/person.model.dart';
+import 'package:immich_mobile/infrastructure/repositories/people.repository.dart';
+import 'package:immich_mobile/repositories/person_api.repository.dart';
+
+class DriftPeopleService {
+  final DriftPeopleRepository _repository;
+  final PersonApiRepository _personApiRepository;
+
+  const DriftPeopleService(this._repository, this._personApiRepository);
+
+  Future<List<DriftPerson>> getAssetPeople(String assetId) {
+    return _repository.getAssetPeople(assetId);
+  }
+
+  Future<List<DriftPerson>> getAllPeople() {
+    return _repository.getAllPeople();
+  }
+
+  Future<int> updateName(String personId, String name) async {
+    await _personApiRepository.update(personId, name: name);
+    return _repository.updateName(personId, name);
+  }
+
+  Future<int> updateBrithday(String personId, DateTime birthday) async {
+    await _personApiRepository.update(personId, birthday: birthday);
+    return _repository.updateBirthday(personId, birthday);
+  }
+}
--- a/mobile/lib/domain/services/remote_album.service.dart
+++ b/mobile/lib/domain/services/remote_album.service.dart
@ -0,0 +1,214 @@
+import 'dart:async';
+
+import 'package:collection/collection.dart';
+import 'package:immich_mobile/domain/models/album/album.model.dart';
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/domain/models/user.model.dart';
+import 'package:immich_mobile/infrastructure/repositories/remote_album.repository.dart';
+import 'package:immich_mobile/models/albums/album_search.model.dart';
+import 'package:immich_mobile/repositories/drift_album_api_repository.dart';
+import 'package:immich_mobile/providers/album/album_sort_by_options.provider.dart';
+
+class RemoteAlbumService {
+  final DriftRemoteAlbumRepository _repository;
+  final DriftAlbumApiRepository _albumApiRepository;
+
+  const RemoteAlbumService(this._repository, this._albumApiRepository);
+
+  Stream<RemoteAlbum?> watchAlbum(String albumId) {
+    return _repository.watchAlbum(albumId);
+  }
+
+  Future<List<RemoteAlbum>> getAll() {
+    return _repository.getAll();
+  }
+
+  Future<RemoteAlbum?> get(String albumId) {
+    return _repository.get(albumId);
+  }
+
+  Future<RemoteAlbum?> getByName(String albumName, String ownerId) {
+    return _repository.getByName(albumName, ownerId);
+  }
+
+  Future<List<RemoteAlbum>> sortAlbums(
+    List<RemoteAlbum> albums,
+    AlbumSortMode sortMode, {
+    bool isReverse = false,
+  }) async {
+    final List<RemoteAlbum> sorted = switch (sortMode) {
+      AlbumSortMode.created => albums.sortedBy((album) => album.createdAt),
+      AlbumSortMode.title => albums.sortedBy((album) => album.name),
+      AlbumSortMode.lastModified => albums.sortedBy((album) => album.updatedAt),
+      AlbumSortMode.assetCount => albums.sortedBy((album) => album.assetCount),
+      AlbumSortMode.mostRecent => await _sortByNewestAsset(albums),
+      AlbumSortMode.mostOldest => await _sortByOldestAsset(albums),
+    };
+
+    return (isReverse ? sorted.reversed : sorted).toList();
+  }
+
+  List<RemoteAlbum> searchAlbums(
+    List<RemoteAlbum> albums,
+    String query,
+    String? userId, [
+    QuickFilterMode filterMode = QuickFilterMode.all,
+  ]) {
+    final lowerQuery = query.toLowerCase();
+    List<RemoteAlbum> filtered = albums;
+
+    // Apply text search filter
+    if (query.isNotEmpty) {
+      filtered = filtered
+          .where(
+            (album) =>
+                album.name.toLowerCase().contains(lowerQuery) || album.description.toLowerCase().contains(lowerQuery),
+          )
+          .toList();
+    }
+
+    if (userId != null) {
+      switch (filterMode) {
+        case QuickFilterMode.myAlbums:
+          filtered = filtered.where((album) => album.ownerId == userId).toList();
+          break;
+        case QuickFilterMode.sharedWithMe:
+          filtered = filtered.where((album) => album.ownerId != userId).toList();
+          break;
+        case QuickFilterMode.all:
+          break;
+      }
+    }
+
+    return filtered;
+  }
+
+  Future<RemoteAlbum> createAlbum({required String title, required List<String> assetIds, String? description}) async {
+    final album = await _albumApiRepository.createDriftAlbum(title, description: description, assetIds: assetIds);
+    await _repository.create(album, assetIds);
+
+    return album;
+  }
+
+  Future<RemoteAlbum> updateAlbum(
+    String albumId, {
+    String? name,
+    String? description,
+    String? thumbnailAssetId,
+    bool? isActivityEnabled,
+    AlbumAssetOrder? order,
+  }) async {
+    final updatedAlbum = await _albumApiRepository.updateAlbum(
+      albumId,
+      name: name,
+      description: description,
+      thumbnailAssetId: thumbnailAssetId,
+      isActivityEnabled: isActivityEnabled,
+      order: order,
+    );
+
+    // Update the local database
+    await _repository.update(updatedAlbum);
+
+    return updatedAlbum;
+  }
+
+  FutureOr<(DateTime, DateTime)> getDateRange(String albumId) {
+    return _repository.getDateRange(albumId);
+  }
+
+  Future<List<UserDto>> getSharedUsers(String albumId) {
+    return _repository.getSharedUsers(albumId);
+  }
+
+  Future<AlbumUserRole?> getUserRole(String albumId, String userId) {
+    return _repository.getUserRole(albumId, userId);
+  }
+
+  Future<List<RemoteAsset>> getAssets(String albumId) {
+    return _repository.getAssets(albumId);
+  }
+
+  Future<int> addAssets({required String albumId, required List<String> assetIds}) async {
+    final album = await _albumApiRepository.addAssets(albumId, assetIds);
+
+    await _repository.addAssets(albumId, album.added);
+
+    return album.added.length;
+  }
+
+  Future<void> deleteAlbum(String albumId) async {
+    await _albumApiRepository.deleteAlbum(albumId);
+
+    await _repository.deleteAlbum(albumId);
+  }
+
+  Future<void> addUsers({required String albumId, required List<String> userIds}) async {
+    await _albumApiRepository.addUsers(albumId, userIds);
+
+    return _repository.addUsers(albumId, userIds);
+  }
+
+  Future<void> removeUser(String albumId, {required String userId}) async {
+    await _albumApiRepository.removeUser(albumId, userId: userId);
+
+    return _repository.removeUser(albumId, userId: userId);
+  }
+
+  Future<void> setActivityStatus(String albumId, bool enabled) async {
+    await _albumApiRepository.setActivityStatus(albumId, enabled);
+
+    return _repository.setActivityStatus(albumId, enabled);
+  }
+
+  Future<int> getCount() {
+    return _repository.getCount();
+  }
+
+  Future<List<RemoteAlbum>> getAlbumsContainingAsset(String assetId) {
+    return _repository.getAlbumsContainingAsset(assetId);
+  }
+
+  Future<List<RemoteAlbum>> _sortByNewestAsset(List<RemoteAlbum> albums) async {
+    // map album IDs to their newest asset dates
+    final Map<String, Future<DateTime?>> assetTimestampFutures = {};
+    for (final album in albums) {
+      assetTimestampFutures[album.id] = _repository.getNewestAssetTimestamp(album.id);
+    }
+
+    // await all database queries
+    final entries = await Future.wait(
+      assetTimestampFutures.entries.map((entry) async => MapEntry(entry.key, await entry.value)),
+    );
+    final assetTimestamps = Map.fromEntries(entries);
+
+    final sorted = albums.sorted((a, b) {
+      final aDate = assetTimestamps[a.id] ?? DateTime.fromMillisecondsSinceEpoch(0);
+      final bDate = assetTimestamps[b.id] ?? DateTime.fromMillisecondsSinceEpoch(0);
+      return aDate.compareTo(bDate);
+    });
+
+    return sorted;
+  }
+
+  Future<List<RemoteAlbum>> _sortByOldestAsset(List<RemoteAlbum> albums) async {
+    // map album IDs to their oldest asset dates
+    final Map<String, Future<DateTime?>> assetTimestampFutures = {
+      for (final album in albums) album.id: _repository.getOldestAssetTimestamp(album.id),
+    };
+
+    // await all database queries
+    final entries = await Future.wait(
+      assetTimestampFutures.entries.map((entry) async => MapEntry(entry.key, await entry.value)),
+    );
+    final assetTimestamps = Map.fromEntries(entries);
+
+    final sorted = albums.sorted((a, b) {
+      final aDate = assetTimestamps[a.id] ?? DateTime.fromMillisecondsSinceEpoch(0);
+      final bDate = assetTimestamps[b.id] ?? DateTime.fromMillisecondsSinceEpoch(0);
+      return aDate.compareTo(bDate);
+    });
+
+    return sorted.reversed.toList();
+  }
+}
--- a/mobile/lib/domain/services/search.service.dart
+++ b/mobile/lib/domain/services/search.service.dart
@ -0,0 +1,93 @@
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/domain/models/search_result.model.dart';
+import 'package:immich_mobile/extensions/string_extensions.dart';
+import 'package:immich_mobile/infrastructure/repositories/search_api.repository.dart';
+import 'package:immich_mobile/models/search/search_filter.model.dart';
+import 'package:logging/logging.dart';
+import 'package:openapi/api.dart' as api show AssetVisibility;
+import 'package:openapi/api.dart' hide AssetVisibility;
+
+class SearchService {
+  final _log = Logger("SearchService");
+  final SearchApiRepository _searchApiRepository;
+
+  SearchService(this._searchApiRepository);
+
+  Future<List<String>?> getSearchSuggestions(
+    SearchSuggestionType type, {
+    String? country,
+    String? state,
+    String? make,
+    String? model,
+  }) async {
+    try {
+      return await _searchApiRepository.getSearchSuggestions(
+        type,
+        country: country,
+        state: state,
+        make: make,
+        model: model,
+      );
+    } catch (e) {
+      _log.warning("Failed to get search suggestions", e);
+    }
+    return [];
+  }
+
+  Future<SearchResult?> search(SearchFilter filter, int page) async {
+    try {
+      final response = await _searchApiRepository.search(filter, page);
+
+      if (response == null || response.assets.items.isEmpty) {
+        return null;
+      }
+
+      return SearchResult(
+        assets: response.assets.items.map((e) => e.toDto()).toList(),
+        nextPage: response.assets.nextPage?.toInt(),
+      );
+    } catch (error, stackTrace) {
+      _log.severe("Failed to search for assets", error, stackTrace);
+    }
+    return null;
+  }
+}
+
+extension on AssetResponseDto {
+  RemoteAsset toDto() {
+    return RemoteAsset(
+      id: id,
+      name: originalFileName,
+      checksum: checksum,
+      createdAt: fileCreatedAt,
+      updatedAt: updatedAt,
+      ownerId: ownerId,
+      visibility: switch (visibility) {
+        api.AssetVisibility.timeline => AssetVisibility.timeline,
+        api.AssetVisibility.hidden => AssetVisibility.hidden,
+        api.AssetVisibility.archive => AssetVisibility.archive,
+        api.AssetVisibility.locked => AssetVisibility.locked,
+        _ => AssetVisibility.timeline,
+      },
+      durationInSeconds: duration.toDuration()?.inSeconds ?? 0,
+      height: exifInfo?.exifImageHeight?.toInt(),
+      width: exifInfo?.exifImageWidth?.toInt(),
+      isFavorite: isFavorite,
+      livePhotoVideoId: livePhotoVideoId,
+      thumbHash: thumbhash,
+      localId: null,
+      type: type.toAssetType(),
+      isEdited: isEdited,
+    );
+  }
+}
+
+extension on AssetTypeEnum {
+  AssetType toAssetType() => switch (this) {
+    AssetTypeEnum.IMAGE => AssetType.image,
+    AssetTypeEnum.VIDEO => AssetType.video,
+    AssetTypeEnum.AUDIO => AssetType.audio,
+    AssetTypeEnum.OTHER => AssetType.other,
+    _ => throw Exception('Unknown AssetType value: $this'),
+  };
+}
--- a/mobile/lib/domain/services/setting.service.dart
+++ b/mobile/lib/domain/services/setting.service.dart
@ -0,0 +1,19 @@
+import 'package:immich_mobile/domain/models/setting.model.dart';
+import 'package:immich_mobile/domain/services/store.service.dart';
+
+// Singleton instance of SettingsService, to use in places
+// where reactivity is not required
+// ignore: non_constant_identifier_names
+final AppSetting = SettingsService(storeService: StoreService.I);
+
+class SettingsService {
+  final StoreService _storeService;
+
+  const SettingsService({required StoreService storeService}) : _storeService = storeService;
+
+  T get<T>(Setting<T> setting) => _storeService.get(setting.storeKey, setting.defaultValue);
+
+  Future<void> set<T>(Setting<T> setting, T value) => _storeService.put(setting.storeKey, value);
+
+  Stream<T> watch<T>(Setting<T> setting) => _storeService.watch(setting.storeKey).map((v) => v ?? setting.defaultValue);
+}
--- a/mobile/lib/domain/services/store.service.dart
+++ b/mobile/lib/domain/services/store.service.dart
@ -0,0 +1,104 @@
+import 'dart:async';
+
+import 'package:immich_mobile/domain/models/store.model.dart';
+import 'package:immich_mobile/infrastructure/repositories/store.repository.dart';
+
+/// Provides access to a persistent key-value store with an in-memory cache.
+/// Listens for repository changes to keep the cache updated.
+class StoreService {
+  final IStoreRepository _storeRepository;
+
+  /// In-memory cache. Keys are [StoreKey.id]
+  final Map<int, Object?> _cache = {};
+  StreamSubscription<List<StoreDto>>? _storeUpdateSubscription;
+
+  StoreService._({required IStoreRepository isarStoreRepository}) : _storeRepository = isarStoreRepository;
+
+  // TODO: Temporary typedef to make minimal changes. Remove this and make the presentation layer access store through a provider
+  static StoreService? _instance;
+  static StoreService get I {
+    if (_instance == null) {
+      throw UnsupportedError("StoreService not initialized. Call init() first");
+    }
+    return _instance!;
+  }
+
+  // TODO: Replace the implementation with the one from create after removing the typedef
+  static Future<StoreService> init({required IStoreRepository storeRepository, bool listenUpdates = true}) async {
+    _instance ??= await create(storeRepository: storeRepository, listenUpdates: listenUpdates);
+    return _instance!;
+  }
+
+  static Future<StoreService> create({required IStoreRepository storeRepository, bool listenUpdates = true}) async {
+    final instance = StoreService._(isarStoreRepository: storeRepository);
+    await instance.populateCache();
+    if (listenUpdates) {
+      instance._storeUpdateSubscription = instance._listenForChange();
+    }
+    return instance;
+  }
+
+  Future<void> populateCache() async {
+    final storeValues = await _storeRepository.getAll();
+    for (StoreDto storeValue in storeValues) {
+      _cache[storeValue.key.id] = storeValue.value;
+    }
+  }
+
+  StreamSubscription<List<StoreDto>> _listenForChange() => _storeRepository.watchAll().listen((events) {
+    for (final event in events) {
+      _cache[event.key.id] = event.value;
+    }
+  });
+
+  /// Disposes the store and cancels the subscription. To reuse the store call init() again
+  Future<void> dispose() async {
+    await _storeUpdateSubscription?.cancel();
+    _cache.clear();
+  }
+
+  /// Returns the cached value for [key], or `null`
+  T? tryGet<T>(StoreKey<T> key) => _cache[key.id] as T?;
+
+  /// Returns the stored value for [key] or [defaultValue].
+  /// Throws [StoreKeyNotFoundException] if value and [defaultValue] are null.
+  T get<T>(StoreKey<T> key, [T? defaultValue]) {
+    final value = tryGet(key) ?? defaultValue;
+    if (value == null) {
+      throw StoreKeyNotFoundException(key);
+    }
+    return value;
+  }
+
+  /// Stores the [value] for the [key]. Skips write if value hasn't changed.
+  Future<void> put<U extends StoreKey<T>, T>(U key, T value) async {
+    if (_cache[key.id] == value) return;
+    await _storeRepository.upsert(key, value);
+    _cache[key.id] = value;
+  }
+
+  /// Returns a stream that emits the value for [key] on change.
+  Stream<T?> watch<T>(StoreKey<T> key) => _storeRepository.watch(key);
+
+  /// Removes the value for [key]
+  Future<void> delete<T>(StoreKey<T> key) async {
+    await _storeRepository.delete(key);
+    _cache.remove(key.id);
+  }
+
+  /// Clears all values from the store (cache and DB)
+  Future<void> clear() async {
+    await _storeRepository.deleteAll();
+    _cache.clear();
+  }
+
+  bool get isBetaTimelineEnabled => tryGet(StoreKey.betaTimeline) ?? true;
+}
+
+class StoreKeyNotFoundException implements Exception {
+  final StoreKey key;
+  const StoreKeyNotFoundException(this.key);
+
+  @override
+  String toString() => "Key - <${key.name}> not available in Store";
+}
--- a/mobile/lib/domain/services/sync_linked_album.service.dart
+++ b/mobile/lib/domain/services/sync_linked_album.service.dart
@ -0,0 +1,110 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/album/local_album.model.dart';
+import 'package:immich_mobile/infrastructure/repositories/local_album.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/remote_album.repository.dart';
+import 'package:immich_mobile/providers/infrastructure/album.provider.dart';
+import 'package:immich_mobile/repositories/drift_album_api_repository.dart';
+import 'package:immich_mobile/utils/debug_print.dart';
+import 'package:logging/logging.dart';
+
+final syncLinkedAlbumServiceProvider = Provider(
+  (ref) => SyncLinkedAlbumService(
+    ref.watch(localAlbumRepository),
+    ref.watch(remoteAlbumRepository),
+    ref.watch(driftAlbumApiRepositoryProvider),
+  ),
+);
+
+class SyncLinkedAlbumService {
+  final DriftLocalAlbumRepository _localAlbumRepository;
+  final DriftRemoteAlbumRepository _remoteAlbumRepository;
+  final DriftAlbumApiRepository _albumApiRepository;
+
+  SyncLinkedAlbumService(this._localAlbumRepository, this._remoteAlbumRepository, this._albumApiRepository);
+
+  final _log = Logger("SyncLinkedAlbumService");
+
+  Future<void> syncLinkedAlbums(String userId) async {
+    final selectedAlbums = await _localAlbumRepository.getBackupAlbums();
+
+    await Future.wait(
+      selectedAlbums.map((localAlbum) async {
+        final linkedRemoteAlbumId = localAlbum.linkedRemoteAlbumId;
+        if (linkedRemoteAlbumId == null) {
+          _log.warning("No linked remote album ID found for local album: ${localAlbum.name}");
+          return;
+        }
+
+        final remoteAlbum = await _remoteAlbumRepository.get(linkedRemoteAlbumId);
+        if (remoteAlbum == null) {
+          _log.warning("Linked remote album not found for ID: $linkedRemoteAlbumId");
+          return;
+        }
+
+        // get assets that are uploaded but not in the remote album
+        final assetIds = await _remoteAlbumRepository.getLinkedAssetIds(userId, localAlbum.id, linkedRemoteAlbumId);
+        _log.fine("Syncing ${assetIds.length} assets to remote album: ${remoteAlbum.name}");
+        if (assetIds.isNotEmpty) {
+          final album = await _albumApiRepository.addAssets(remoteAlbum.id, assetIds);
+          await _remoteAlbumRepository.addAssets(remoteAlbum.id, album.added);
+        }
+      }),
+    );
+  }
+
+  Future<void> manageLinkedAlbums(List<LocalAlbum> localAlbums, String ownerId) async {
+    try {
+      for (final album in localAlbums) {
+        await _processLocalAlbum(album, ownerId);
+      }
+    } catch (error, stackTrace) {
+      _log.severe("Error managing linked albums", error, stackTrace);
+    }
+  }
+
+  /// Processes a single local album to ensure proper linking with remote albums
+  Future<void> _processLocalAlbum(LocalAlbum localAlbum, String ownerId) {
+    final hasLinkedRemoteAlbum = localAlbum.linkedRemoteAlbumId != null;
+
+    if (hasLinkedRemoteAlbum) {
+      return _handleLinkedAlbum(localAlbum);
+    } else {
+      return _handleUnlinkedAlbum(localAlbum, ownerId);
+    }
+  }
+
+  /// Handles albums that are already linked to a remote album
+  Future<void> _handleLinkedAlbum(LocalAlbum localAlbum) async {
+    final remoteAlbumId = localAlbum.linkedRemoteAlbumId!;
+    final remoteAlbum = await _remoteAlbumRepository.get(remoteAlbumId);
+
+    final remoteAlbumExists = remoteAlbum != null;
+    if (!remoteAlbumExists) {
+      return _localAlbumRepository.unlinkRemoteAlbum(localAlbum.id);
+    }
+  }
+
+  /// Handles albums that are not linked to any remote album
+  Future<void> _handleUnlinkedAlbum(LocalAlbum localAlbum, String ownerId) async {
+    final existingRemoteAlbum = await _remoteAlbumRepository.getByName(localAlbum.name, ownerId);
+
+    if (existingRemoteAlbum != null) {
+      return _linkToExistingRemoteAlbum(localAlbum, existingRemoteAlbum);
+    } else {
+      return _createAndLinkNewRemoteAlbum(localAlbum);
+    }
+  }
+
+  /// Links a local album to an existing remote album
+  Future<void> _linkToExistingRemoteAlbum(LocalAlbum localAlbum, dynamic existingRemoteAlbum) {
+    return _localAlbumRepository.linkRemoteAlbum(localAlbum.id, existingRemoteAlbum.id);
+  }
+
+  /// Creates a new remote album and links it to the local album
+  Future<void> _createAndLinkNewRemoteAlbum(LocalAlbum localAlbum) async {
+    dPrint(() => "Creating new remote album for local album: ${localAlbum.name}");
+    final newRemoteAlbum = await _albumApiRepository.createDriftAlbum(localAlbum.name, assetIds: []);
+    await _remoteAlbumRepository.create(newRemoteAlbum, []);
+    return _localAlbumRepository.linkRemoteAlbum(localAlbum.id, newRemoteAlbum.id);
+  }
+}
--- a/mobile/lib/domain/services/sync_stream.service.dart
+++ b/mobile/lib/domain/services/sync_stream.service.dart
@ -0,0 +1,400 @@
+// ignore_for_file: constant_identifier_names
+
+import 'dart:async';
+import 'dart:convert';
+
+import 'package:immich_mobile/domain/models/store.model.dart';
+import 'package:immich_mobile/domain/models/sync_event.model.dart';
+import 'package:immich_mobile/entities/store.entity.dart';
+import 'package:immich_mobile/extensions/platform_extensions.dart';
+import 'package:immich_mobile/infrastructure/repositories/local_asset.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/storage.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/sync_api.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/sync_migration.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/sync_stream.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/trashed_local_asset.repository.dart';
+import 'package:immich_mobile/repositories/local_files_manager.repository.dart';
+import 'package:immich_mobile/services/api.service.dart';
+import 'package:immich_mobile/utils/semver.dart';
+import 'package:logging/logging.dart';
+import 'package:openapi/api.dart';
+
+enum SyncMigrationTask {
+  v20260128_ResetExifV1, // EXIF table has incorrect width and height information.
+  v20260128_CopyExifWidthHeightToAsset, // Asset table has incorrect width and height for video ratio calculations.
+  v20260128_ResetAssetV1, // Asset v2.5.0 has width and height information that were edited assets.
+}
+
+class SyncStreamService {
+  final Logger _logger = Logger('SyncStreamService');
+
+  final SyncApiRepository _syncApiRepository;
+  final SyncStreamRepository _syncStreamRepository;
+  final DriftLocalAssetRepository _localAssetRepository;
+  final DriftTrashedLocalAssetRepository _trashedLocalAssetRepository;
+  final LocalFilesManagerRepository _localFilesManager;
+  final StorageRepository _storageRepository;
+  final SyncMigrationRepository _syncMigrationRepository;
+  final ApiService _api;
+  final bool Function()? _cancelChecker;
+
+  SyncStreamService({
+    required SyncApiRepository syncApiRepository,
+    required SyncStreamRepository syncStreamRepository,
+    required DriftLocalAssetRepository localAssetRepository,
+    required DriftTrashedLocalAssetRepository trashedLocalAssetRepository,
+    required LocalFilesManagerRepository localFilesManager,
+    required StorageRepository storageRepository,
+    required SyncMigrationRepository syncMigrationRepository,
+    required ApiService api,
+    bool Function()? cancelChecker,
+  }) : _syncApiRepository = syncApiRepository,
+       _syncStreamRepository = syncStreamRepository,
+       _localAssetRepository = localAssetRepository,
+       _trashedLocalAssetRepository = trashedLocalAssetRepository,
+       _localFilesManager = localFilesManager,
+       _storageRepository = storageRepository,
+       _syncMigrationRepository = syncMigrationRepository,
+       _api = api,
+       _cancelChecker = cancelChecker;
+
+  bool get isCancelled => _cancelChecker?.call() ?? false;
+
+  Future<bool> sync() async {
+    _logger.info("Remote sync request for user");
+    final serverVersion = await _api.serverInfoApi.getServerVersion();
+    if (serverVersion == null) {
+      _logger.severe("Cannot perform sync: unable to determine server version");
+      return false;
+    }
+
+    final semVer = SemVer(major: serverVersion.major, minor: serverVersion.minor, patch: serverVersion.patch_);
+
+    final value = Store.get(StoreKey.syncMigrationStatus, "[]");
+    final migrations = (jsonDecode(value) as List).cast<String>();
+    int previousLength = migrations.length;
+    await _runPreSyncTasks(migrations, semVer);
+
+    if (migrations.length != previousLength) {
+      _logger.info("Updated pre-sync migration status: $migrations");
+      await Store.put(StoreKey.syncMigrationStatus, jsonEncode(migrations));
+    }
+
+    // Start the sync stream and handle events
+    bool shouldReset = false;
+    await _syncApiRepository.streamChanges(_handleEvents, onReset: () => shouldReset = true);
+    if (shouldReset) {
+      _logger.info("Resetting sync state as requested by server");
+      await _syncApiRepository.streamChanges(_handleEvents);
+    }
+
+    previousLength = migrations.length;
+    await _runPostSyncTasks(migrations);
+
+    if (migrations.length != previousLength) {
+      _logger.info("Updated pre-sync migration status: $migrations");
+      await Store.put(StoreKey.syncMigrationStatus, jsonEncode(migrations));
+    }
+
+    return true;
+  }
+
+  Future<void> _runPreSyncTasks(List<String> migrations, SemVer semVer) async {
+    if (!migrations.contains(SyncMigrationTask.v20260128_ResetExifV1.name)) {
+      _logger.info("Running pre-sync task: v20260128_ResetExifV1");
+      await _syncApiRepository.deleteSyncAck([
+        SyncEntityType.assetExifV1,
+        SyncEntityType.partnerAssetExifV1,
+        SyncEntityType.albumAssetExifCreateV1,
+        SyncEntityType.albumAssetExifUpdateV1,
+      ]);
+      migrations.add(SyncMigrationTask.v20260128_ResetExifV1.name);
+    }
+
+    if (!migrations.contains(SyncMigrationTask.v20260128_ResetAssetV1.name) &&
+        semVer >= const SemVer(major: 2, minor: 5, patch: 0)) {
+      _logger.info("Running pre-sync task: v20260128_ResetAssetV1");
+      await _syncApiRepository.deleteSyncAck([
+        SyncEntityType.assetV1,
+        SyncEntityType.partnerAssetV1,
+        SyncEntityType.albumAssetCreateV1,
+        SyncEntityType.albumAssetUpdateV1,
+      ]);
+
+      migrations.add(SyncMigrationTask.v20260128_ResetAssetV1.name);
+
+      if (!migrations.contains(SyncMigrationTask.v20260128_CopyExifWidthHeightToAsset.name)) {
+        migrations.add(SyncMigrationTask.v20260128_CopyExifWidthHeightToAsset.name);
+      }
+    }
+  }
+
+  Future<void> _runPostSyncTasks(List<String> migrations) async {
+    if (!migrations.contains(SyncMigrationTask.v20260128_CopyExifWidthHeightToAsset.name)) {
+      _logger.info("Running post-sync task: v20260128_CopyExifWidthHeightToAsset");
+      await _syncMigrationRepository.v20260128CopyExifWidthHeightToAsset();
+      migrations.add(SyncMigrationTask.v20260128_CopyExifWidthHeightToAsset.name);
+    }
+  }
+
+  Future<void> _handleEvents(List<SyncEvent> events, Function() abort, Function() reset) async {
+    List<SyncEvent> items = [];
+    for (final event in events) {
+      if (isCancelled) {
+        _logger.warning("Sync stream cancelled");
+        abort();
+        return;
+      }
+
+      if (event.type != items.firstOrNull?.type) {
+        await _processBatch(items);
+      }
+
+      if (event.type == SyncEntityType.syncResetV1) {
+        reset();
+      }
+
+      items.add(event);
+    }
+
+    await _processBatch(items);
+  }
+
+  Future<void> _processBatch(List<SyncEvent> batch) async {
+    if (batch.isEmpty) {
+      return;
+    }
+
+    final type = batch.first.type;
+    await _handleSyncData(type, batch.map((e) => e.data));
+    await _syncApiRepository.ack([batch.last.ack]);
+    batch.clear();
+  }
+
+  Future<void> _handleSyncData(SyncEntityType type, Iterable<Object> data) async {
+    _logger.fine("Processing sync data for $type of length ${data.length}");
+    switch (type) {
+      case SyncEntityType.authUserV1:
+        return _syncStreamRepository.updateAuthUsersV1(data.cast());
+      case SyncEntityType.userV1:
+        return _syncStreamRepository.updateUsersV1(data.cast());
+      case SyncEntityType.userDeleteV1:
+        return _syncStreamRepository.deleteUsersV1(data.cast());
+      case SyncEntityType.partnerV1:
+        return _syncStreamRepository.updatePartnerV1(data.cast());
+      case SyncEntityType.partnerDeleteV1:
+        return _syncStreamRepository.deletePartnerV1(data.cast());
+      case SyncEntityType.assetV1:
+        final remoteSyncAssets = data.cast<SyncAssetV1>();
+        await _syncStreamRepository.updateAssetsV1(remoteSyncAssets);
+        if (CurrentPlatform.isAndroid && Store.get(StoreKey.manageLocalMediaAndroid, false)) {
+          final hasPermission = await _localFilesManager.hasManageMediaPermission();
+          if (hasPermission) {
+            await _handleRemoteTrashed(remoteSyncAssets.where((e) => e.deletedAt != null).map((e) => e.checksum));
+            await _applyRemoteRestoreToLocal();
+          } else {
+            _logger.warning("sync Trashed Assets cannot proceed because MANAGE_MEDIA permission is missing");
+          }
+        }
+        return;
+      case SyncEntityType.assetDeleteV1:
+        return _syncStreamRepository.deleteAssetsV1(data.cast());
+      case SyncEntityType.assetExifV1:
+        return _syncStreamRepository.updateAssetsExifV1(data.cast());
+      case SyncEntityType.assetMetadataV1:
+        return _syncStreamRepository.updateAssetsMetadataV1(data.cast());
+      case SyncEntityType.assetMetadataDeleteV1:
+        return _syncStreamRepository.deleteAssetsMetadataV1(data.cast());
+      case SyncEntityType.partnerAssetV1:
+        return _syncStreamRepository.updateAssetsV1(data.cast(), debugLabel: 'partner');
+      case SyncEntityType.partnerAssetBackfillV1:
+        return _syncStreamRepository.updateAssetsV1(data.cast(), debugLabel: 'partner backfill');
+      case SyncEntityType.partnerAssetDeleteV1:
+        return _syncStreamRepository.deleteAssetsV1(data.cast(), debugLabel: "partner");
+      case SyncEntityType.partnerAssetExifV1:
+        return _syncStreamRepository.updateAssetsExifV1(data.cast(), debugLabel: 'partner');
+      case SyncEntityType.partnerAssetExifBackfillV1:
+        return _syncStreamRepository.updateAssetsExifV1(data.cast(), debugLabel: 'partner backfill');
+      case SyncEntityType.albumV1:
+        return _syncStreamRepository.updateAlbumsV1(data.cast());
+      case SyncEntityType.albumDeleteV1:
+        return _syncStreamRepository.deleteAlbumsV1(data.cast());
+      case SyncEntityType.albumUserV1:
+        return _syncStreamRepository.updateAlbumUsersV1(data.cast());
+      case SyncEntityType.albumUserBackfillV1:
+        return _syncStreamRepository.updateAlbumUsersV1(data.cast(), debugLabel: 'backfill');
+      case SyncEntityType.albumUserDeleteV1:
+        return _syncStreamRepository.deleteAlbumUsersV1(data.cast());
+      case SyncEntityType.albumAssetCreateV1:
+        return _syncStreamRepository.updateAssetsV1(data.cast(), debugLabel: 'album asset create');
+      case SyncEntityType.albumAssetUpdateV1:
+        return _syncStreamRepository.updateAssetsV1(data.cast(), debugLabel: 'album asset update');
+      case SyncEntityType.albumAssetBackfillV1:
+        return _syncStreamRepository.updateAssetsV1(data.cast(), debugLabel: 'album asset backfill');
+      case SyncEntityType.albumAssetExifCreateV1:
+        return _syncStreamRepository.updateAssetsExifV1(data.cast(), debugLabel: 'album asset exif create');
+      case SyncEntityType.albumAssetExifUpdateV1:
+        return _syncStreamRepository.updateAssetsExifV1(data.cast(), debugLabel: 'album asset exif update');
+      case SyncEntityType.albumAssetExifBackfillV1:
+        return _syncStreamRepository.updateAssetsExifV1(data.cast(), debugLabel: 'album asset exif backfill');
+      case SyncEntityType.albumToAssetV1:
+        return _syncStreamRepository.updateAlbumToAssetsV1(data.cast());
+      case SyncEntityType.albumToAssetBackfillV1:
+        return _syncStreamRepository.updateAlbumToAssetsV1(data.cast(), debugLabel: 'backfill');
+      case SyncEntityType.albumToAssetDeleteV1:
+        return _syncStreamRepository.deleteAlbumToAssetsV1(data.cast());
+      // No-op. SyncAckV1 entities are checkpoints in the sync stream
+      // to acknowledge that the client has processed all the backfill events
+      case SyncEntityType.syncAckV1:
+        return;
+      // SyncCompleteV1 is used to signal the completion of the sync process. Cleanup stale assets and signal completion
+      case SyncEntityType.syncCompleteV1:
+        return;
+      // return _syncStreamRepository.pruneAssets();
+      // Request to reset the client state. Clear everything related to remote entities
+      case SyncEntityType.syncResetV1:
+        return _syncStreamRepository.reset();
+      case SyncEntityType.memoryV1:
+        return _syncStreamRepository.updateMemoriesV1(data.cast());
+      case SyncEntityType.memoryDeleteV1:
+        return _syncStreamRepository.deleteMemoriesV1(data.cast());
+      case SyncEntityType.memoryToAssetV1:
+        return _syncStreamRepository.updateMemoryAssetsV1(data.cast());
+      case SyncEntityType.memoryToAssetDeleteV1:
+        return _syncStreamRepository.deleteMemoryAssetsV1(data.cast());
+      case SyncEntityType.stackV1:
+        return _syncStreamRepository.updateStacksV1(data.cast());
+      case SyncEntityType.stackDeleteV1:
+        return _syncStreamRepository.deleteStacksV1(data.cast());
+      case SyncEntityType.partnerStackV1:
+        return _syncStreamRepository.updateStacksV1(data.cast(), debugLabel: 'partner');
+      case SyncEntityType.partnerStackBackfillV1:
+        return _syncStreamRepository.updateStacksV1(data.cast(), debugLabel: 'partner backfill');
+      case SyncEntityType.partnerStackDeleteV1:
+        return _syncStreamRepository.deleteStacksV1(data.cast(), debugLabel: 'partner');
+      case SyncEntityType.userMetadataV1:
+        return _syncStreamRepository.updateUserMetadatasV1(data.cast());
+      case SyncEntityType.userMetadataDeleteV1:
+        return _syncStreamRepository.deleteUserMetadatasV1(data.cast());
+      case SyncEntityType.personV1:
+        return _syncStreamRepository.updatePeopleV1(data.cast());
+      case SyncEntityType.personDeleteV1:
+        return _syncStreamRepository.deletePeopleV1(data.cast());
+      case SyncEntityType.assetFaceV1:
+        return _syncStreamRepository.updateAssetFacesV1(data.cast());
+      case SyncEntityType.assetFaceDeleteV1:
+        return _syncStreamRepository.deleteAssetFacesV1(data.cast());
+      default:
+        _logger.warning("Unknown sync data type: $type");
+    }
+  }
+
+  Future<void> handleWsAssetUploadReadyV1Batch(List<dynamic> batchData) async {
+    if (batchData.isEmpty) return;
+
+    _logger.info('Processing batch of ${batchData.length} AssetUploadReadyV1 events');
+
+    final List<SyncAssetV1> assets = [];
+    final List<SyncAssetExifV1> exifs = [];
+
+    try {
+      for (final data in batchData) {
+        if (data is! Map<String, dynamic>) {
+          continue;
+        }
+
+        final payload = data;
+        final assetData = payload['asset'];
+        final exifData = payload['exif'];
+
+        if (assetData == null || exifData == null) {
+          continue;
+        }
+
+        final asset = SyncAssetV1.fromJson(assetData);
+        final exif = SyncAssetExifV1.fromJson(exifData);
+
+        if (asset != null && exif != null) {
+          assets.add(asset);
+          exifs.add(exif);
+        }
+      }
+
+      if (assets.isNotEmpty && exifs.isNotEmpty) {
+        await _syncStreamRepository.updateAssetsV1(assets, debugLabel: 'websocket-batch');
+        await _syncStreamRepository.updateAssetsExifV1(exifs, debugLabel: 'websocket-batch');
+        _logger.info('Successfully processed ${assets.length} assets in batch');
+      }
+    } catch (error, stackTrace) {
+      _logger.severe("Error processing AssetUploadReadyV1 websocket batch events", error, stackTrace);
+    }
+  }
+
+  Future<void> handleWsAssetEditReadyV1Batch(List<dynamic> batchData) async {
+    if (batchData.isEmpty) return;
+
+    _logger.info('Processing batch of ${batchData.length} AssetEditReadyV1 events');
+
+    final List<SyncAssetV1> assets = [];
+
+    try {
+      for (final data in batchData) {
+        if (data is! Map<String, dynamic>) {
+          continue;
+        }
+
+        final payload = data;
+        final assetData = payload['asset'];
+
+        if (assetData == null) {
+          continue;
+        }
+
+        final asset = SyncAssetV1.fromJson(assetData);
+
+        if (asset != null) {
+          assets.add(asset);
+        }
+      }
+
+      if (assets.isNotEmpty) {
+        await _syncStreamRepository.updateAssetsV1(assets, debugLabel: 'websocket-edit');
+        _logger.info('Successfully processed ${assets.length} edited assets');
+      }
+    } catch (error, stackTrace) {
+      _logger.severe("Error processing AssetEditReadyV1 websocket batch events", error, stackTrace);
+    }
+  }
+
+  Future<void> _handleRemoteTrashed(Iterable<String> checksums) async {
+    if (checksums.isEmpty) {
+      return Future.value();
+    } else {
+      final localAssetsToTrash = await _localAssetRepository.getAssetsFromBackupAlbums(checksums);
+      if (localAssetsToTrash.isNotEmpty) {
+        final mediaUrls = await Future.wait(
+          localAssetsToTrash.values
+              .expand((e) => e)
+              .map((localAsset) => _storageRepository.getAssetEntityForAsset(localAsset).then((e) => e?.getMediaUrl())),
+        );
+        _logger.info("Moving to trash ${mediaUrls.join(", ")} assets");
+        final result = await _localFilesManager.moveToTrash(mediaUrls.nonNulls.toList());
+        if (result) {
+          await _trashedLocalAssetRepository.trashLocalAsset(localAssetsToTrash);
+        }
+      } else {
+        _logger.info("No assets found in backup-enabled albums for assets: $checksums");
+      }
+    }
+  }
+
+  Future<void> _applyRemoteRestoreToLocal() async {
+    final assetsToRestore = await _trashedLocalAssetRepository.getToRestore();
+    if (assetsToRestore.isNotEmpty) {
+      final restoredIds = await _localFilesManager.restoreAssetsFromTrash(assetsToRestore);
+      await _trashedLocalAssetRepository.applyRestoredAssets(restoredIds);
+    } else {
+      _logger.info("No remote assets found for restoration");
+    }
+  }
+}
--- a/mobile/lib/domain/services/timeline.service.dart
+++ b/mobile/lib/domain/services/timeline.service.dart
@ -0,0 +1,236 @@
+import 'dart:async';
+import 'dart:math' as math;
+
+import 'package:collection/collection.dart';
+import 'package:immich_mobile/constants/constants.dart';
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/domain/models/events.model.dart';
+import 'package:immich_mobile/domain/models/setting.model.dart';
+import 'package:immich_mobile/domain/models/timeline.model.dart';
+import 'package:immich_mobile/domain/services/setting.service.dart';
+import 'package:immich_mobile/domain/utils/event_stream.dart';
+import 'package:immich_mobile/infrastructure/repositories/timeline.repository.dart';
+import 'package:immich_mobile/utils/async_mutex.dart';
+
+typedef TimelineAssetSource = Future<List<BaseAsset>> Function(int index, int count);
+
+typedef TimelineBucketSource = Stream<List<Bucket>> Function();
+
+typedef TimelineQuery = ({TimelineAssetSource assetSource, TimelineBucketSource bucketSource, TimelineOrigin origin});
+
+enum TimelineOrigin {
+  main,
+  localAlbum,
+  remoteAlbum,
+  remoteAssets,
+  favorite,
+  trash,
+  archive,
+  lockedFolder,
+  video,
+  place,
+  person,
+  map,
+  search,
+  deepLink,
+  albumActivities,
+}
+
+class TimelineFactory {
+  final DriftTimelineRepository _timelineRepository;
+  final SettingsService _settingsService;
+
+  const TimelineFactory({required DriftTimelineRepository timelineRepository, required SettingsService settingsService})
+    : _timelineRepository = timelineRepository,
+      _settingsService = settingsService;
+
+  GroupAssetsBy get groupBy {
+    final group = GroupAssetsBy.values[_settingsService.get(Setting.groupAssetsBy)];
+    // We do not support auto grouping in the new timeline yet, fallback to day grouping
+    return group == GroupAssetsBy.auto ? GroupAssetsBy.day : group;
+  }
+
+  TimelineService main(List<String> timelineUsers) => TimelineService(_timelineRepository.main(timelineUsers, groupBy));
+
+  TimelineService localAlbum({required String albumId}) =>
+      TimelineService(_timelineRepository.localAlbum(albumId, groupBy));
+
+  TimelineService remoteAlbum({required String albumId}) =>
+      TimelineService(_timelineRepository.remoteAlbum(albumId, groupBy));
+
+  TimelineService remoteAssets(String userId) => TimelineService(_timelineRepository.remote(userId, groupBy));
+
+  TimelineService favorite(String userId) => TimelineService(_timelineRepository.favorite(userId, groupBy));
+
+  TimelineService trash(String userId) => TimelineService(_timelineRepository.trash(userId, groupBy));
+
+  TimelineService archive(String userId) => TimelineService(_timelineRepository.archived(userId, groupBy));
+
+  TimelineService lockedFolder(String userId) => TimelineService(_timelineRepository.locked(userId, groupBy));
+
+  TimelineService video(String userId) => TimelineService(_timelineRepository.video(userId, groupBy));
+
+  TimelineService place(String place) => TimelineService(_timelineRepository.place(place, groupBy));
+
+  TimelineService person(String userId, String personId) =>
+      TimelineService(_timelineRepository.person(userId, personId, groupBy));
+
+  TimelineService fromAssets(List<BaseAsset> assets, TimelineOrigin type) =>
+      TimelineService(_timelineRepository.fromAssets(assets, type));
+
+  TimelineService fromAssetsWithBuckets(List<BaseAsset> assets, TimelineOrigin type) =>
+      TimelineService(_timelineRepository.fromAssetsWithBuckets(assets, type));
+
+  TimelineService map(List<String> userIds, TimelineMapOptions options) =>
+      TimelineService(_timelineRepository.map(userIds, options, groupBy));
+}
+
+class TimelineService {
+  final TimelineAssetSource _assetSource;
+  final TimelineBucketSource _bucketSource;
+  final TimelineOrigin origin;
+  final AsyncMutex _mutex = AsyncMutex();
+  int _bufferOffset = 0;
+  List<BaseAsset> _buffer = [];
+  StreamSubscription? _bucketSubscription;
+
+  int _totalAssets = 0;
+  int get totalAssets => _totalAssets;
+
+  TimelineService(TimelineQuery query)
+    : this._(assetSource: query.assetSource, bucketSource: query.bucketSource, origin: query.origin);
+
+  TimelineService._({
+    required TimelineAssetSource assetSource,
+    required TimelineBucketSource bucketSource,
+    required this.origin,
+  }) : _assetSource = assetSource,
+       _bucketSource = bucketSource {
+    _bucketSubscription = _bucketSource().listen((buckets) {
+      _mutex.run(() async {
+        final totalAssets = buckets.fold<int>(0, (acc, bucket) => acc + bucket.assetCount);
+
+        if (totalAssets == 0) {
+          _bufferOffset = 0;
+          _buffer.clear();
+        } else {
+          final int offset;
+          final int count;
+          // When the buffer is empty or the old bufferOffset is greater than the new total assets,
+          // we need to reset the buffer and load the first batch of assets.
+          if (_bufferOffset >= totalAssets || _buffer.isEmpty) {
+            offset = 0;
+            count = kTimelineAssetLoadBatchSize;
+          } else {
+            offset = _bufferOffset;
+            count = math.min(_buffer.length, totalAssets - _bufferOffset);
+          }
+          _buffer = await _assetSource(offset, count);
+          _bufferOffset = offset;
+        }
+
+        // change the state's total assets count only after the buffer is reloaded
+        _totalAssets = totalAssets;
+        EventStream.shared.emit(const TimelineReloadEvent());
+      });
+    });
+  }
+
+  Stream<List<Bucket>> Function() get watchBuckets => _bucketSource;
+
+  Future<List<BaseAsset>> loadAssets(int index, int count) => _mutex.run(() => _loadAssets(index, count));
+
+  Future<List<BaseAsset>> _loadAssets(int index, int count) async {
+    if (hasRange(index, count)) {
+      return getAssets(index, count);
+    }
+
+    // if the requested offset is greater than the cached offset, the user scrolls forward "down"
+    final bool forward = _bufferOffset < index;
+
+    // make sure to load a meaningful amount of data (and not only the requested slice)
+    // otherwise, each call to [loadAssets] would result in DB call trashing performance
+    // fills small requests to [kTimelineAssetLoadBatchSize], adds some legroom into the opposite scroll direction for large requests
+    final len = math.max(kTimelineAssetLoadBatchSize, count + kTimelineAssetLoadOppositeSize);
+    // when scrolling forward, start shortly before the requested offset
+    // when scrolling backward, end shortly after the requested offset to guard against the user scrolling
+    // in the other direction a tiny bit resulting in another required load from the DB
+    final start = math.max(
+      0,
+      forward
+          ? index - kTimelineAssetLoadOppositeSize
+          : (len > kTimelineAssetLoadBatchSize ? index : index + count - len),
+    );
+
+    _buffer = await _assetSource(start, len);
+    _bufferOffset = start;
+
+    return getAssets(index, count);
+  }
+
+  bool hasRange(int index, int count) =>
+      index >= 0 &&
+      index < _totalAssets &&
+      index >= _bufferOffset &&
+      index + count <= _bufferOffset + _buffer.length &&
+      index + count <= _totalAssets;
+
+  List<BaseAsset> getAssets(int index, int count) {
+    if (!hasRange(index, count)) {
+      throw RangeError('TimelineService::getAssets Index out of range');
+    }
+    int start = index - _bufferOffset;
+    return _buffer.slice(start, start + count);
+  }
+
+  // Pre-cache assets around the given index for asset viewer
+  Future<void> preCacheAssets(int index) => _mutex.run(() => _loadAssets(index, math.min(5, _totalAssets - index)));
+
+  BaseAsset getRandomAsset() => _buffer.elementAt(math.Random().nextInt(_buffer.length));
+
+  BaseAsset getAsset(int index) {
+    if (!hasRange(index, 1)) {
+      throw RangeError(
+        'TimelineService::getAsset Index $index not in buffer range [$_bufferOffset, ${_bufferOffset + _buffer.length})',
+      );
+    }
+    return _buffer.elementAt(index - _bufferOffset);
+  }
+
+  /// Gets an asset at the given index, automatically loading the buffer if needed.
+  /// This is an async version that can handle out-of-range indices by loading the appropriate buffer.
+  Future<BaseAsset?> getAssetAsync(int index) async {
+    if (index < 0 || index >= _totalAssets) {
+      return null;
+    }
+
+    if (hasRange(index, 1)) {
+      return _buffer.elementAt(index - _bufferOffset);
+    }
+
+    // Load the buffer containing the requested index
+    try {
+      final assets = await loadAssets(index, 1);
+      return assets.isNotEmpty ? assets.first : null;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  /// Safely gets an asset at the given index without throwing a RangeError.
+  /// Returns null if the index is out of bounds or not currently in the buffer.
+  /// For automatic buffer loading, use getAssetAsync instead.
+  BaseAsset? getAssetSafe(int index) {
+    if (index < 0 || index >= _totalAssets || !hasRange(index, 1)) {
+      return null;
+    }
+    return _buffer.elementAt(index - _bufferOffset);
+  }
+
+  Future<void> dispose() async {
+    await _bucketSubscription?.cancel();
+    _bucketSubscription = null;
+    _buffer = [];
+    _bufferOffset = 0;
+  }
+}
--- a/mobile/lib/domain/services/user.service.dart
+++ b/mobile/lib/domain/services/user.service.dart
@ -0,0 +1,65 @@
+import 'dart:async';
+import 'dart:typed_data';
+
+import 'package:immich_mobile/domain/models/store.model.dart';
+import 'package:immich_mobile/domain/models/user.model.dart';
+import 'package:immich_mobile/domain/services/store.service.dart';
+import 'package:immich_mobile/infrastructure/repositories/user.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/user_api.repository.dart';
+import 'package:logging/logging.dart';
+
+class UserService {
+  final Logger _log = Logger("UserService");
+  final IsarUserRepository _isarUserRepository;
+  final UserApiRepository _userApiRepository;
+  final StoreService _storeService;
+
+  UserService({
+    required IsarUserRepository isarUserRepository,
+    required UserApiRepository userApiRepository,
+    required StoreService storeService,
+  }) : _isarUserRepository = isarUserRepository,
+       _userApiRepository = userApiRepository,
+       _storeService = storeService;
+
+  UserDto getMyUser() {
+    return _storeService.get(StoreKey.currentUser);
+  }
+
+  UserDto? tryGetMyUser() {
+    return _storeService.tryGet(StoreKey.currentUser);
+  }
+
+  Stream<UserDto?> watchMyUser() {
+    return _storeService.watch(StoreKey.currentUser);
+  }
+
+  Future<UserDto?> refreshMyUser() async {
+    final user = await _userApiRepository.getMyUser();
+    if (user == null) return null;
+    await _storeService.put(StoreKey.currentUser, user);
+    await _isarUserRepository.update(user);
+    return user;
+  }
+
+  Future<String?> createProfileImage(String name, Uint8List image) async {
+    try {
+      final path = await _userApiRepository.createProfileImage(name: name, data: image);
+      final updatedUser = getMyUser();
+      await _storeService.put(StoreKey.currentUser, updatedUser);
+      await _isarUserRepository.update(updatedUser);
+      return path;
+    } catch (e) {
+      _log.warning("Failed to upload profile image", e);
+      return null;
+    }
+  }
+
+  Future<List<UserDto>> getAll() async {
+    return await _isarUserRepository.getAll();
+  }
+
+  Future<void> deleteAll() {
+    return _isarUserRepository.deleteAll();
+  }
+}
--- a/mobile/lib/domain/utils/background_sync.dart
+++ b/mobile/lib/domain/utils/background_sync.dart
@ -0,0 +1,248 @@
+import 'dart:async';
+
+import 'package:immich_mobile/domain/utils/migrate_cloud_ids.dart' as m;
+import 'package:immich_mobile/domain/utils/sync_linked_album.dart';
+import 'package:immich_mobile/providers/infrastructure/sync.provider.dart';
+import 'package:immich_mobile/utils/isolate.dart';
+import 'package:worker_manager/worker_manager.dart';
+
+typedef SyncCallback = void Function();
+typedef SyncCallbackWithResult<T> = void Function(T result);
+typedef SyncErrorCallback = void Function(String error);
+
+class BackgroundSyncManager {
+  final SyncCallback? onRemoteSyncStart;
+  final SyncCallbackWithResult<bool?>? onRemoteSyncComplete;
+  final SyncErrorCallback? onRemoteSyncError;
+
+  final SyncCallback? onLocalSyncStart;
+  final SyncCallback? onLocalSyncComplete;
+  final SyncErrorCallback? onLocalSyncError;
+
+  final SyncCallback? onHashingStart;
+  final SyncCallback? onHashingComplete;
+  final SyncErrorCallback? onHashingError;
+
+  final SyncCallback? onCloudIdSyncStart;
+  final SyncCallback? onCloudIdSyncComplete;
+  final SyncErrorCallback? onCloudIdSyncError;
+
+  Cancelable<bool?>? _syncTask;
+  Cancelable<void>? _syncWebsocketTask;
+  Cancelable<void>? _cloudIdSyncTask;
+  Cancelable<void>? _deviceAlbumSyncTask;
+  Cancelable<void>? _linkedAlbumSyncTask;
+  Cancelable<void>? _hashTask;
+
+  BackgroundSyncManager({
+    this.onRemoteSyncStart,
+    this.onRemoteSyncComplete,
+    this.onRemoteSyncError,
+    this.onLocalSyncStart,
+    this.onLocalSyncComplete,
+    this.onLocalSyncError,
+    this.onHashingStart,
+    this.onHashingComplete,
+    this.onHashingError,
+    this.onCloudIdSyncStart,
+    this.onCloudIdSyncComplete,
+    this.onCloudIdSyncError,
+  });
+
+  Future<void> cancel() async {
+    final futures = <Future>[];
+
+    if (_syncTask != null) {
+      futures.add(_syncTask!.future);
+    }
+    _syncTask?.cancel();
+    _syncTask = null;
+
+    if (_syncWebsocketTask != null) {
+      futures.add(_syncWebsocketTask!.future);
+    }
+    _syncWebsocketTask?.cancel();
+    _syncWebsocketTask = null;
+
+    if (_cloudIdSyncTask != null) {
+      futures.add(_cloudIdSyncTask!.future);
+    }
+    _cloudIdSyncTask?.cancel();
+    _cloudIdSyncTask = null;
+
+    if (_linkedAlbumSyncTask != null) {
+      futures.add(_linkedAlbumSyncTask!.future);
+    }
+    _linkedAlbumSyncTask?.cancel();
+    _linkedAlbumSyncTask = null;
+
+    try {
+      await Future.wait(futures);
+    } on CanceledError {
+      // Ignore cancellation errors
+    }
+  }
+
+  Future<void> cancelLocal() async {
+    final futures = <Future>[];
+
+    if (_hashTask != null) {
+      futures.add(_hashTask!.future);
+    }
+    _hashTask?.cancel();
+    _hashTask = null;
+
+    if (_deviceAlbumSyncTask != null) {
+      futures.add(_deviceAlbumSyncTask!.future);
+    }
+    _deviceAlbumSyncTask?.cancel();
+    _deviceAlbumSyncTask = null;
+
+    try {
+      await Future.wait(futures);
+    } on CanceledError {
+      // Ignore cancellation errors
+    }
+  }
+
+  // No need to cancel the task, as it can also be run when the user logs out
+  Future<void> syncLocal({bool full = false}) {
+    if (_deviceAlbumSyncTask != null) {
+      return _deviceAlbumSyncTask!.future;
+    }
+
+    onLocalSyncStart?.call();
+
+    // We use a ternary operator to avoid [_deviceAlbumSyncTask] from being
+    // captured by the closure passed to [runInIsolateGentle].
+    _deviceAlbumSyncTask = full
+        ? runInIsolateGentle(
+            computation: (ref) => ref.read(localSyncServiceProvider).sync(full: true),
+            debugLabel: 'local-sync-full-true',
+          )
+        : runInIsolateGentle(
+            computation: (ref) => ref.read(localSyncServiceProvider).sync(full: false),
+            debugLabel: 'local-sync-full-false',
+          );
+
+    return _deviceAlbumSyncTask!
+        .whenComplete(() {
+          _deviceAlbumSyncTask = null;
+          onLocalSyncComplete?.call();
+        })
+        .catchError((error) {
+          onLocalSyncError?.call(error.toString());
+          _deviceAlbumSyncTask = null;
+        });
+  }
+
+  Future<void> hashAssets() {
+    if (_hashTask != null) {
+      return _hashTask!.future;
+    }
+
+    onHashingStart?.call();
+
+    _hashTask = runInIsolateGentle(
+      computation: (ref) => ref.read(hashServiceProvider).hashAssets(),
+      debugLabel: 'hash-assets',
+    );
+
+    return _hashTask!
+        .whenComplete(() {
+          onHashingComplete?.call();
+          _hashTask = null;
+        })
+        .catchError((error) {
+          onHashingError?.call(error.toString());
+          _hashTask = null;
+        });
+  }
+
+  Future<bool> syncRemote() {
+    if (_syncTask != null) {
+      return _syncTask!.future.then((result) => result ?? false).catchError((_) => false);
+    }
+
+    onRemoteSyncStart?.call();
+
+    _syncTask = runInIsolateGentle(
+      computation: (ref) => ref.read(syncStreamServiceProvider).sync(),
+      debugLabel: 'remote-sync',
+    );
+    return _syncTask!
+        .then((result) {
+          final success = result ?? false;
+          onRemoteSyncComplete?.call(success);
+          return success;
+        })
+        .catchError((error) {
+          onRemoteSyncError?.call(error.toString());
+          _syncTask = null;
+          return false;
+        })
+        .whenComplete(() {
+          _syncTask = null;
+        });
+  }
+
+  Future<void> syncWebsocketBatch(List<dynamic> batchData) {
+    if (_syncWebsocketTask != null) {
+      return _syncWebsocketTask!.future;
+    }
+    _syncWebsocketTask = _handleWsAssetUploadReadyV1Batch(batchData);
+    return _syncWebsocketTask!.whenComplete(() {
+      _syncWebsocketTask = null;
+    });
+  }
+
+  Future<void> syncWebsocketEditBatch(List<dynamic> batchData) {
+    if (_syncWebsocketTask != null) {
+      return _syncWebsocketTask!.future;
+    }
+    _syncWebsocketTask = _handleWsAssetEditReadyV1Batch(batchData);
+    return _syncWebsocketTask!.whenComplete(() {
+      _syncWebsocketTask = null;
+    });
+  }
+
+  Future<void> syncLinkedAlbum() {
+    if (_linkedAlbumSyncTask != null) {
+      return _linkedAlbumSyncTask!.future;
+    }
+
+    _linkedAlbumSyncTask = runInIsolateGentle(computation: syncLinkedAlbumsIsolated, debugLabel: 'linked-album-sync');
+    return _linkedAlbumSyncTask!.whenComplete(() {
+      _linkedAlbumSyncTask = null;
+    });
+  }
+
+  Future<void> syncCloudIds() {
+    if (_cloudIdSyncTask != null) {
+      return _cloudIdSyncTask!.future;
+    }
+
+    onCloudIdSyncStart?.call();
+
+    _cloudIdSyncTask = runInIsolateGentle(computation: m.syncCloudIds);
+    return _cloudIdSyncTask!
+        .whenComplete(() {
+          onCloudIdSyncComplete?.call();
+          _cloudIdSyncTask = null;
+        })
+        .catchError((error) {
+          onCloudIdSyncError?.call(error.toString());
+          _cloudIdSyncTask = null;
+        });
+  }
+}
+
+Cancelable<void> _handleWsAssetUploadReadyV1Batch(List<dynamic> batchData) => runInIsolateGentle(
+  computation: (ref) => ref.read(syncStreamServiceProvider).handleWsAssetUploadReadyV1Batch(batchData),
+  debugLabel: 'websocket-batch',
+);
+
+Cancelable<void> _handleWsAssetEditReadyV1Batch(List<dynamic> batchData) => runInIsolateGentle(
+  computation: (ref) => ref.read(syncStreamServiceProvider).handleWsAssetEditReadyV1Batch(batchData),
+  debugLabel: 'websocket-edit',
+);
--- a/mobile/lib/domain/utils/event_stream.dart
+++ b/mobile/lib/domain/utils/event_stream.dart
@ -0,0 +1,38 @@
+import 'dart:async';
+
+class Event {
+  const Event();
+}
+
+class EventStream {
+  EventStream._();
+
+  static final EventStream shared = EventStream._();
+
+  final StreamController<Event> _controller = StreamController<Event>.broadcast();
+
+  void emit(Event event) {
+    _controller.add(event);
+  }
+
+  Stream<T> where<T extends Event>() {
+    if (T == Event) {
+      return _controller.stream as Stream<T>;
+    }
+    return _controller.stream.where((event) => event is T).cast<T>();
+  }
+
+  StreamSubscription<T> listen<T extends Event>(
+    void Function(T event)? onData, {
+    Function? onError,
+    void Function()? onDone,
+    bool? cancelOnError,
+  }) {
+    return where<T>().listen(onData, onError: onError, onDone: onDone, cancelOnError: cancelOnError);
+  }
+
+  /// Closes the stream controller
+  void dispose() {
+    _controller.close();
+  }
+}
--- a/mobile/lib/domain/utils/migrate_cloud_ids.dart
+++ b/mobile/lib/domain/utils/migrate_cloud_ids.dart
@ -0,0 +1,191 @@
+import 'package:drift/drift.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/constants/constants.dart';
+import 'package:immich_mobile/domain/models/asset/asset_metadata.model.dart';
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/extensions/platform_extensions.dart';
+import 'package:immich_mobile/infrastructure/entities/local_asset.entity.dart';
+import 'package:immich_mobile/infrastructure/repositories/db.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/local_album.repository.dart';
+import 'package:immich_mobile/platform/native_sync_api.g.dart';
+import 'package:immich_mobile/providers/api.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/db.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/sync.provider.dart';
+import 'package:immich_mobile/providers/server_info.provider.dart';
+import 'package:immich_mobile/providers/user.provider.dart';
+import 'package:logging/logging.dart';
+// ignore: import_rule_openapi
+import 'package:openapi/api.dart' hide AssetVisibility;
+
+Future<void> syncCloudIds(ProviderContainer ref) async {
+  if (!CurrentPlatform.isIOS) {
+    return;
+  }
+  final logger = Logger('migrateCloudIds');
+
+  final db = ref.read(driftProvider);
+  // Populate cloud IDs for local assets that don't have one yet
+  await _populateCloudIds(db);
+
+  final serverInfo = await ref.read(serverInfoProvider.notifier).getServerInfo();
+  final canUpdateMetadata = serverInfo.serverVersion.isAtLeast(major: 2, minor: 4);
+  if (!canUpdateMetadata) {
+    logger.fine('Server version does not support asset metadata updates. Skipping cloudId migration.');
+    return;
+  }
+  final canBulkUpdateMetadata = serverInfo.serverVersion.isAtLeast(major: 2, minor: 5);
+
+  // Wait for remote sync to complete, so we have up-to-date asset metadata entries
+  try {
+    await ref.read(syncStreamServiceProvider).sync();
+  } catch (e, s) {
+    logger.fine('Failed to complete remote sync before cloudId migration.', e, s);
+    return;
+  }
+
+  // Fetch the mapping for backed up assets that have a cloud ID locally but do not have a cloud ID on the server
+  final currentUser = ref.read(currentUserProvider);
+  if (currentUser == null) {
+    logger.warning('Current user is null. Aborting cloudId migration.');
+    return;
+  }
+
+  final assetApi = ref.read(apiServiceProvider).assetsApi;
+
+  // Process cloud IDs in paginated batches
+  await _processCloudIdMappingsInBatches(db, currentUser.id, assetApi, canBulkUpdateMetadata, logger);
+}
+
+Future<void> _processCloudIdMappingsInBatches(
+  Drift drift,
+  String userId,
+  AssetsApi assetsApi,
+  bool canBulkUpdate,
+  Logger logger,
+) async {
+  const pageSize = 20000;
+  String? lastLocalId;
+  final seenRemoteAssetIds = <String>{};
+
+  while (true) {
+    final mappings = await _fetchCloudIdMappings(drift, userId, pageSize, lastLocalId);
+    if (mappings.isEmpty) {
+      break;
+    }
+
+    final items = <AssetMetadataBulkUpsertItemDto>[];
+    for (final mapping in mappings) {
+      if (seenRemoteAssetIds.add(mapping.remoteAssetId)) {
+        items.add(
+          AssetMetadataBulkUpsertItemDto(
+            assetId: mapping.remoteAssetId,
+            key: kMobileMetadataKey,
+            value: RemoteAssetMobileAppMetadata(
+              cloudId: mapping.localAsset.cloudId,
+              createdAt: mapping.localAsset.createdAt.toIso8601String(),
+              adjustmentTime: mapping.localAsset.adjustmentTime?.toIso8601String(),
+              latitude: mapping.localAsset.latitude?.toString(),
+              longitude: mapping.localAsset.longitude?.toString(),
+            ),
+          ),
+        );
+      } else {
+        logger.fine('Duplicate remote asset ID found: ${mapping.remoteAssetId}. Skipping duplicate entry.');
+      }
+    }
+
+    if (items.isNotEmpty) {
+      if (canBulkUpdate) {
+        await _bulkUpdateCloudIds(assetsApi, items);
+      } else {
+        await _sequentialUpdateCloudIds(assetsApi, items);
+      }
+    }
+
+    lastLocalId = mappings.last.localAsset.id;
+    if (mappings.length < pageSize) {
+      break;
+    }
+  }
+}
+
+Future<void> _sequentialUpdateCloudIds(AssetsApi assetsApi, List<AssetMetadataBulkUpsertItemDto> items) async {
+  for (final item in items) {
+    final upsertItem = AssetMetadataUpsertItemDto(key: item.key, value: item.value);
+    try {
+      await assetsApi.updateAssetMetadata(item.assetId, AssetMetadataUpsertDto(items: [upsertItem]));
+    } catch (error, stack) {
+      Logger('migrateCloudIds').warning('Failed to update metadata for asset ${item.assetId}', error, stack);
+    }
+  }
+}
+
+Future<void> _bulkUpdateCloudIds(AssetsApi assetsApi, List<AssetMetadataBulkUpsertItemDto> items) async {
+  try {
+    await assetsApi.updateBulkAssetMetadata(AssetMetadataBulkUpsertDto(items: items));
+  } catch (error, stack) {
+    Logger('migrateCloudIds').warning('Failed to bulk update metadata', error, stack);
+  }
+}
+
+Future<void> _populateCloudIds(Drift drift) async {
+  final query = drift.localAssetEntity.selectOnly()
+    ..addColumns([drift.localAssetEntity.id])
+    ..where(drift.localAssetEntity.iCloudId.isNull());
+  final ids = await query.map((row) => row.read(drift.localAssetEntity.id)!).get();
+  final cloudMapping = <String, String>{};
+  final cloudIds = await NativeSyncApi().getCloudIdForAssetIds(ids);
+  for (int i = 0; i < cloudIds.length; i++) {
+    final cloudIdResult = cloudIds[i];
+    if (cloudIdResult.cloudId != null) {
+      cloudMapping[cloudIdResult.assetId] = cloudIdResult.cloudId!;
+    } else {
+      Logger('migrateCloudIds').fine(
+        "Cannot fetch cloudId for asset with id: ${cloudIdResult.assetId}. Error: ${cloudIdResult.error ?? "unknown"}",
+      );
+    }
+  }
+  await DriftLocalAlbumRepository(drift).updateCloudMapping(cloudMapping);
+}
+
+typedef _CloudIdMapping = ({String remoteAssetId, LocalAsset localAsset});
+
+Future<List<_CloudIdMapping>> _fetchCloudIdMappings(Drift drift, String userId, int limit, String? lastLocalId) async {
+  final query =
+      drift.localAssetEntity.select().join([
+          innerJoin(
+            drift.remoteAssetEntity,
+            drift.localAssetEntity.checksum.equalsExp(drift.remoteAssetEntity.checksum),
+          ),
+          leftOuterJoin(
+            drift.remoteAssetCloudIdEntity,
+            drift.remoteAssetEntity.id.equalsExp(drift.remoteAssetCloudIdEntity.assetId),
+            useColumns: false,
+          ),
+        ])
+        ..where(
+          // Only select assets that have a local cloud ID but either no remote cloud ID or a mismatched eTag
+          drift.localAssetEntity.iCloudId.isNotNull() &
+              drift.remoteAssetEntity.ownerId.equals(userId) &
+              // Skip locked assets as we cannot update them without unlocking first
+              drift.remoteAssetEntity.visibility.isNotValue(AssetVisibility.locked.index) &
+              (drift.remoteAssetCloudIdEntity.cloudId.isNull() |
+                  drift.remoteAssetCloudIdEntity.adjustmentTime.isNotExp(drift.localAssetEntity.adjustmentTime) |
+                  drift.remoteAssetCloudIdEntity.latitude.isNotExp(drift.localAssetEntity.latitude) |
+                  drift.remoteAssetCloudIdEntity.longitude.isNotExp(drift.localAssetEntity.longitude) |
+                  drift.remoteAssetCloudIdEntity.createdAt.isNotExp(drift.localAssetEntity.createdAt)),
+        )
+        ..orderBy([OrderingTerm.asc(drift.localAssetEntity.id)])
+        ..limit(limit);
+
+  if (lastLocalId != null) {
+    query.where(drift.localAssetEntity.id.isBiggerThanValue(lastLocalId));
+  }
+
+  return query.map((row) {
+    return (
+      remoteAssetId: row.read(drift.remoteAssetEntity.id)!,
+      localAsset: row.readTable(drift.localAssetEntity).toDto(),
+    );
+  }).get();
+}
--- a/mobile/lib/domain/utils/sync_linked_album.dart
+++ b/mobile/lib/domain/utils/sync_linked_album.dart
@ -0,0 +1,14 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/store.model.dart';
+import 'package:immich_mobile/domain/services/sync_linked_album.service.dart';
+import 'package:immich_mobile/entities/store.entity.dart';
+import 'package:logging/logging.dart';
+
+Future<void> syncLinkedAlbumsIsolated(ProviderContainer ref) {
+  final user = Store.tryGet(StoreKey.currentUser);
+  if (user == null) {
+    Logger("SyncLinkedAlbum").warning("No user logged in, skipping linked album sync");
+    return Future.value();
+  }
+  return ref.read(syncLinkedAlbumServiceProvider).syncLinkedAlbums(user.id);
+}