640 lines
25 KiB
Dart
640 lines
25 KiB
Dart
part of '../media_detail_screen.dart';
|
|
|
|
extension _MediaDetailActionButtons on _MediaDetailScreenState {
|
|
Widget _buildActionButtons(MediaItem metadata) {
|
|
final isTv = PlatformDetector.isTV();
|
|
final tvScale = TvLayoutConstants.scaleOf(context);
|
|
final actionSize = isTv ? _tvDetailActionSize * tvScale : 48.0;
|
|
final playButtonLabel = _getPlayButtonLabel(metadata);
|
|
final playIconSize = isTv ? 22 * tvScale : 20.0;
|
|
final playTextStyle = TextStyle(fontSize: isTv ? 17 * tvScale : 16, fontWeight: FontWeight.w700);
|
|
final playButtonIcon = AppIcon(_getPlayButtonIcon(metadata), fill: 1, size: playIconSize);
|
|
|
|
Future<void> onPlayPressed() async {
|
|
// For TV shows, play the OnDeck episode if available
|
|
// Otherwise, play the first episode of the first season
|
|
if (metadata.isShow) {
|
|
if (_onDeckEpisode != null) {
|
|
appLogger.d('Playing on deck episode: ${_onDeckEpisode!.title}');
|
|
await navigateToVideoPlayerWithRefresh(
|
|
context,
|
|
metadata: _onDeckEpisode!,
|
|
isOffline: widget.isOffline,
|
|
onRefresh: _loadFullMetadata,
|
|
);
|
|
} else {
|
|
// No on deck episode, fetch first episode of first season
|
|
await _playFirstEpisode();
|
|
}
|
|
} else if (metadata.isSeason) {
|
|
// For seasons, play the first episode
|
|
if (_episodes.isNotEmpty) {
|
|
await navigateToVideoPlayerWithRefresh(
|
|
context,
|
|
metadata: _episodes.first,
|
|
isOffline: widget.isOffline,
|
|
onRefresh: _loadFullMetadata,
|
|
);
|
|
} else {
|
|
await _playFirstEpisode();
|
|
}
|
|
} else {
|
|
appLogger.d('Playing: ${metadata.title}');
|
|
// For movies or episodes, play directly
|
|
await navigateToVideoPlayerWithRefresh(
|
|
context,
|
|
metadata: metadata,
|
|
isOffline: widget.isOffline,
|
|
onRefresh: _loadFullMetadata,
|
|
);
|
|
}
|
|
}
|
|
|
|
final primaryTrailer = _getPrimaryTrailer();
|
|
|
|
final isKeyboardMode = InputModeTracker.isKeyboardMode(context);
|
|
final colorScheme = Theme.of(context).colorScheme;
|
|
|
|
// In keyboard/d-pad mode, focused buttons get a prominent style.
|
|
// overlayColor is set to transparent to prevent the Material focus
|
|
// overlay from dimming the background color we set.
|
|
final focusBg = colorScheme.inverseSurface;
|
|
final focusFg = colorScheme.onInverseSurface;
|
|
final tonalBg = colorScheme.secondaryContainer;
|
|
final idleBg = isTv ? tonalBg.withValues(alpha: 0.38) : tonalBg;
|
|
final tonalFg = colorScheme.onSecondaryContainer;
|
|
final noOverlay = WidgetStateProperty.resolveWith((states) {
|
|
if (states.contains(WidgetState.focused)) return Colors.transparent;
|
|
return null; // default for other states
|
|
});
|
|
|
|
ButtonStyle actionButtonStyle({Color? foregroundColor, EdgeInsetsGeometry? padding}) {
|
|
if (!isKeyboardMode && !isTv) {
|
|
if (padding != null) {
|
|
return FilledButton.styleFrom(padding: padding);
|
|
}
|
|
return IconButton.styleFrom(
|
|
minimumSize: const Size(48, 48),
|
|
maximumSize: const Size(48, 48),
|
|
foregroundColor: foregroundColor,
|
|
);
|
|
}
|
|
return ButtonStyle(
|
|
padding: padding != null ? WidgetStatePropertyAll(padding) : null,
|
|
minimumSize: WidgetStatePropertyAll(padding == null ? Size.square(actionSize) : Size(0, actionSize)),
|
|
maximumSize: padding == null ? WidgetStatePropertyAll(Size.square(actionSize)) : null,
|
|
fixedSize: padding == null ? WidgetStatePropertyAll(Size.square(actionSize)) : null,
|
|
tapTargetSize: MaterialTapTargetSize.shrinkWrap,
|
|
visualDensity: VisualDensity.compact,
|
|
overlayColor: noOverlay,
|
|
backgroundColor: WidgetStateProperty.resolveWith((states) {
|
|
if (states.contains(WidgetState.focused)) return focusBg;
|
|
return idleBg;
|
|
}),
|
|
foregroundColor: WidgetStateProperty.resolveWith((states) {
|
|
if (states.contains(WidgetState.focused)) return focusFg;
|
|
return foregroundColor ?? tonalFg;
|
|
}),
|
|
);
|
|
}
|
|
|
|
// Plays the resolved trailer. Shared by the row's trailer button and the
|
|
// ⋮ menu item so the trailer stays reachable when the row hides its button.
|
|
final VoidCallback? onPlayTrailer = primaryTrailer == null
|
|
? null
|
|
: () => unawaited(navigateToVideoPlayer(context, metadata: primaryTrailer));
|
|
|
|
final gap = isTv ? 8.0 * tvScale : 12.0;
|
|
|
|
final playButton = SizedBox(
|
|
height: actionSize,
|
|
child: FilledButton(
|
|
focusNode: _playButtonFocusNode,
|
|
autofocus: isKeyboardMode,
|
|
onPressed: onPlayPressed,
|
|
style: actionButtonStyle(
|
|
padding: EdgeInsets.symmetric(horizontal: isTv ? 17 * tvScale : 16, vertical: isTv ? 9 * tvScale : 0),
|
|
),
|
|
child: playButtonLabel.isNotEmpty
|
|
? Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
playButtonIcon,
|
|
SizedBox(width: isTv ? 7 * tvScale : 8),
|
|
Text(playButtonLabel, style: playTextStyle),
|
|
],
|
|
)
|
|
: playButtonIcon,
|
|
),
|
|
);
|
|
|
|
final trailerButton = primaryTrailer == null
|
|
? null
|
|
: IconButton.filledTonal(
|
|
onPressed: onPlayTrailer,
|
|
icon: const AppIcon(Symbols.theaters_rounded, fill: 1),
|
|
tooltip: t.tooltips.playTrailer,
|
|
iconSize: isTv ? 21 * tvScale : 20,
|
|
style: actionButtonStyle(),
|
|
);
|
|
|
|
final shuffleButton = (metadata.isShow || metadata.isSeason)
|
|
? IconButton.filledTonal(
|
|
onPressed: () async {
|
|
await _handleShufflePlayWithQueue(context, metadata);
|
|
},
|
|
icon: const AppIcon(Symbols.shuffle_rounded, fill: 1),
|
|
tooltip: t.tooltips.shufflePlay,
|
|
iconSize: isTv ? 21 * tvScale : 20,
|
|
style: actionButtonStyle(),
|
|
)
|
|
: null;
|
|
|
|
final downloadButton = !widget.isOffline && !PlatformDetector.isAppleTV()
|
|
? _buildDownloadButton(metadata, actionButtonStyle, tvScale)
|
|
: null;
|
|
final watchedButton = _buildWatchedToggleButton(metadata, actionButtonStyle, tvScale);
|
|
final moreActionsButton = widget.isOffline
|
|
? null
|
|
: _buildMoreActionsButton(metadata, actionButtonStyle, tvScale, onPlayTrailer: onPlayTrailer);
|
|
|
|
Row actionRow(List<Widget> buttons) {
|
|
return Row(
|
|
children: [
|
|
for (var i = 0; i < buttons.length; i++) ...[if (i > 0) SizedBox(width: gap), buttons[i]],
|
|
],
|
|
);
|
|
}
|
|
|
|
final allButtons = <Widget>[
|
|
playButton,
|
|
if (trailerButton != null) trailerButton,
|
|
if (shuffleButton != null) shuffleButton,
|
|
if (downloadButton != null) downloadButton,
|
|
watchedButton,
|
|
if (moreActionsButton != null) moreActionsButton,
|
|
];
|
|
|
|
double playButtonWidthEstimate() {
|
|
if (playButtonLabel.isEmpty) return 64.0;
|
|
final textPainter = TextPainter(
|
|
text: TextSpan(text: playButtonLabel, style: playTextStyle),
|
|
maxLines: 1,
|
|
textDirection: Directionality.of(context),
|
|
)..layout();
|
|
final textWidth = textPainter.width;
|
|
textPainter.dispose();
|
|
final horizontalPadding = isTv ? 34.0 * tvScale : 32.0;
|
|
final iconGap = isTv ? 7.0 * tvScale : 8.0;
|
|
return (horizontalPadding + playIconSize + iconGap + textWidth).clamp(64.0, double.infinity).toDouble();
|
|
}
|
|
|
|
final estimatedPlayWidth = playButtonWidthEstimate();
|
|
double estimatedRowWidth(List<Widget> buttons) {
|
|
if (buttons.isEmpty) return 0;
|
|
return estimatedPlayWidth + (buttons.length - 1) * actionSize + (buttons.length - 1) * gap;
|
|
}
|
|
|
|
List<Widget> compactButtonsFor(double maxWidth) {
|
|
if (widget.isOffline) {
|
|
final compact = <Widget>[playButton, watchedButton];
|
|
if (maxWidth.isFinite && estimatedRowWidth(compact) > maxWidth) return [playButton];
|
|
return compact;
|
|
}
|
|
|
|
final medium = <Widget>[
|
|
playButton,
|
|
if (downloadButton != null) downloadButton,
|
|
watchedButton,
|
|
if (moreActionsButton != null) moreActionsButton,
|
|
];
|
|
if (!maxWidth.isFinite || estimatedRowWidth(medium) <= maxWidth) return medium;
|
|
|
|
final compact = <Widget>[playButton, watchedButton, if (moreActionsButton != null) moreActionsButton];
|
|
if (estimatedRowWidth(compact) <= maxWidth) return compact;
|
|
|
|
return [playButton, if (moreActionsButton != null) moreActionsButton];
|
|
}
|
|
|
|
return Focus(
|
|
skipTraversal: true,
|
|
onFocusChange: (hasFocus) {
|
|
if (isTv) _setTvDetailActionRowFocus(hasFocus);
|
|
},
|
|
onKeyEvent: _handlePlayButtonKeyEvent,
|
|
// TV screens are wide and D-pad focus should see every direct action.
|
|
// On smaller online screens, hidden actions remain available from ⋮.
|
|
child: isTv
|
|
? actionRow(allButtons)
|
|
: LayoutBuilder(
|
|
builder: (context, constraints) {
|
|
final maxWidth = constraints.maxWidth;
|
|
if (!maxWidth.isFinite || estimatedRowWidth(allButtons) <= maxWidth) {
|
|
return actionRow(allButtons);
|
|
}
|
|
return actionRow(compactButtonsFor(maxWidth));
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _buildWatchedToggleButton(
|
|
MediaItem metadata,
|
|
ButtonStyle Function({Color? foregroundColor, EdgeInsetsGeometry? padding}) actionButtonStyle,
|
|
double tvScale,
|
|
) {
|
|
return IconButton.filledTonal(
|
|
onPressed: () async {
|
|
try {
|
|
final isWatched = metadata.isWatched;
|
|
if (widget.isOffline) {
|
|
// Offline mode: queue action for later sync
|
|
final offlineWatch = context.read<OfflineWatchProvider>();
|
|
if (isWatched) {
|
|
await offlineWatch.markAsUnwatched(serverId: metadata.serverId!, itemId: metadata.id);
|
|
} else {
|
|
await offlineWatch.markAsWatched(serverId: metadata.serverId!, itemId: metadata.id);
|
|
}
|
|
if (mounted) {
|
|
showAppSnackBar(
|
|
context,
|
|
isWatched ? t.messages.markedAsUnwatchedOffline : t.messages.markedAsWatchedOffline,
|
|
);
|
|
}
|
|
} else {
|
|
// Online mode: dispatch via the right backend's neutral method so
|
|
// Jellyfin items hit /UserPlayedItems and Plex items hit /:/scrobble.
|
|
final serverId = metadata.serverId;
|
|
if (serverId == null) return;
|
|
final client = context.tryGetMediaClientForServer(serverId);
|
|
if (client == null) return;
|
|
|
|
if (isWatched) {
|
|
await client.markUnwatched(metadata);
|
|
unawaited(TrackerCoordinator.instance.markUnwatched(metadata, client));
|
|
} else {
|
|
await client.markWatched(metadata);
|
|
unawaited(TrackerCoordinator.instance.markWatched(metadata, client));
|
|
}
|
|
if (mounted) {
|
|
_watchStateChanged = true;
|
|
showSuccessSnackBar(context, isWatched ? t.messages.markedAsUnwatched : t.messages.markedAsWatched);
|
|
}
|
|
}
|
|
} catch (e) {
|
|
if (mounted) {
|
|
showErrorSnackBar(context, t.messages.errorLoading(error: e.toString()));
|
|
}
|
|
}
|
|
},
|
|
icon: AppIcon(metadata.isWatched ? Symbols.remove_done_rounded : Symbols.check_rounded, fill: 1),
|
|
tooltip: metadata.isWatched ? t.tooltips.markAsUnwatched : t.tooltips.markAsWatched,
|
|
iconSize: PlatformDetector.isTV() ? 21 * tvScale : 20,
|
|
style: actionButtonStyle(),
|
|
);
|
|
}
|
|
|
|
Widget _buildMoreActionsButton(
|
|
MediaItem metadata,
|
|
ButtonStyle Function({Color? foregroundColor, EdgeInsetsGeometry? padding}) actionButtonStyle,
|
|
double tvScale, {
|
|
VoidCallback? onPlayTrailer,
|
|
}) {
|
|
return MediaContextMenu(
|
|
key: _contextMenuKey,
|
|
item: metadata,
|
|
onRefresh: (itemId) => unawaited(_refreshItemInPlace(itemId)),
|
|
onPlayTrailer: onPlayTrailer,
|
|
child: Builder(
|
|
builder: (buttonContext) => IconButton.filledTonal(
|
|
onPressed: () {
|
|
final renderBox = buttonContext.findRenderObject() as RenderBox?;
|
|
if (renderBox != null) {
|
|
final position = renderBox.localToGlobal(renderBox.size.center(Offset.zero));
|
|
_contextMenuKey.currentState?.showContextMenu(buttonContext, position: position);
|
|
}
|
|
},
|
|
icon: const AppIcon(Symbols.more_vert_rounded, fill: 1),
|
|
iconSize: PlatformDetector.isTV() ? 21 * tvScale : 20,
|
|
style: actionButtonStyle(),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _buildDownloadButton(
|
|
MediaItem metadata,
|
|
ButtonStyle Function({Color? foregroundColor, EdgeInsetsGeometry? padding}) actionButtonStyle,
|
|
double tvScale,
|
|
) {
|
|
return Consumer<DownloadProvider>(
|
|
builder: (context, downloadProvider, _) {
|
|
final iconSize = PlatformDetector.isTV() ? 21.0 * tvScale : 20.0;
|
|
final globalKey = metadata.globalKey;
|
|
final ruleKey = _syncRuleKeyForMetadata(context, downloadProvider, metadata);
|
|
final progress = downloadProvider.getProgress(globalKey);
|
|
final isQueueing = downloadProvider.isQueueing(globalKey);
|
|
|
|
// Debug logging
|
|
if (progress != null) {
|
|
appLogger.d('UI rebuilding for $globalKey: status=${progress.status}, progress=${progress.progress}%');
|
|
}
|
|
|
|
// State 1: Queueing (building download queue)
|
|
if (isQueueing) {
|
|
return IconButton.filledTonal(
|
|
onPressed: null,
|
|
icon: LoadingIndicatorBox(size: iconSize),
|
|
iconSize: iconSize,
|
|
style: actionButtonStyle(),
|
|
);
|
|
}
|
|
|
|
// State 2: Queued (waiting to download)
|
|
if (progress?.status == DownloadStatus.queued) {
|
|
final currentFile = progress?.currentFile;
|
|
final tooltip = currentFile != null && currentFile.contains('episodes')
|
|
? t.downloads.queuedFilesTooltip(files: currentFile)
|
|
: t.downloads.queuedTooltip;
|
|
|
|
return IconButton.filledTonal(
|
|
onPressed: null,
|
|
tooltip: tooltip,
|
|
icon: const AppIcon(Symbols.schedule_rounded, fill: 1),
|
|
iconSize: iconSize,
|
|
style: actionButtonStyle(),
|
|
);
|
|
}
|
|
|
|
// State 3: Downloading (active download)
|
|
if (progress?.status == DownloadStatus.downloading) {
|
|
// Show episode count in tooltip for shows/seasons
|
|
final currentFile = progress?.currentFile;
|
|
final tooltip = currentFile != null && currentFile.contains('episodes')
|
|
? t.downloads.downloadingFilesTooltip(files: currentFile)
|
|
: t.downloads.downloadingTooltip;
|
|
|
|
return IconButton.filledTonal(
|
|
onPressed: null,
|
|
tooltip: tooltip,
|
|
icon: _buildRadialProgress(progress?.progressPercent),
|
|
iconSize: iconSize,
|
|
style: actionButtonStyle(),
|
|
);
|
|
}
|
|
|
|
// State 4: Paused (can resume)
|
|
if (progress?.status == DownloadStatus.paused) {
|
|
return IconButton.filledTonal(
|
|
onPressed: () async {
|
|
final client = _getMediaClientForMetadata(context);
|
|
if (client == null) return;
|
|
await downloadProvider.resumeDownload(globalKey, client);
|
|
if (context.mounted) {
|
|
showAppSnackBar(context, 'Download resumed');
|
|
}
|
|
},
|
|
icon: const AppIcon(Symbols.pause_circle_outline_rounded, fill: 1),
|
|
tooltip: 'Resume download',
|
|
iconSize: iconSize,
|
|
style: actionButtonStyle(foregroundColor: Colors.amber),
|
|
);
|
|
}
|
|
|
|
// State 5: Failed (can retry)
|
|
if (progress?.status == DownloadStatus.failed) {
|
|
return IconButton.filledTonal(
|
|
onPressed: () async {
|
|
final client = _getMediaClientForMetadata(context);
|
|
if (client == null) return;
|
|
|
|
final versionConfig = await _resolveDownloadVersion(context, metadata, client);
|
|
if (versionConfig == null || !context.mounted) return;
|
|
|
|
await downloadProvider.deleteDownload(globalKey);
|
|
try {
|
|
await downloadProvider.queueDownload(metadata, client, versionConfig: versionConfig);
|
|
|
|
if (context.mounted) {
|
|
showSuccessSnackBar(context, t.downloads.downloadQueued);
|
|
}
|
|
} on CellularDownloadBlockedException {
|
|
if (context.mounted) {
|
|
showErrorSnackBar(context, t.settings.cellularDownloadBlocked);
|
|
}
|
|
}
|
|
},
|
|
icon: const AppIcon(Symbols.error_outline_rounded, fill: 1),
|
|
tooltip: 'Retry download',
|
|
iconSize: iconSize,
|
|
style: actionButtonStyle(foregroundColor: Colors.red),
|
|
);
|
|
}
|
|
|
|
// State 6: Cancelled (can delete or retry)
|
|
if (progress?.status == DownloadStatus.cancelled) {
|
|
return IconButton.filledTonal(
|
|
onPressed: () async {
|
|
// Show options: Delete or Retry
|
|
final retry = await showConfirmDialog(
|
|
context,
|
|
title: 'Cancelled Download',
|
|
message: 'This download was cancelled. What would you like to do?',
|
|
cancelText: t.common.delete,
|
|
confirmText: 'Retry',
|
|
);
|
|
|
|
if (!retry && context.mounted) {
|
|
await downloadProvider.deleteDownload(globalKey);
|
|
if (context.mounted) {
|
|
showSuccessSnackBar(context, t.downloads.downloadDeleted);
|
|
}
|
|
} else if (retry && context.mounted) {
|
|
final client = _getMediaClientForMetadata(context);
|
|
if (client == null) return;
|
|
|
|
final versionConfig = await _resolveDownloadVersion(context, metadata, client);
|
|
if (versionConfig == null || !context.mounted) return;
|
|
|
|
await downloadProvider.deleteDownload(globalKey);
|
|
try {
|
|
await downloadProvider.queueDownload(metadata, client, versionConfig: versionConfig);
|
|
if (context.mounted) {
|
|
showSuccessSnackBar(context, t.downloads.downloadQueued);
|
|
}
|
|
} on CellularDownloadBlockedException {
|
|
if (context.mounted) {
|
|
showErrorSnackBar(context, t.settings.cellularDownloadBlocked);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
icon: const AppIcon(Symbols.cancel_rounded, fill: 1),
|
|
tooltip: 'Cancelled download',
|
|
iconSize: iconSize,
|
|
style: actionButtonStyle(foregroundColor: Colors.grey),
|
|
);
|
|
}
|
|
|
|
// State 7: Partial Download (some episodes downloaded, not all)
|
|
if (progress?.status == DownloadStatus.partial) {
|
|
final hasSyncRule = downloadProvider.hasSyncRule(ruleKey);
|
|
final currentFile = progress?.currentFile;
|
|
|
|
if (hasSyncRule) {
|
|
// Synced partial — this is the normal state for sync rules
|
|
final syncRule = downloadProvider.getSyncRule(ruleKey);
|
|
final isEnabled = syncRule?.enabled ?? true;
|
|
final tooltip = currentFile != null
|
|
? '$currentFile (syncing ${t.downloads.keepNUnwatched(count: syncRule?.episodeCount.toString() ?? '?')})'
|
|
: t.downloads.keepSynced;
|
|
|
|
return IconButton.filledTonal(
|
|
onPressed: () => _showSyncRuleActions(
|
|
context,
|
|
downloadProvider,
|
|
metadata,
|
|
ruleKey: ruleKey,
|
|
downloadGlobalKey: globalKey,
|
|
),
|
|
tooltip: tooltip,
|
|
icon: AppIcon(isEnabled ? Symbols.sync_rounded : Symbols.sync_disabled_rounded, fill: 1),
|
|
iconSize: iconSize,
|
|
style: actionButtonStyle(foregroundColor: isEnabled ? Colors.teal : Colors.grey),
|
|
);
|
|
}
|
|
|
|
final tooltip = currentFile != null
|
|
? 'Downloaded $currentFile - Click to complete'
|
|
: 'Partially downloaded - Click to complete';
|
|
|
|
return IconButton.filledTonal(
|
|
onPressed: () async {
|
|
final client = _getMediaClientForMetadata(context);
|
|
if (client == null) return;
|
|
|
|
final versionConfig = await _resolveDownloadVersion(context, metadata, client);
|
|
if (versionConfig == null || !context.mounted) return;
|
|
|
|
final count = await downloadProvider.queueMissingEpisodes(metadata, client, versionConfig: versionConfig);
|
|
|
|
if (context.mounted) {
|
|
final message = count > 0
|
|
? t.downloads.episodesQueued(count: count)
|
|
: 'All episodes already downloaded';
|
|
showAppSnackBar(context, message);
|
|
}
|
|
},
|
|
tooltip: tooltip,
|
|
icon: const AppIcon(Symbols.downloading_rounded, fill: 1),
|
|
iconSize: iconSize,
|
|
style: actionButtonStyle(foregroundColor: Colors.orange),
|
|
);
|
|
}
|
|
|
|
// State 8: Downloaded/Completed (can delete)
|
|
if (downloadProvider.isDownloaded(globalKey)) {
|
|
final hasSyncRule = downloadProvider.hasSyncRule(ruleKey);
|
|
|
|
if (hasSyncRule) {
|
|
// Synced + complete — show sync icon
|
|
final syncRule = downloadProvider.getSyncRule(ruleKey);
|
|
final isEnabled = syncRule?.enabled ?? true;
|
|
return IconButton.filledTonal(
|
|
onPressed: () => _showSyncRuleActions(
|
|
context,
|
|
downloadProvider,
|
|
metadata,
|
|
ruleKey: ruleKey,
|
|
downloadGlobalKey: globalKey,
|
|
),
|
|
icon: AppIcon(isEnabled ? Symbols.sync_rounded : Symbols.sync_disabled_rounded, fill: 1),
|
|
tooltip: t.downloads.keepNUnwatched(count: syncRule?.episodeCount.toString() ?? '?'),
|
|
iconSize: iconSize,
|
|
style: actionButtonStyle(foregroundColor: isEnabled ? Colors.teal : Colors.grey),
|
|
);
|
|
}
|
|
|
|
// Shows/seasons may have more episodes to fetch; movies/episodes don't.
|
|
final canDownloadMore = metadata.isShow || metadata.isSeason;
|
|
|
|
Future<void> confirmAndDelete() async {
|
|
final confirmed = await showDeleteConfirmation(
|
|
context,
|
|
title: t.downloads.deleteDownload,
|
|
message: t.downloads.deleteConfirm(title: metadata.displayTitle),
|
|
);
|
|
if (confirmed && context.mounted) {
|
|
await downloadProvider.deleteDownload(globalKey);
|
|
if (context.mounted) {
|
|
showSuccessSnackBar(context, t.downloads.downloadDeleted);
|
|
}
|
|
}
|
|
}
|
|
|
|
return IconButton.filledTonal(
|
|
onPressed: () async {
|
|
// Movies/episodes: nothing more to download, so delete directly.
|
|
if (!canDownloadMore) {
|
|
await confirmAndDelete();
|
|
return;
|
|
}
|
|
// Shows/seasons: reopen the download options menu so the user can
|
|
// grab more episodes (or switch to sync), with delete as a row.
|
|
final client = _getMediaClientForMetadata(context);
|
|
if (client == null) return;
|
|
try {
|
|
final result = await showDownloadOptionsAndQueue(
|
|
context,
|
|
metadata: metadata,
|
|
client: client,
|
|
downloadProvider: downloadProvider,
|
|
onDelete: confirmAndDelete,
|
|
);
|
|
if (result == null || !context.mounted) return;
|
|
showSuccessSnackBar(context, result.toSnackBarMessage());
|
|
} on CellularDownloadBlockedException {
|
|
if (context.mounted) {
|
|
showErrorSnackBar(context, t.settings.cellularDownloadBlocked);
|
|
}
|
|
}
|
|
},
|
|
icon: const AppIcon(Symbols.download_rounded, fill: 1),
|
|
tooltip: canDownloadMore ? t.downloads.manage : t.downloads.deleteDownload,
|
|
iconSize: iconSize,
|
|
style: actionButtonStyle(foregroundColor: Colors.orange),
|
|
);
|
|
}
|
|
|
|
// State 9: Not downloaded (default - can download)
|
|
return IconButton.filledTonal(
|
|
onPressed: () async {
|
|
final client = _getMediaClientForMetadata(context);
|
|
if (client == null) return;
|
|
|
|
try {
|
|
final result = await showDownloadOptionsAndQueue(
|
|
context,
|
|
metadata: metadata,
|
|
client: client,
|
|
downloadProvider: downloadProvider,
|
|
);
|
|
if (result == null || !context.mounted) return;
|
|
|
|
showSuccessSnackBar(context, result.toSnackBarMessage());
|
|
} on CellularDownloadBlockedException {
|
|
if (context.mounted) {
|
|
showErrorSnackBar(context, t.settings.cellularDownloadBlocked);
|
|
}
|
|
}
|
|
},
|
|
icon: const AppIcon(Symbols.download_rounded, fill: 1),
|
|
tooltip: t.downloads.downloadNow,
|
|
iconSize: iconSize,
|
|
style: actionButtonStyle(),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
}
|