migrate actions

This reverts commit c4ac46e1b0.

i18n/en.json

@@ -1462,7 +1462,6 @@
   "move_to_lock_folder_action_prompt": "{count} added to the locked folder",
   "move_to_locked_folder": "Move to locked folder",
   "move_to_locked_folder_confirmation": "These photos and video will be removed from all albums, and only viewable from the locked folder",
-  "move_to_locked_folder_local_ios": "These items will be moved to Recently Deleted but still be available on the Immich server",
   "moved_to_trash": "Moved to trash",
   "mute_memories": "Mute Memories",
   "my_albums": "My albums",

mobile/lib/constants/enums.dart

@@ -15,6 +15,8 @@ enum ActionSource { timeline, viewer }
 
 enum ShareAssetType { original, preview }
 
+enum ButtonPosition { bottomBar, kebabMenu }
+
 enum CleanupStep { selectDate, scan, delete }
 
 enum AssetKeepType { none, photosOnly, videosOnly }

mobile/lib/presentation/actions/asset_debug.action.dart

@@ -17,9 +17,14 @@ class AssetDebugAction extends AssetAction<BaseAsset> {
   @override
   String label(ActionScope scope) => scope.context.t.troubleshoot;
 
+  static bool canShow({required int assetCount, required bool advancedTroubleshooting}) =>
+      assetCount == 1 && advancedTroubleshooting;
+
   @override
-  bool isVisible(ActionScope scope) =>
-      assets.length == 1 && scope.ref.watch(settingsProvider.notifier).get(.advancedTroubleshooting);
+  bool isVisible(ActionScope scope) => canShow(
+    assetCount: assets.length,
+    advancedTroubleshooting: scope.ref.watch(settingsProvider.notifier).get(.advancedTroubleshooting),
+  );
 
   @override
   Future<void> onAction(ActionScope scope) async =>

mobile/lib/presentation/actions/edit_image.action.dart

@@ -0,0 +1,67 @@
+import 'package:auto_route/auto_route.dart';
+import 'package:flutter/material.dart';
+import 'package:immich_mobile/constants/enums.dart';
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/generated/translations.g.dart';
+import 'package:immich_mobile/presentation/actions/action.dart';
+import 'package:immich_mobile/presentation/pages/edit/editor.provider.dart';
+import 'package:immich_mobile/presentation/widgets/images/image_provider.dart';
+import 'package:immich_mobile/providers/infrastructure/action.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/asset.provider.dart';
+import 'package:immich_mobile/providers/routes.provider.dart';
+import 'package:immich_mobile/providers/server_info.provider.dart';
+import 'package:immich_mobile/routing/router.dart';
+import 'package:immich_mobile/utils/semver.dart';
+
+class EditImageAction extends AssetAction<BaseAsset> {
+  const EditImageAction({required super.assets});
+
+  @override
+  IconData get icon => Icons.tune;
+
+  @override
+  String label(ActionScope scope) => scope.context.t.edit;
+
+  static bool canShow({required BaseAsset asset, required bool isInLockedView, required SemVer serverVersion}) =>
+      !isInLockedView &&
+      asset.isEditable &&
+      // edit sync was added in 2.6.0
+      serverVersion >= const SemVer(major: 2, minor: 6, patch: 0);
+
+  @override
+  bool isVisible(ActionScope scope) =>
+      assets.length == 1 &&
+      canShow(
+        asset: assets.first,
+        isInLockedView: scope.ref.watch(inLockedViewProvider),
+        serverVersion: scope.ref.watch(serverInfoProvider.select((state) => state.serverVersion)),
+      );
+
+  @override
+  Future<void> onAction(ActionScope scope) async {
+    final ActionScope(:context, :ref) = scope;
+    final asset = assets.firstOrNull;
+    if (asset == null || asset.remoteId == null) {
+      return;
+    }
+
+    final imageProvider = getFullImageProvider(asset, edited: false);
+    final image = Image(image: imageProvider);
+    final (edits, exifInfo) = await (
+      ref.read(remoteAssetRepositoryProvider).getAssetEdits(asset.remoteId!),
+      ref.read(remoteAssetRepositoryProvider).getExif(asset.remoteId!),
+    ).wait;
+
+    if (exifInfo == null) {
+      return;
+    }
+
+    ref.read(editorStateProvider.notifier).init(edits, exifInfo);
+    await context.pushRoute(
+      DriftEditImageRoute(
+        image: image,
+        applyEdits: (edits) => ref.read(actionProvider.notifier).applyEdits(ActionSource.viewer, edits),
+      ),
+    );
+  }
+}

mobile/lib/presentation/actions/open_activity.action.dart

@@ -0,0 +1,45 @@
+import 'dart:async';
+
+import 'package:auto_route/auto_route.dart';
+import 'package:flutter/material.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/generated/translations.g.dart';
+import 'package:immich_mobile/presentation/actions/action.dart';
+import 'package:immich_mobile/providers/infrastructure/current_album.provider.dart';
+import 'package:immich_mobile/providers/routes.provider.dart';
+import 'package:immich_mobile/routing/router.dart';
+
+class OpenActivityAction extends AssetAction<BaseAsset> {
+  const OpenActivityAction({required super.assets});
+
+  @override
+  IconData get icon => Icons.chat_outlined;
+
+  @override
+  String label(ActionScope scope) => scope.context.t.activity;
+
+  static bool canShow({required bool isInLockedView, required RemoteAlbum? album}) =>
+      !isInLockedView && album != null && album.isActivityEnabled && album.isShared;
+
+  @override
+  bool isVisible(ActionScope scope) => canShow(
+    isInLockedView: scope.ref.watch(inLockedViewProvider),
+    album: scope.ref.watch(currentRemoteAlbumProvider),
+  );
+
+  @override
+  Future<void> onAction(ActionScope scope) async {
+    final album = scope.ref.read(currentRemoteAlbumProvider);
+    final asset = assets.firstOrNull;
+    if (album == null || asset == null) {
+      return;
+    }
+
+    unawaited(
+      scope.context.pushRoute(
+        DriftActivitiesRoute(album: album, assetId: asset is RemoteAsset ? asset.id : null, assetName: asset.name),
+      ),
+    );
+  }
+}

mobile/lib/presentation/widgets/action_buttons/edit_image_action_button.widget.dart

@@ -1,59 +0,0 @@
-import 'dart:async';
-
-import 'package:auto_route/auto_route.dart';
-import 'package:flutter/material.dart';
-import 'package:hooks_riverpod/hooks_riverpod.dart';
-import 'package:immich_mobile/constants/enums.dart';
-import 'package:immich_mobile/domain/models/asset_edit.model.dart';
-import 'package:immich_mobile/extensions/translate_extensions.dart';
-import 'package:immich_mobile/presentation/pages/edit/editor.provider.dart';
-import 'package:immich_mobile/presentation/widgets/action_buttons/base_action_button.widget.dart';
-import 'package:immich_mobile/presentation/widgets/images/image_provider.dart';
-import 'package:immich_mobile/providers/asset_viewer/asset_viewer.provider.dart';
-import 'package:immich_mobile/providers/infrastructure/action.provider.dart';
-import 'package:immich_mobile/providers/infrastructure/asset.provider.dart';
-import 'package:immich_mobile/routing/router.dart';
-
-class EditImageActionButton extends ConsumerWidget {
-  const EditImageActionButton({super.key});
-
-  @override
-  Widget build(BuildContext context, WidgetRef ref) {
-    final currentAsset = ref.watch(assetViewerProvider.select((s) => s.currentAsset));
-
-    Future<void> editImage(List<AssetEdit> edits) async {
-      if (currentAsset == null || currentAsset.remoteId == null) {
-        return;
-      }
-
-      await ref.read(actionProvider.notifier).applyEdits(ActionSource.viewer, edits);
-    }
-
-    Future<void> onPress() async {
-      if (currentAsset == null || currentAsset.remoteId == null) {
-        return;
-      }
-
-      final imageProvider = getFullImageProvider(currentAsset, edited: false);
-
-      final image = Image(image: imageProvider);
-      final (edits, exifInfo) = await (
-        ref.read(remoteAssetRepositoryProvider).getAssetEdits(currentAsset.remoteId!),
-        ref.read(remoteAssetRepositoryProvider).getExif(currentAsset.remoteId!),
-      ).wait;
-
-      if (exifInfo == null) {
-        return;
-      }
-
-      ref.read(editorStateProvider.notifier).init(edits, exifInfo);
-      await context.pushRoute(DriftEditImageRoute(image: image, applyEdits: editImage));
-    }
-
-    return BaseActionButton(
-      iconData: Icons.tune,
-      label: "edit".t(context: context),
-      onPressed: onPress,
-    );
-  }
-}

mobile/lib/presentation/widgets/action_buttons/move_to_lock_folder_action_button.widget.dart

@@ -16,15 +16,11 @@ Future<void> performMoveToLockFolderAction(BuildContext context, WidgetRef ref,
     return;
   }
 
-  final result = await ref.read(actionProvider.notifier).moveToLockFolder(source, context);
-  if (result == null) {
-    return;
-  }
-
   if (source == ActionSource.viewer) {
     EventStream.shared.emit(const ViewerReloadAssetEvent());
   }
 
+  final result = await ref.read(actionProvider.notifier).moveToLockFolder(source);
   ref.read(multiSelectProvider.notifier).reset();
 
   final successMessage = 'move_to_lock_folder_action_prompt'.t(

mobile/lib/presentation/widgets/asset_viewer/bottom_bar.widget.dart

@@ -2,24 +2,18 @@ import 'package:flutter/material.dart';
 import 'package:hooks_riverpod/hooks_riverpod.dart';
 import 'package:immich_mobile/constants/enums.dart';
 import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
-import 'package:immich_mobile/domain/services/timeline.service.dart';
+import 'package:immich_mobile/domain/models/setting.model.dart';
 import 'package:immich_mobile/extensions/build_context_extensions.dart';
-import 'package:immich_mobile/presentation/widgets/action_buttons/add_action_button.widget.dart';
-import 'package:immich_mobile/presentation/widgets/action_buttons/delete_action_button.widget.dart';
-import 'package:immich_mobile/presentation/widgets/action_buttons/delete_local_action_button.widget.dart';
-import 'package:immich_mobile/presentation/widgets/action_buttons/delete_permanent_action_button.widget.dart';
-import 'package:immich_mobile/presentation/widgets/action_buttons/edit_image_action_button.widget.dart';
-import 'package:immich_mobile/presentation/widgets/action_buttons/restore_action_button.widget.dart';
-import 'package:immich_mobile/presentation/widgets/action_buttons/share_action_button.widget.dart';
-import 'package:immich_mobile/presentation/widgets/action_buttons/upload_action_button.widget.dart';
 import 'package:immich_mobile/presentation/widgets/asset_viewer/ocr_toggle_button.widget.dart';
 import 'package:immich_mobile/providers/asset_viewer/asset_viewer.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/current_album.provider.dart';
 import 'package:immich_mobile/providers/infrastructure/readonly_mode.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/setting.provider.dart';
 import 'package:immich_mobile/providers/infrastructure/timeline.provider.dart';
 import 'package:immich_mobile/providers/routes.provider.dart';
 import 'package:immich_mobile/providers/server_info.provider.dart';
 import 'package:immich_mobile/providers/user.provider.dart';
-import 'package:immich_mobile/utils/semver.dart';
+import 'package:immich_mobile/utils/action_button.utils.dart';
 import 'package:immich_mobile/widgets/asset_viewer/video_controls.dart';
 
 class ViewerBottomBar extends ConsumerWidget {
@@ -37,35 +31,31 @@ class ViewerBottomBar extends ConsumerWidget {
     final isOwner = asset is RemoteAsset && asset.ownerId == user?.id;
     final showingDetails = ref.watch(assetViewerProvider.select((s) => s.showingDetails));
     final isInLockedView = ref.watch(inLockedViewProvider);
-    final serverInfo = ref.watch(serverInfoProvider);
-    final isInTrash = ref.read(timelineServiceProvider).origin == TimelineOrigin.trash;
+    final album = ref.watch(currentRemoteAlbumProvider);
+    final isArchived = asset is RemoteAsset && asset.visibility == AssetVisibility.archive;
+    final advancedTroubleshooting = ref.watch(settingsProvider.notifier).get(Setting.advancedTroubleshooting);
+    final timelineOrigin = ref.read(timelineServiceProvider).origin;
+    final isTrashEnabled = ref.watch(serverInfoProvider.select((state) => state.serverFeatures.trash));
+    final serverVersion = ref.watch(serverInfoProvider.select((state) => state.serverVersion));
 
     final originalTheme = context.themeData;
 
-    final actions = <Widget>[
-      if (isInTrash && isOwner && asset.hasRemote)
-        const RestoreActionButton(source: ActionSource.viewer)
-      else
-        const ShareActionButton(source: ActionSource.viewer),
+    final buttonContext = ActionButtonContext(
+      asset: asset,
+      isOwner: isOwner,
+      isArchived: isArchived,
+      isTrashEnabled: isTrashEnabled,
+      isStacked: asset is RemoteAsset && asset.stackId != null,
+      isInLockedView: isInLockedView,
+      currentAlbum: album,
+      advancedTroubleshooting: advancedTroubleshooting,
+      source: ActionSource.viewer,
+      timelineOrigin: timelineOrigin,
+      originalTheme: originalTheme,
+      serverVersion: serverVersion,
+    );
 
-      if (!isInLockedView) ...[
-        if (!isInTrash) ...[
-          if (asset.isLocalOnly) const UploadActionButton(source: ActionSource.viewer),
-          // edit sync was added in 2.6.0
-          if (asset.isEditable && serverInfo.serverVersion >= const SemVer(major: 2, minor: 6, patch: 0))
-            const EditImageActionButton(),
-          if (asset.hasRemote) AddActionButton(originalTheme: originalTheme),
-        ],
-        if (isOwner) ...[
-          if (asset.isLocalOnly)
-            const DeleteLocalActionButton(source: ActionSource.viewer)
-          else if (asset.isTrashed)
-            const DeletePermanentActionButton(source: ActionSource.viewer, useShortLabel: true)
-          else
-            const DeleteActionButton(source: ActionSource.viewer, showConfirmation: true),
-        ],
-      ],
-    ];
+    final actions = ActionButtonBuilder.buildViewerBottomBar(buttonContext, context);
 
     return AnimatedSwitcher(
       duration: Durations.short4,

mobile/lib/presentation/widgets/asset_viewer/viewer_kebab_menu.widget.dart

@@ -31,6 +31,7 @@ class ViewerKebabMenu extends ConsumerWidget {
     final isCasting = ref.watch(castProvider.select((c) => c.isCasting));
     final timelineOrigin = ref.read(timelineServiceProvider).origin;
     final isTrashEnable = ref.watch(serverInfoProvider.select((state) => state.serverFeatures.trash));
+    final serverVersion = ref.watch(serverInfoProvider.select((state) => state.serverVersion));
     final isInLockedView = ref.watch(inLockedViewProvider);
     final currentAlbum = ref.watch(currentRemoteAlbumProvider);
     final isArchived = asset is RemoteAsset && asset.visibility == AssetVisibility.archive;
@@ -48,6 +49,7 @@ class ViewerKebabMenu extends ConsumerWidget {
       source: ActionSource.viewer,
       isCasting: isCasting,
       timelineOrigin: timelineOrigin,
+      serverVersion: serverVersion,
     );
 
     final menuChildren = ActionButtonBuilder.buildViewerKebabMenu(actionContext, context);

mobile/lib/presentation/widgets/asset_viewer/viewer_top_app_bar.widget.dart

@@ -14,7 +14,6 @@ import 'package:immich_mobile/providers/infrastructure/asset_viewer/asset.provid
 import 'package:immich_mobile/providers/infrastructure/current_album.provider.dart';
 import 'package:immich_mobile/providers/infrastructure/readonly_mode.provider.dart';
 import 'package:immich_mobile/providers/routes.provider.dart';
-import 'package:immich_mobile/routing/router.dart';
 import 'package:immich_mobile/utils/timezone.dart';
 import 'package:immich_ui/immich_ui.dart';
 
@@ -47,20 +46,6 @@ class ViewerTopAppBar extends ConsumerWidget implements PreferredSizeWidget {
 
     final actions = <Widget>[
       if (asset.isMotionPhoto) const MotionPhotoActionButton(iconOnly: true),
-      if (album != null && album.isActivityEnabled && album.isShared)
-        IconButton(
-          icon: const Icon(Icons.chat_outlined),
-          onPressed: () {
-            context.router.push(
-              DriftActivitiesRoute(
-                album: album,
-                assetId: asset is RemoteAsset ? asset.id : null,
-                assetName: asset.name,
-              ),
-            );
-          },
-        ),
-
       ActionIconButtonWidget(action: FavoriteAction(assets: assetForAction)),
 
       ViewerKebabMenu(originalTheme: originalTheme),

mobile/lib/providers/infrastructure/action.provider.dart

@@ -10,7 +10,6 @@ import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
 import 'package:immich_mobile/domain/models/asset_edit.model.dart';
 import 'package:immich_mobile/domain/services/asset.service.dart';
 import 'package:immich_mobile/domain/services/remote_album.service.dart';
-import 'package:immich_mobile/extensions/platform_extensions.dart';
 import 'package:immich_mobile/models/download/livephotos_medatada.model.dart';
 import 'package:immich_mobile/providers/asset_viewer/asset_viewer.provider.dart';
 import 'package:immich_mobile/providers/backup/asset_upload_progress.provider.dart';
@@ -28,7 +27,6 @@ import 'package:immich_mobile/services/download.service.dart';
 import 'package:immich_mobile/services/foreground_upload.service.dart';
 import 'package:immich_mobile/utils/semver.dart';
 import 'package:immich_mobile/widgets/asset_grid/delete_dialog.dart';
-import 'package:immich_mobile/widgets/common/confirm_dialog.dart';
 import 'package:logging/logging.dart';
 import 'package:openapi/api.dart';
 
@@ -202,24 +200,9 @@ class ActionNotifier extends Notifier<void> {
     }
   }
 
-  Future<ActionResult?> moveToLockFolder(ActionSource source, BuildContext context) async {
+  Future<ActionResult> moveToLockFolder(ActionSource source) async {
     final ids = _getOwnedRemoteIdsForSource(source);
     final localIds = _getLocalIdsForSource(source, ignoreLocalOnly: true);
-
-    if (localIds.isNotEmpty) {
-      final confirmed = await showDialog<bool>(
-        context: context,
-        builder: (_) => ConfirmDialog(
-          title: "move_to_locked_folder",
-          content: CurrentPlatform.isAndroid ? "delete_dialog_alert_local" : "move_to_locked_folder_local_ios",
-          ok: "confirm",
-        ),
-      );
-      if (confirmed != true) {
-        return null;
-      }
-    }
-
     try {
       await _service.moveToLockFolder(ids, localIds);
       return ActionResult(count: ids.length, success: true);

mobile/lib/repositories/asset_media.repository.dart

@@ -45,9 +45,9 @@ class AssetMediaRepository {
     return false;
   }
 
-  Future<List<String>> deleteAll(List<String> ids, {bool trash = true}) async {
+  Future<List<String>> deleteAll(List<String> ids) async {
     if (CurrentPlatform.isAndroid) {
-      if (trash && await _androidSupportsTrash()) {
+      if (await _androidSupportsTrash()) {
         return PhotoManager.editor.android.moveToTrash(
           ids.map((e) => AssetEntity(id: e, width: 1, height: 1, typeInt: 0)).toList(),
         );

mobile/lib/services/action.service.dart

@@ -92,9 +92,9 @@ class ActionService {
     await _assetApiRepository.updateVisibility(remoteIds, AssetVisibilityEnum.locked);
     await _remoteAssetRepository.updateVisibility(remoteIds, AssetVisibility.locked);
 
-    // Locked assets stay on the server, so permanently delete the local copies instead of trashing them
+    // Ask user if they want to delete local copies
     if (localIds.isNotEmpty) {
-      await _deleteLocalAssets(localIds, trash: false);
+      await _deleteLocalAssets(localIds);
     }
   }
 
@@ -313,12 +313,12 @@ class ActionService {
     }
   }
 
-  Future<int> _deleteLocalAssets(List<String> localIds, {bool trash = true}) async {
-    final deletedIds = await _assetMediaRepository.deleteAll(localIds, trash: trash);
+  Future<int> _deleteLocalAssets(List<String> localIds) async {
+    final deletedIds = await _assetMediaRepository.deleteAll(localIds);
     if (deletedIds.isEmpty) {
       return 0;
     }
-    if (trash && CurrentPlatform.isAndroid && Store.get(StoreKey.manageLocalMediaAndroid, false)) {
+    if (CurrentPlatform.isAndroid && Store.get(StoreKey.manageLocalMediaAndroid, false)) {
       await _trashedLocalAssetRepository.applyTrashedAssets(deletedIds);
     } else {
       await _localAssetRepository.delete(deletedIds);

mobile/lib/utils/action_button.utils.dart

@@ -9,6 +9,9 @@ import 'package:immich_mobile/domain/services/timeline.service.dart';
 import 'package:immich_mobile/domain/utils/event_stream.dart';
 import 'package:immich_mobile/presentation/actions/action.widget.dart';
 import 'package:immich_mobile/presentation/actions/asset_debug.action.dart';
+import 'package:immich_mobile/presentation/actions/edit_image.action.dart';
+import 'package:immich_mobile/presentation/actions/open_activity.action.dart';
+import 'package:immich_mobile/utils/semver.dart';
 import 'package:immich_mobile/presentation/widgets/action_buttons/archive_action_button.widget.dart';
 import 'package:immich_mobile/presentation/widgets/action_buttons/base_action_button.widget.dart';
 import 'package:immich_mobile/presentation/widgets/action_buttons/cast_action_button.widget.dart';
@@ -16,6 +19,7 @@ import 'package:immich_mobile/presentation/widgets/action_buttons/delete_action_
 import 'package:immich_mobile/presentation/widgets/action_buttons/delete_local_action_button.widget.dart';
 import 'package:immich_mobile/presentation/widgets/action_buttons/delete_permanent_action_button.widget.dart';
 import 'package:immich_mobile/presentation/widgets/action_buttons/download_action_button.widget.dart';
+import 'package:immich_mobile/presentation/widgets/action_buttons/add_action_button.widget.dart';
 import 'package:immich_mobile/presentation/widgets/action_buttons/like_activity_action_button.widget.dart';
 import 'package:immich_mobile/presentation/widgets/action_buttons/move_to_lock_folder_action_button.widget.dart';
 import 'package:immich_mobile/presentation/widgets/action_buttons/open_in_browser_action_button.widget.dart';
@@ -47,6 +51,8 @@ class ActionButtonContext {
   final bool isCasting;
   final TimelineOrigin timelineOrigin;
   final int selectedCount;
+  final ThemeData? originalTheme;
+  final SemVer serverVersion;
 
   const ActionButtonContext({
     required this.asset,
@@ -61,13 +67,17 @@ class ActionButtonContext {
     this.isCasting = false,
     this.timelineOrigin = TimelineOrigin.main,
     this.selectedCount = 1,
+    this.originalTheme,
+    this.serverVersion = const SemVer(major: 0, minor: 0, patch: 0),
   });
 }
 
 enum ActionButtonType {
   openInfo,
+  openActivity,
   likeActivity,
   share,
+  editImage,
   shareLink,
   cast,
   setAlbumCover,
@@ -89,11 +99,22 @@ enum ActionButtonType {
   deleteLocal,
   deletePermanent,
   delete,
+  addTo,
   advancedInfo;
 
+  bool _isInActivityAlbum(ActionButtonContext context) {
+    return !context.isInLockedView &&
+        context.currentAlbum != null &&
+        context.currentAlbum!.isActivityEnabled &&
+        context.currentAlbum!.isShared;
+  }
+
   bool shouldShow(ActionButtonContext context) {
     return switch (this) {
-      ActionButtonType.advancedInfo => context.advancedTroubleshooting,
+      ActionButtonType.advancedInfo => AssetDebugAction.canShow(
+        assetCount: context.selectedCount,
+        advancedTroubleshooting: context.advancedTroubleshooting,
+      ),
       ActionButtonType.share => true,
       ActionButtonType.shareLink =>
         !context.isInLockedView && //
@@ -159,11 +180,7 @@ enum ActionButtonType {
             !context.isInLockedView && //
             context.isStacked,
       ActionButtonType.openInBrowser => context.asset.hasRemote && !context.isInLockedView,
-      ActionButtonType.likeActivity =>
-        !context.isInLockedView &&
-            context.currentAlbum != null &&
-            context.currentAlbum!.isActivityEnabled &&
-            context.currentAlbum!.isShared,
+      ActionButtonType.likeActivity => _isInActivityAlbum(context),
       ActionButtonType.similarPhotos =>
         !context.isInLockedView && //
             context.asset is RemoteAsset,
@@ -181,10 +198,29 @@ enum ActionButtonType {
             context.timelineOrigin != TimelineOrigin.localAlbum &&
             context.isOwner,
       ActionButtonType.cast => context.isCasting || context.asset.hasRemote,
+      ActionButtonType.editImage => EditImageAction.canShow(
+        asset: context.asset,
+        isInLockedView: context.isInLockedView,
+        serverVersion: context.serverVersion,
+      ),
+      ActionButtonType.addTo =>
+        !context.isInLockedView && //
+            context.asset.hasRemote,
+      ActionButtonType.openActivity => OpenActivityAction.canShow(
+        isInLockedView: context.isInLockedView,
+        album: context.currentAlbum,
+      ),
       ActionButtonType.slideshow => true,
     };
   }
 
+  bool showsAt(ButtonPosition position, ActionButtonContext context) => switch (this) {
+    ActionButtonType.openActivity || ActionButtonType.likeActivity =>
+      position != ButtonPosition.bottomBar || context.timelineOrigin != TimelineOrigin.trash,
+    ActionButtonType.editImage => position != ButtonPosition.bottomBar || context.currentAlbum?.isShared != true,
+    _ => true,
+  };
+
   Widget buildButton(
     ActionButtonContext context, [
     BuildContext? buildContext,
@@ -217,8 +253,14 @@ enum ActionButtonType {
         source: context.source,
         iconOnly: iconOnly,
         menuItem: menuItem,
+        useShortLabel: false,
+      ),
+      ActionButtonType.delete => DeleteActionButton(
+        source: context.source,
+        iconOnly: iconOnly,
+        menuItem: menuItem,
+        showConfirmation: true,
       ),
-      ActionButtonType.delete => DeleteActionButton(source: context.source, iconOnly: iconOnly, menuItem: menuItem),
       ActionButtonType.moveToLockFolder => MoveToLockFolderActionButton(
         source: context.source,
         iconOnly: iconOnly,
@@ -284,6 +326,15 @@ enum ActionButtonType {
               },
       ),
       ActionButtonType.cast => CastActionButton(iconOnly: iconOnly, menuItem: menuItem),
+      ActionButtonType.editImage when menuItem => ActionMenuItemWidget(
+        action: EditImageAction(assets: [context.asset]),
+      ),
+      ActionButtonType.editImage => ActionColumnButtonWidget(action: EditImageAction(assets: [context.asset])),
+      ActionButtonType.addTo => AddActionButton(originalTheme: context.originalTheme),
+      ActionButtonType.openActivity when menuItem => ActionMenuItemWidget(
+        action: OpenActivityAction(assets: [context.asset]),
+      ),
+      ActionButtonType.openActivity => ActionColumnButtonWidget(action: OpenActivityAction(assets: [context.asset])),
     };
   }
 
@@ -315,34 +366,62 @@ enum ActionButtonType {
 class ActionButtonBuilder {
   static const List<ActionButtonType> _actionTypes = ActionButtonType.values;
   static const List<ActionButtonType> defaultViewerKebabMenuOrder = _actionTypes;
-  static const Set<ActionButtonType> defaultViewerBottomBarButtons = {
+  static const List<ActionButtonType> _defaultViewerBottomBarOrder = [
     ActionButtonType.share,
-    ActionButtonType.moveToLockFolder,
     ActionButtonType.upload,
-    ActionButtonType.delete,
-    ActionButtonType.archive,
-    ActionButtonType.unarchive,
+    ActionButtonType.editImage,
+    ActionButtonType.addTo,
+    ActionButtonType.openActivity,
+    ActionButtonType.likeActivity,
+    ActionButtonType.removeFromLockFolder,
     ActionButtonType.restoreTrash,
     ActionButtonType.deletePermanent,
-  };
+    ActionButtonType.delete,
+    ActionButtonType.deleteLocal,
+  ];
 
   static List<Widget> build(ActionButtonContext context) {
     return _actionTypes.where((type) => type.shouldShow(context)).map((type) => type.buildButton(context)).toList();
   }
 
-  static List<Widget> buildViewerKebabMenu(ActionButtonContext context, BuildContext buildContext) {
-    final visibleButtons = defaultViewerKebabMenuOrder
-        .where((type) => !defaultViewerBottomBarButtons.contains(type) && type.shouldShow(context))
+  static List<ActionButtonType> getViewerBottomBarTypes(ActionButtonContext context) {
+    return _defaultViewerBottomBarOrder
+        .where((type) => type.shouldShow(context) && type.showsAt(ButtonPosition.bottomBar, context))
+        .take(4)
         .toList();
+  }
 
-    if (visibleButtons.isEmpty) {
+  static List<ActionButtonType> getViewerKebabMenuTypes(ActionButtonContext context) {
+    final inBottomBar = getViewerBottomBarTypes(context).toSet();
+    return defaultViewerKebabMenuOrder
+        .where(
+          (type) =>
+              !inBottomBar.contains(type) &&
+              type.shouldShow(context) &&
+              type.showsAt(ButtonPosition.kebabMenu, context),
+        )
+        .toList();
+  }
+
+  static List<Widget> buildViewerKebabMenu(ActionButtonContext context, BuildContext buildContext) {
+    return getViewerKebabMenuTypes(context).toKebabMenuWidgets(context, buildContext);
+  }
+
+  static List<Widget> buildViewerBottomBar(ActionButtonContext context, BuildContext buildContext) {
+    return getViewerBottomBarTypes(context).toBottomBarWidgets(context, buildContext);
+  }
+}
+
+extension ActionButtonTypeListExtension on List<ActionButtonType> {
+  List<Widget> toKebabMenuWidgets(ActionButtonContext context, BuildContext buildContext) {
+    if (isEmpty) {
       return [];
     }
 
     final List<Widget> result = [];
     int? lastGroup;
 
-    for (final type in visibleButtons) {
+    for (final type in this) {
       if (lastGroup != null && type.kebabMenuGroup != lastGroup) {
         result.add(const Divider(height: 1));
       }
@@ -352,4 +431,8 @@ class ActionButtonBuilder {
 
     return result;
   }
+
+  List<Widget> toBottomBarWidgets(ActionButtonContext context, BuildContext buildContext) {
+    return map((type) => type.buildButton(context, buildContext, false, false)).toList();
+  }
 }

mobile/test/services/action.service_test.dart

@@ -2,8 +2,6 @@ import 'package:drift/drift.dart' as drift;
 import 'package:drift/native.dart';
 import 'package:flutter/foundation.dart';
 import 'package:flutter_test/flutter_test.dart';
-import 'package:immich_mobile/constants/enums.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/domain/services/store.service.dart';
 import 'package:immich_mobile/entities/store.entity.dart';
@@ -149,13 +147,13 @@ void main() {
       await Store.put(StoreKey.manageLocalMediaAndroid, true);
       const ids = ['a', 'b'];
 
-      when(() => assetMediaRepository.deleteAll(ids, trash: true)).thenAnswer((_) async => ids);
+      when(() => assetMediaRepository.deleteAll(ids)).thenAnswer((_) async => ids);
       when(() => trashedLocalAssetRepository.applyTrashedAssets(ids)).thenAnswer((_) async {});
 
       final result = await sut.deleteLocal(ids);
 
       expect(result, ids.length);
-      verify(() => assetMediaRepository.deleteAll(ids, trash: true)).called(1);
+      verify(() => assetMediaRepository.deleteAll(ids)).called(1);
       verify(() => trashedLocalAssetRepository.applyTrashedAssets(ids)).called(1);
       verifyNever(() => localAssetRepository.delete(any()));
     });
@@ -164,13 +162,13 @@ void main() {
       await Store.put(StoreKey.manageLocalMediaAndroid, false);
       const ids = ['c'];
 
-      when(() => assetMediaRepository.deleteAll(ids, trash: true)).thenAnswer((_) async => ids);
+      when(() => assetMediaRepository.deleteAll(ids)).thenAnswer((_) async => ids);
       when(() => localAssetRepository.delete(ids)).thenAnswer((_) async {});
 
       final result = await sut.deleteLocal(ids);
 
       expect(result, ids.length);
-      verify(() => assetMediaRepository.deleteAll(ids, trash: true)).called(1);
+      verify(() => assetMediaRepository.deleteAll(ids)).called(1);
       verify(() => localAssetRepository.delete(ids)).called(1);
       verifyNever(() => trashedLocalAssetRepository.applyTrashedAssets(any()));
     });
@@ -179,46 +177,14 @@ void main() {
       await Store.put(StoreKey.manageLocalMediaAndroid, true);
       const ids = ['x'];
 
-      when(() => assetMediaRepository.deleteAll(ids, trash: true)).thenAnswer((_) async => <String>[]);
+      when(() => assetMediaRepository.deleteAll(ids)).thenAnswer((_) async => <String>[]);
 
       final result = await sut.deleteLocal(ids);
 
       expect(result, 0);
-      verify(() => assetMediaRepository.deleteAll(ids, trash: true)).called(1);
+      verify(() => assetMediaRepository.deleteAll(ids)).called(1);
       verifyNever(() => trashedLocalAssetRepository.applyTrashedAssets(any()));
       verifyNever(() => localAssetRepository.delete(any()));
     });
   });
-
-  group('ActionService.moveToLockFolder', () {
-    const remoteIds = ['r1', 'r2'];
-    const localIds = ['l1', 'l2'];
-
-    test('permanently deletes local copies without trashing, even when Android trash handling is on', () async {
-      await Store.put(StoreKey.manageLocalMediaAndroid, true);
-
-      when(() => assetApiRepository.updateVisibility(remoteIds, AssetVisibilityEnum.locked)).thenAnswer((_) async {});
-      when(() => remoteAssetRepository.updateVisibility(remoteIds, AssetVisibility.locked)).thenAnswer((_) async {});
-      when(() => assetMediaRepository.deleteAll(localIds, trash: false)).thenAnswer((_) async => localIds);
-      when(() => localAssetRepository.delete(localIds)).thenAnswer((_) async {});
-
-      await sut.moveToLockFolder(remoteIds, localIds);
-
-      verify(() => assetApiRepository.updateVisibility(remoteIds, AssetVisibilityEnum.locked)).called(1);
-      verify(() => remoteAssetRepository.updateVisibility(remoteIds, AssetVisibility.locked)).called(1);
-      verify(() => assetMediaRepository.deleteAll(localIds, trash: false)).called(1);
-      verify(() => localAssetRepository.delete(localIds)).called(1);
-      verifyNever(() => trashedLocalAssetRepository.applyTrashedAssets(any()));
-    });
-
-    test('locks remote assets without touching local media when there are no local copies', () async {
-      when(() => assetApiRepository.updateVisibility(remoteIds, AssetVisibilityEnum.locked)).thenAnswer((_) async {});
-      when(() => remoteAssetRepository.updateVisibility(remoteIds, AssetVisibility.locked)).thenAnswer((_) async {});
-
-      await sut.moveToLockFolder(remoteIds, const []);
-
-      verify(() => assetApiRepository.updateVisibility(remoteIds, AssetVisibilityEnum.locked)).called(1);
-      verifyNever(() => assetMediaRepository.deleteAll(any(), trash: any(named: 'trash')));
-    });
-  });
 }

mobile/test/unit/factories/remote_album_factory.dart

@@ -0,0 +1,25 @@
+import 'package:immich_mobile/domain/models/album/album.model.dart';
+
+import '../../utils.dart';
+
+class RemoteAlbumFactory {
+  const RemoteAlbumFactory();
+
+  static RemoteAlbum create({String? id, String? ownerId, bool isActivityEnabled = false, bool isShared = false}) {
+    id = TestUtils.uuid(id);
+
+    return RemoteAlbum(
+      id: id,
+      name: 'album_$id',
+      ownerId: TestUtils.uuid(ownerId),
+      description: '',
+      createdAt: TestUtils.yesterday(),
+      updatedAt: TestUtils.now(),
+      isActivityEnabled: isActivityEnabled,
+      order: AlbumAssetOrder.desc,
+      assetCount: 1,
+      ownerName: 'owner',
+      isShared: isShared,
+    );
+  }
+}

mobile/test/unit/presentation/actions/edit_image_action_test.dart

@@ -0,0 +1,113 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:immich_mobile/models/server_info/server_version.model.dart';
+import 'package:immich_mobile/presentation/actions/action.widget.dart';
+import 'package:immich_mobile/presentation/actions/edit_image.action.dart';
+import 'package:immich_mobile/providers/routes.provider.dart';
+import 'package:immich_mobile/providers/server_info.provider.dart';
+import 'package:immich_mobile/services/server_info.service.dart';
+import 'package:immich_mobile/utils/semver.dart';
+import 'package:immich_ui/immich_ui.dart';
+import 'package:mocktail/mocktail.dart';
+
+import '../../factories/local_asset_factory.dart';
+import '../../factories/remote_asset_factory.dart';
+import '../presentation_context.dart';
+
+class _MockServerInfoService extends Mock implements ServerInfoService {}
+
+class _StubServerInfoNotifier extends ServerInfoNotifier {
+  _StubServerInfoNotifier(ServerVersion version) : super(_MockServerInfoService()) {
+    state = state.copyWith(serverVersion: version);
+  }
+}
+
+void main() {
+  late PresentationContext context;
+
+  const editCapableVersion = ServerVersion(major: 2, minor: 6, patch: 0);
+
+  setUp(() async {
+    context = await PresentationContext.create();
+  });
+
+  tearDown(() {
+    context.dispose();
+  });
+
+  Future<void> pumpAction(
+    WidgetTester tester,
+    EditImageAction action, {
+    ServerVersion serverVersion = editCapableVersion,
+    bool isInLockedView = false,
+  }) async {
+    await tester.pumpTestWidget(
+      context,
+      ActionIconButtonWidget(action: action),
+      overrides: [
+        serverInfoProvider.overrideWith((ref) => _StubServerInfoNotifier(serverVersion)),
+        inLockedViewProvider.overrideWith((ref) => isInLockedView),
+      ],
+    );
+  }
+
+  group('EditImageAction', () {
+    testWidgets('visible for an editable remote asset on a capable server', (tester) async {
+      await pumpAction(tester, EditImageAction(assets: [RemoteAssetFactory.create()]));
+
+      expect(find.byType(ImmichIconButton), findsOneWidget);
+    });
+
+    testWidgets('hidden for a local-only asset', (tester) async {
+      await pumpAction(tester, EditImageAction(assets: [LocalAssetFactory.create()]));
+
+      expect(find.byType(ImmichIconButton), findsNothing);
+    });
+
+    testWidgets('hidden when the server is older than 2.6.0', (tester) async {
+      await pumpAction(
+        tester,
+        EditImageAction(assets: [RemoteAssetFactory.create()]),
+        serverVersion: const ServerVersion(major: 2, minor: 5, patch: 9),
+      );
+
+      expect(find.byType(ImmichIconButton), findsNothing);
+    });
+
+    testWidgets('hidden in the locked view', (tester) async {
+      await pumpAction(tester, EditImageAction(assets: [RemoteAssetFactory.create()]), isInLockedView: true);
+
+      expect(find.byType(ImmichIconButton), findsNothing);
+    });
+
+    testWidgets('hidden for multiple assets', (tester) async {
+      await pumpAction(tester, EditImageAction(assets: [RemoteAssetFactory.create(), RemoteAssetFactory.create()]));
+
+      expect(find.byType(ImmichIconButton), findsNothing);
+    });
+  });
+
+  group('EditImageAction.canShow', () {
+    test('requires an editable asset, no locked view, and server >= 2.6.0', () {
+      final asset = RemoteAssetFactory.create();
+
+      expect(EditImageAction.canShow(asset: asset, isInLockedView: false, serverVersion: editCapableVersion), isTrue);
+      expect(EditImageAction.canShow(asset: asset, isInLockedView: true, serverVersion: editCapableVersion), isFalse);
+      expect(
+        EditImageAction.canShow(
+          asset: asset,
+          isInLockedView: false,
+          serverVersion: const SemVer(major: 2, minor: 5, patch: 9),
+        ),
+        isFalse,
+      );
+      expect(
+        EditImageAction.canShow(
+          asset: LocalAssetFactory.create(),
+          isInLockedView: false,
+          serverVersion: editCapableVersion,
+        ),
+        isFalse,
+      );
+    });
+  });
+}

mobile/test/unit/presentation/actions/open_activity_action_test.dart

@@ -0,0 +1,86 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/album/album.model.dart';
+import 'package:immich_mobile/presentation/actions/action.widget.dart';
+import 'package:immich_mobile/presentation/actions/open_activity.action.dart';
+import 'package:immich_mobile/providers/infrastructure/current_album.provider.dart';
+import 'package:immich_mobile/providers/routes.provider.dart';
+import 'package:immich_ui/immich_ui.dart';
+
+import '../../factories/remote_album_factory.dart';
+import '../../factories/remote_asset_factory.dart';
+import '../presentation_context.dart';
+
+class _StubAlbumNotifier extends CurrentAlbumNotifier {
+  _StubAlbumNotifier(this.album);
+
+  final RemoteAlbum? album;
+
+  @override
+  RemoteAlbum? build() => album;
+}
+
+void main() {
+  late PresentationContext context;
+
+  setUp(() async {
+    context = await PresentationContext.create();
+  });
+
+  tearDown(() {
+    context.dispose();
+  });
+
+  Future<void> pumpAction(
+    WidgetTester tester, {
+    RemoteAlbum? album,
+    bool isInLockedView = false,
+    List<Override> overrides = const [],
+  }) async {
+    await tester.pumpTestWidget(
+      context,
+      ActionIconButtonWidget(action: OpenActivityAction(assets: [RemoteAssetFactory.create()])),
+      overrides: [
+        currentRemoteAlbumProvider.overrideWith(() => _StubAlbumNotifier(album)),
+        inLockedViewProvider.overrideWith((ref) => isInLockedView),
+        ...overrides,
+      ],
+    );
+  }
+
+  group('OpenActivityAction', () {
+    testWidgets('visible in a shared album with activity enabled', (tester) async {
+      await pumpAction(tester, album: RemoteAlbumFactory.create(isShared: true, isActivityEnabled: true));
+
+      expect(find.byType(ImmichIconButton), findsOneWidget);
+    });
+
+    testWidgets('hidden when there is no current album', (tester) async {
+      await pumpAction(tester, album: null);
+
+      expect(find.byType(ImmichIconButton), findsNothing);
+    });
+
+    testWidgets('hidden when the album is not shared', (tester) async {
+      await pumpAction(tester, album: RemoteAlbumFactory.create(isShared: false, isActivityEnabled: true));
+
+      expect(find.byType(ImmichIconButton), findsNothing);
+    });
+
+    testWidgets('hidden when activity is disabled', (tester) async {
+      await pumpAction(tester, album: RemoteAlbumFactory.create(isShared: true, isActivityEnabled: false));
+
+      expect(find.byType(ImmichIconButton), findsNothing);
+    });
+
+    testWidgets('hidden in the locked view', (tester) async {
+      await pumpAction(
+        tester,
+        album: RemoteAlbumFactory.create(isShared: true, isActivityEnabled: true),
+        isInLockedView: true,
+      );
+
+      expect(find.byType(ImmichIconButton), findsNothing);
+    });
+  });
+}

mobile/test/utils_legacy/action_button_utils_test.dart

@@ -5,6 +5,7 @@ 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/services/timeline.service.dart';
 import 'package:immich_mobile/utils/action_button.utils.dart';
+import 'package:immich_mobile/utils/semver.dart';
 
 LocalAsset createLocalAsset({
   String? remoteId,
@@ -1238,4 +1239,438 @@ void main() {
       expect(nonArchivedWidgets, isNotEmpty);
     });
   });
+
+  group('ActionButtonBuilder.getViewerBottomBarTypes', () {
+    test('should return correct button types for shared album with activity', () {
+      final remoteAsset = createRemoteAsset();
+      final album = createRemoteAlbum(isActivityEnabled: true, isShared: true);
+      final context = ActionButtonContext(
+        asset: remoteAsset,
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: true,
+        isInLockedView: false,
+        currentAlbum: album,
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+      );
+
+      const expectedTypes = [
+        ActionButtonType.share,
+        ActionButtonType.addTo,
+        ActionButtonType.openActivity,
+        ActionButtonType.likeActivity,
+      ];
+
+      final bottomBarTypes = ActionButtonBuilder.getViewerBottomBarTypes(context);
+      final kebabTypes = ActionButtonBuilder.getViewerKebabMenuTypes(context);
+
+      expect(bottomBarTypes, expectedTypes);
+      expect(bottomBarTypes.any(kebabTypes.contains), isFalse);
+    });
+
+    test('should return correct button types for local only asset', () {
+      final localAsset = createLocalAsset();
+      final context = ActionButtonContext(
+        asset: localAsset,
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: true,
+        isInLockedView: false,
+        currentAlbum: null,
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+        serverVersion: const SemVer(major: 2, minor: 6, patch: 0),
+      );
+
+      const expectedTypes = [ActionButtonType.share, ActionButtonType.upload, ActionButtonType.deleteLocal];
+
+      final bottomBarTypes = ActionButtonBuilder.getViewerBottomBarTypes(context);
+      final kebabTypes = ActionButtonBuilder.getViewerKebabMenuTypes(context);
+
+      expect(bottomBarTypes, expectedTypes);
+      expect(bottomBarTypes.any(kebabTypes.contains), isFalse);
+    });
+
+    test('should return correct button types for locked view', () {
+      final remoteAsset = createRemoteAsset();
+      final context = ActionButtonContext(
+        asset: remoteAsset,
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: false,
+        isInLockedView: true,
+        currentAlbum: null,
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+      );
+
+      const expectedTypes = [
+        ActionButtonType.share,
+        ActionButtonType.removeFromLockFolder,
+        ActionButtonType.deletePermanent,
+      ];
+
+      final bottomBarTypes = ActionButtonBuilder.getViewerBottomBarTypes(context);
+      final kebabTypes = ActionButtonBuilder.getViewerKebabMenuTypes(context);
+
+      expect(bottomBarTypes, expectedTypes);
+      expect(bottomBarTypes.any(kebabTypes.contains), isFalse);
+    });
+
+    test('should return correct button types for remote only asset', () {
+      final remoteAsset = createRemoteAsset();
+      final context = ActionButtonContext(
+        asset: remoteAsset,
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: true,
+        isInLockedView: false,
+        currentAlbum: null,
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+        serverVersion: const SemVer(major: 2, minor: 6, patch: 0),
+      );
+
+      const expectedTypes = [
+        ActionButtonType.share,
+        ActionButtonType.editImage,
+        ActionButtonType.addTo,
+        ActionButtonType.delete,
+      ];
+
+      final bottomBarTypes = ActionButtonBuilder.getViewerBottomBarTypes(context);
+      final kebabTypes = ActionButtonBuilder.getViewerKebabMenuTypes(context);
+
+      expect(bottomBarTypes, expectedTypes);
+      expect(bottomBarTypes.any(kebabTypes.contains), isFalse);
+    });
+
+    test('trashed asset (no album) keeps restore and permanent delete in bottom bar', () {
+      final remoteAsset = createRemoteAsset(deletedAt: DateTime.now());
+      final context = ActionButtonContext(
+        asset: remoteAsset,
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: true,
+        isInLockedView: false,
+        currentAlbum: null,
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+        timelineOrigin: TimelineOrigin.trash,
+      );
+
+      const expectedTypes = [
+        ActionButtonType.share,
+        ActionButtonType.addTo,
+        ActionButtonType.restoreTrash,
+        ActionButtonType.deletePermanent,
+      ];
+
+      expect(ActionButtonBuilder.getViewerBottomBarTypes(context), expectedTypes);
+    });
+
+    test('trashed asset in shared activity album still surfaces restore and permanent delete', () {
+      final remoteAsset = createRemoteAsset(deletedAt: DateTime.now());
+      final album = createRemoteAlbum(isActivityEnabled: true, isShared: true);
+      final context = ActionButtonContext(
+        asset: remoteAsset,
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: true,
+        isInLockedView: false,
+        currentAlbum: album,
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+        timelineOrigin: TimelineOrigin.trash,
+      );
+
+      final bottomBarTypes = ActionButtonBuilder.getViewerBottomBarTypes(context);
+
+      expect(bottomBarTypes, contains(ActionButtonType.restoreTrash));
+      expect(bottomBarTypes, contains(ActionButtonType.deletePermanent));
+      expect(bottomBarTypes, isNot(contains(ActionButtonType.openActivity)));
+      expect(bottomBarTypes, isNot(contains(ActionButtonType.likeActivity)));
+    });
+
+    test('5th bottom-bar candidate overflows into the kebab', () {
+      final remoteAsset = createRemoteAsset();
+      final album = createRemoteAlbum(isActivityEnabled: true, isShared: true);
+      final context = ActionButtonContext(
+        asset: remoteAsset,
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: true,
+        isInLockedView: false,
+        currentAlbum: album,
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+        serverVersion: const SemVer(major: 2, minor: 6, patch: 0),
+      );
+
+      final bottomBarTypes = ActionButtonBuilder.getViewerBottomBarTypes(context);
+      final kebabTypes = ActionButtonBuilder.getViewerKebabMenuTypes(context);
+
+      expect(bottomBarTypes.length, 4);
+      expect(bottomBarTypes, isNot(contains(ActionButtonType.delete)));
+      expect(kebabTypes, contains(ActionButtonType.delete));
+    });
+  });
+
+  group('ActionButtonType.shouldShow editImage button', () {
+    final editableRemote = createRemoteAsset();
+
+    test('should show for editable remote asset on a recent server', () {
+      final context = ActionButtonContext(
+        asset: editableRemote,
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: true,
+        isInLockedView: false,
+        currentAlbum: null,
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+        serverVersion: const SemVer(major: 2, minor: 6, patch: 0),
+      );
+
+      expect(ActionButtonType.editImage.shouldShow(context), isTrue);
+    });
+
+    test('should not show when local-only (LocalAsset is not editable)', () {
+      final context = ActionButtonContext(
+        asset: createLocalAsset(),
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: true,
+        isInLockedView: false,
+        currentAlbum: null,
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+        serverVersion: const SemVer(major: 2, minor: 6, patch: 0),
+      );
+
+      expect(ActionButtonType.editImage.shouldShow(context), isFalse);
+    });
+
+    test('should not show when server version is below 2.6', () {
+      final context = ActionButtonContext(
+        asset: editableRemote,
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: true,
+        isInLockedView: false,
+        currentAlbum: null,
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+        serverVersion: const SemVer(major: 2, minor: 5, patch: 9),
+      );
+
+      expect(ActionButtonType.editImage.shouldShow(context), isFalse);
+    });
+
+    test('should not show in locked view', () {
+      final context = ActionButtonContext(
+        asset: editableRemote,
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: true,
+        isInLockedView: true,
+        currentAlbum: null,
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+        serverVersion: const SemVer(major: 2, minor: 6, patch: 0),
+      );
+
+      expect(ActionButtonType.editImage.shouldShow(context), isFalse);
+    });
+  });
+
+  group('ActionButtonType.shouldShow addTo button', () {
+    test('should show when not locked and asset has remote', () {
+      final context = ActionButtonContext(
+        asset: createRemoteAsset(),
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: true,
+        isInLockedView: false,
+        currentAlbum: null,
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+      );
+
+      expect(ActionButtonType.addTo.shouldShow(context), isTrue);
+    });
+
+    test('should not show in locked view', () {
+      final context = ActionButtonContext(
+        asset: createRemoteAsset(),
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: true,
+        isInLockedView: true,
+        currentAlbum: null,
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+      );
+
+      expect(ActionButtonType.addTo.shouldShow(context), isFalse);
+    });
+
+    test('should not show for local-only asset', () {
+      final context = ActionButtonContext(
+        asset: createLocalAsset(),
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: true,
+        isInLockedView: false,
+        currentAlbum: null,
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+      );
+
+      expect(ActionButtonType.addTo.shouldShow(context), isFalse);
+    });
+  });
+
+  group('ActionButtonType.shouldShow openActivity button', () {
+    final asset = createRemoteAsset();
+
+    test('should show in a shared activity-enabled album', () {
+      final context = ActionButtonContext(
+        asset: asset,
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: true,
+        isInLockedView: false,
+        currentAlbum: createRemoteAlbum(isActivityEnabled: true, isShared: true),
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+      );
+
+      expect(ActionButtonType.openActivity.shouldShow(context), isTrue);
+    });
+
+    test('should not show when no album', () {
+      final context = ActionButtonContext(
+        asset: asset,
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: true,
+        isInLockedView: false,
+        currentAlbum: null,
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+      );
+
+      expect(ActionButtonType.openActivity.shouldShow(context), isFalse);
+    });
+
+    test('should not show when album not shared', () {
+      final context = ActionButtonContext(
+        asset: asset,
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: true,
+        isInLockedView: false,
+        currentAlbum: createRemoteAlbum(isActivityEnabled: true, isShared: false),
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+      );
+
+      expect(ActionButtonType.openActivity.shouldShow(context), isFalse);
+    });
+
+    test('should not show when activity disabled', () {
+      final context = ActionButtonContext(
+        asset: asset,
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: true,
+        isInLockedView: false,
+        currentAlbum: createRemoteAlbum(isActivityEnabled: false, isShared: true),
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+      );
+
+      expect(ActionButtonType.openActivity.shouldShow(context), isFalse);
+    });
+
+    test('should not show in locked view', () {
+      final context = ActionButtonContext(
+        asset: asset,
+        isOwner: true,
+        isArchived: false,
+        isTrashEnabled: true,
+        isInLockedView: true,
+        currentAlbum: createRemoteAlbum(isActivityEnabled: true, isShared: true),
+        advancedTroubleshooting: false,
+        isStacked: false,
+        source: ActionSource.viewer,
+      );
+
+      expect(ActionButtonType.openActivity.shouldShow(context), isFalse);
+    });
+  });
+
+  group('ActionButtonType.showsAt', () {
+    ActionButtonContext ctx({RemoteAlbum? album, TimelineOrigin origin = TimelineOrigin.main}) => ActionButtonContext(
+      asset: createRemoteAsset(),
+      isOwner: true,
+      isArchived: false,
+      isTrashEnabled: true,
+      isInLockedView: false,
+      currentAlbum: album,
+      advancedTroubleshooting: false,
+      isStacked: false,
+      source: ActionSource.viewer,
+      timelineOrigin: origin,
+    );
+
+    group('editImage', () {
+      test('hidden from bottom bar when album is shared', () {
+        final context = ctx(album: createRemoteAlbum(isShared: true));
+        expect(ActionButtonType.editImage.showsAt(ButtonPosition.bottomBar, context), isFalse);
+      });
+
+      test('shown in bottom bar when album is not shared', () {
+        final context = ctx(album: createRemoteAlbum(isShared: false));
+        expect(ActionButtonType.editImage.showsAt(ButtonPosition.bottomBar, context), isTrue);
+      });
+
+      test('shown in bottom bar when there is no album', () {
+        expect(ActionButtonType.editImage.showsAt(ButtonPosition.bottomBar, ctx()), isTrue);
+      });
+    });
+
+    group('openActivity / likeActivity', () {
+      test('hidden from bottom bar when viewing from trash', () {
+        final context = ctx(origin: TimelineOrigin.trash);
+        expect(ActionButtonType.openActivity.showsAt(ButtonPosition.bottomBar, context), isFalse);
+        expect(ActionButtonType.likeActivity.showsAt(ButtonPosition.bottomBar, context), isFalse);
+      });
+
+      test('shown in bottom bar outside trash', () {
+        expect(ActionButtonType.openActivity.showsAt(ButtonPosition.bottomBar, ctx()), isTrue);
+        expect(ActionButtonType.likeActivity.showsAt(ButtonPosition.bottomBar, ctx()), isTrue);
+      });
+    });
+  });
 }

packages/plugin-core/src/index.ts

@@ -151,14 +151,14 @@ const methods = wrapper<Manifest>({
   }),
 
   webhook: ({ config, data, functions, type, trigger }) => {
-    const headers: Record<string, string> = {};
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
 
     if (config.headerName && config.headerValue) {
       headers[config.headerName] = config.headerValue;
     }
 
-    headers['Content-Type'] = 'application/json';
-
     functions.httpRequest(config.url, {
       method: config.method ?? 'POST',
       body: JSON.stringify({