391 lines
13 KiB
Dart
391 lines
13 KiB
Dart
import 'dart:async' show unawaited;
|
|
import 'dart:io';
|
|
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/services.dart';
|
|
import '../media/playback_rate.dart';
|
|
import '../models/hotkey_model.dart';
|
|
import '../i18n/strings.g.dart';
|
|
import '../mpv/mpv.dart';
|
|
import 'settings_binding_owner.dart';
|
|
import 'settings_service.dart';
|
|
import 'shortcut_action.dart';
|
|
import '../utils/platform_detector.dart';
|
|
import '../utils/player_utils.dart';
|
|
|
|
class KeyboardShortcutsService extends ChangeNotifier {
|
|
static KeyboardShortcutsService? _instance;
|
|
static Future<void>? _initialization;
|
|
late final SettingsBindingOwner _settingsBinding;
|
|
Map<String, HotKey?> _hotkeys = {};
|
|
Future<void> _shortcutMutationTail = Future.value();
|
|
int _seekTimeSmall = 10; // Default, loaded from settings
|
|
int _seekTimeLarge = 30; // Default, loaded from settings
|
|
bool _disposed = false;
|
|
bool _settingsInitialized = false;
|
|
|
|
KeyboardShortcutsService._() {
|
|
_settingsBinding = SettingsBindingOwner(
|
|
prefs: [SettingsService.keyboardHotkeys, SettingsService.seekTimeSmall, SettingsService.seekTimeLarge],
|
|
onRefresh: _syncFromSettings,
|
|
);
|
|
}
|
|
|
|
SettingsService get _settingsService => _settingsBinding.settings!;
|
|
|
|
static Future<KeyboardShortcutsService> getInstance() async {
|
|
var instance = _instance;
|
|
if (instance == null) {
|
|
instance = KeyboardShortcutsService._();
|
|
_instance = instance;
|
|
final initialization = instance._init();
|
|
_initialization = initialization;
|
|
}
|
|
|
|
final initialization = _initialization;
|
|
if (initialization != null) {
|
|
try {
|
|
await initialization;
|
|
} catch (_) {
|
|
if (identical(_instance, instance)) {
|
|
instance._settingsBinding.dispose();
|
|
instance._disposed = true;
|
|
_instance = null;
|
|
}
|
|
rethrow;
|
|
} finally {
|
|
if (identical(_initialization, initialization)) _initialization = null;
|
|
}
|
|
}
|
|
if (instance._disposed) throw StateError('KeyboardShortcutsService was disposed during initialization');
|
|
return instance;
|
|
}
|
|
|
|
/// Keyboard shortcut customization is only supported on desktop platforms.
|
|
static bool isPlatformSupported() {
|
|
return PlatformDetector.isDesktopOS();
|
|
}
|
|
|
|
Future<void> _init() async {
|
|
await _settingsBinding.bind();
|
|
}
|
|
|
|
void _syncFromSettings(SettingsService service) {
|
|
final hotkeys = service.read(SettingsService.keyboardHotkeys);
|
|
final seekTimeSmall = service.read(SettingsService.seekTimeSmall);
|
|
final seekTimeLarge = service.read(SettingsService.seekTimeLarge);
|
|
|
|
final changed =
|
|
!_hotkeyMapsEqual(_hotkeys, hotkeys) || _seekTimeSmall != seekTimeSmall || _seekTimeLarge != seekTimeLarge;
|
|
|
|
_hotkeys = Map<String, HotKey?>.from(hotkeys);
|
|
_seekTimeSmall = seekTimeSmall;
|
|
_seekTimeLarge = seekTimeLarge;
|
|
|
|
final notify = _settingsInitialized;
|
|
_settingsInitialized = true;
|
|
if (notify && changed) notifyListeners();
|
|
}
|
|
|
|
bool _hotkeyMapsEqual(Map<String, HotKey?> a, Map<String, HotKey?> b) {
|
|
if (a.length != b.length) return false;
|
|
for (final entry in a.entries) {
|
|
if (!b.containsKey(entry.key)) return false;
|
|
final value = entry.value;
|
|
final other = b[entry.key];
|
|
if (value == null || other == null) {
|
|
if (value != other) return false;
|
|
} else if (!_hotkeyEquals(value, other)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
Map<String, HotKey?> get hotkeys => Map.from(_hotkeys);
|
|
|
|
@visibleForTesting
|
|
HotKey? getHotkey(String action) {
|
|
return _hotkeys[action];
|
|
}
|
|
|
|
Future<void> setHotkey(String action, HotKey? hotkey) {
|
|
return _serializeShortcutMutation(() async {
|
|
await _settingsService.write(SettingsService.keyboardHotkeys, <String, HotKey?>{..._hotkeys, action: hotkey});
|
|
});
|
|
}
|
|
|
|
Future<void> refreshFromStorage() async {
|
|
_settingsBinding.refresh();
|
|
}
|
|
|
|
Future<void> resetToDefaults() {
|
|
return _serializeShortcutMutation(() async {
|
|
await _settingsService.write(SettingsService.keyboardHotkeys, <String, HotKey?>{
|
|
...SettingsService.defaultKeyboardHotkeys(),
|
|
});
|
|
});
|
|
}
|
|
|
|
Future<void> _serializeShortcutMutation(Future<void> Function() operation) {
|
|
final result = _shortcutMutationTail.then((_) => operation());
|
|
_shortcutMutationTail = result.then<void>((_) {}, onError: (Object _, StackTrace _) {});
|
|
return result;
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
if (_disposed) return;
|
|
_disposed = true;
|
|
_settingsBinding.dispose();
|
|
if (identical(_instance, this)) {
|
|
_instance = null;
|
|
_initialization = null;
|
|
}
|
|
super.dispose();
|
|
}
|
|
|
|
String formatHotkey(HotKey? hotKey) {
|
|
if (hotKey == null) return t.hotkeys.noShortcutSet;
|
|
|
|
final isMac = Platform.isMacOS;
|
|
|
|
// macOS standard modifier order: ⌃ ⌥ ⇧ ⌘
|
|
const macModifierLabels = <HotKeyModifier, String>{
|
|
HotKeyModifier.control: '\u2303',
|
|
HotKeyModifier.alt: '\u2325',
|
|
HotKeyModifier.shift: '\u21e7',
|
|
HotKeyModifier.meta: '\u2318',
|
|
HotKeyModifier.capsLock: '\u21ea',
|
|
HotKeyModifier.fn: 'fn',
|
|
};
|
|
|
|
const defaultModifierLabels = <HotKeyModifier, String>{
|
|
HotKeyModifier.alt: 'Alt',
|
|
HotKeyModifier.control: 'Ctrl',
|
|
HotKeyModifier.shift: 'Shift',
|
|
HotKeyModifier.meta: 'Meta',
|
|
HotKeyModifier.capsLock: 'CapsLock',
|
|
HotKeyModifier.fn: 'Fn',
|
|
};
|
|
|
|
final labels = isMac ? macModifierLabels : defaultModifierLabels;
|
|
final modifiers = (hotKey.modifiers ?? []).map((m) => labels[m] ?? m.name).toList();
|
|
|
|
// The key label already uses macOS symbols via physicalKeyLabel()
|
|
final keyName = physicalKeyLabel(hotKey.key);
|
|
|
|
if (isMac) {
|
|
return [...modifiers, keyName].join();
|
|
}
|
|
return modifiers.isEmpty ? keyName : '${modifiers.join(' + ')} + $keyName';
|
|
}
|
|
|
|
KeyEventResult handleVideoPlayerKeyEvent(
|
|
KeyEvent event,
|
|
Player player,
|
|
VoidCallback? onToggleFullscreen,
|
|
VoidCallback? onToggleSubtitles,
|
|
VoidCallback? onNextAudioTrack,
|
|
VoidCallback? onNextSubtitleTrack,
|
|
VoidCallback? onNextChapter,
|
|
VoidCallback? onPreviousChapter, {
|
|
required bool canControlPlayback,
|
|
required bool canNavigateMediaItems,
|
|
VoidCallback? onPlayPause,
|
|
VoidCallback? onToggleShader,
|
|
VoidCallback? onSkipMarker,
|
|
VoidCallback? onNextEpisode,
|
|
VoidCallback? onPreviousEpisode,
|
|
VoidCallback? onScreenshot,
|
|
VoidCallback? onZoomIn,
|
|
VoidCallback? onZoomOut,
|
|
VoidCallback? onZoomReset,
|
|
VoidCallback? onVolumeUp,
|
|
VoidCallback? onVolumeDown,
|
|
VoidCallback? onToggleMute,
|
|
ValueChanged<int>? onLiveSeekBy,
|
|
Future<void> Function(Duration position)? onSeekRequested,
|
|
|
|
/// Takes over relative seeking entirely when supplied, so the caller can
|
|
/// coalesce a burst of presses and report the accepted offset. Without it
|
|
/// each press rebases off `player.state.position`, which a slow backend
|
|
/// has not applied yet.
|
|
ValueChanged<int>? onSeekBy,
|
|
}) {
|
|
final isRepeat = event is KeyRepeatEvent;
|
|
if (event is! KeyDownEvent && !isRepeat) return KeyEventResult.ignored;
|
|
|
|
final physicalKey = event.physicalKey;
|
|
final isShiftPressed = HardwareKeyboard.instance.isShiftPressed;
|
|
final isControlPressed = HardwareKeyboard.instance.isControlPressed;
|
|
final isAltPressed = HardwareKeyboard.instance.isAltPressed;
|
|
final isMetaPressed = HardwareKeyboard.instance.isMetaPressed;
|
|
|
|
for (final entry in _hotkeys.entries) {
|
|
final hotkey = entry.value;
|
|
if (hotkey == null) continue;
|
|
|
|
if (physicalKey != hotkey.key) continue;
|
|
|
|
// Null for an id this build does not know: the event is still consumed so
|
|
// a stale binding never leaks through to another handler.
|
|
final action = ShortcutAction.fromId(entry.key);
|
|
|
|
final requiredModifiers = hotkey.modifiers ?? [];
|
|
bool modifiersMatch = true;
|
|
|
|
for (final modifier in requiredModifiers) {
|
|
switch (modifier) {
|
|
case HotKeyModifier.shift:
|
|
if (!isShiftPressed) modifiersMatch = false;
|
|
break;
|
|
case HotKeyModifier.control:
|
|
if (!isControlPressed) modifiersMatch = false;
|
|
break;
|
|
case HotKeyModifier.alt:
|
|
if (!isAltPressed) modifiersMatch = false;
|
|
break;
|
|
case HotKeyModifier.meta:
|
|
if (!isMetaPressed) modifiersMatch = false;
|
|
break;
|
|
case HotKeyModifier.capsLock:
|
|
break;
|
|
case HotKeyModifier.fn:
|
|
break;
|
|
}
|
|
if (!modifiersMatch) break;
|
|
}
|
|
|
|
if (modifiersMatch) {
|
|
final hasShift = requiredModifiers.contains(HotKeyModifier.shift);
|
|
final hasControl = requiredModifiers.contains(HotKeyModifier.control);
|
|
final hasAlt = requiredModifiers.contains(HotKeyModifier.alt);
|
|
final hasMeta = requiredModifiers.contains(HotKeyModifier.meta);
|
|
|
|
if (isShiftPressed != hasShift ||
|
|
isControlPressed != hasControl ||
|
|
isAltPressed != hasAlt ||
|
|
isMetaPressed != hasMeta) {
|
|
continue;
|
|
}
|
|
|
|
if (isRepeat && !(action?.repeatable ?? false)) {
|
|
return KeyEventResult.handled;
|
|
}
|
|
|
|
if (action == null ||
|
|
(action.requiresPlayback && !canControlPlayback) ||
|
|
(action.requiresMediaNavigation && !canNavigateMediaItems)) {
|
|
return KeyEventResult.handled;
|
|
}
|
|
|
|
void performSeek(int offsetSeconds) {
|
|
if (onSeekBy != null) {
|
|
onSeekBy(offsetSeconds);
|
|
return;
|
|
}
|
|
// Relative live-TV skip: route through the parent accumulator, which
|
|
// coalesces a rapid burst into one transcode re-open (#1253).
|
|
if (onLiveSeekBy != null) {
|
|
onLiveSeekBy(offsetSeconds);
|
|
} else {
|
|
final target = clampSeekPosition(player, player.state.position + Duration(seconds: offsetSeconds));
|
|
unawaited((onSeekRequested ?? player.seek)(target));
|
|
}
|
|
}
|
|
|
|
switch (action) {
|
|
case ShortcutAction.playPause:
|
|
(onPlayPause ?? player.playOrPause).call();
|
|
case ShortcutAction.volumeUp:
|
|
onVolumeUp?.call();
|
|
case ShortcutAction.volumeDown:
|
|
onVolumeDown?.call();
|
|
case ShortcutAction.seekForward:
|
|
performSeek(_seekTimeSmall);
|
|
case ShortcutAction.seekBackward:
|
|
performSeek(-_seekTimeSmall);
|
|
case ShortcutAction.seekForwardLarge:
|
|
performSeek(_seekTimeLarge);
|
|
case ShortcutAction.seekBackwardLarge:
|
|
performSeek(-_seekTimeLarge);
|
|
case ShortcutAction.fullscreenToggle:
|
|
onToggleFullscreen?.call();
|
|
case ShortcutAction.muteToggle:
|
|
onToggleMute?.call();
|
|
case ShortcutAction.subtitleToggle:
|
|
onToggleSubtitles?.call();
|
|
case ShortcutAction.audioTrackNext:
|
|
onNextAudioTrack?.call();
|
|
case ShortcutAction.subtitleTrackNext:
|
|
onNextSubtitleTrack?.call();
|
|
case ShortcutAction.chapterNext:
|
|
onNextChapter?.call();
|
|
case ShortcutAction.chapterPrevious:
|
|
onPreviousChapter?.call();
|
|
case ShortcutAction.episodeNext:
|
|
onNextEpisode?.call();
|
|
case ShortcutAction.episodePrevious:
|
|
onPreviousEpisode?.call();
|
|
case ShortcutAction.speedIncrease:
|
|
final newRateUp = (player.state.rate + 0.25).clamp(minimumPlaybackRate, maximumPlaybackRate);
|
|
player.setRate(newRateUp);
|
|
_settingsService.write(SettingsService.defaultPlaybackSpeed, newRateUp);
|
|
case ShortcutAction.speedDecrease:
|
|
final newRateDown = (player.state.rate - 0.25).clamp(minimumPlaybackRate, maximumPlaybackRate);
|
|
player.setRate(newRateDown);
|
|
_settingsService.write(SettingsService.defaultPlaybackSpeed, newRateDown);
|
|
case ShortcutAction.speedReset:
|
|
player.setRate(1.0);
|
|
_settingsService.write(SettingsService.defaultPlaybackSpeed, 1.0);
|
|
case ShortcutAction.subSeekNext:
|
|
player.command(['sub-seek', '1']);
|
|
case ShortcutAction.subSeekPrev:
|
|
player.command(['sub-seek', '-1']);
|
|
case ShortcutAction.shaderToggle:
|
|
onToggleShader?.call();
|
|
case ShortcutAction.skipMarker:
|
|
onSkipMarker?.call();
|
|
case ShortcutAction.screenshot:
|
|
unawaited(player.command(['screenshot', 'subtitles']).then((_) => onScreenshot?.call()));
|
|
case ShortcutAction.zoomIn:
|
|
onZoomIn?.call();
|
|
case ShortcutAction.zoomOut:
|
|
onZoomOut?.call();
|
|
case ShortcutAction.zoomReset:
|
|
onZoomReset?.call();
|
|
}
|
|
return KeyEventResult.handled;
|
|
}
|
|
}
|
|
|
|
return KeyEventResult.ignored;
|
|
}
|
|
|
|
String getActionDisplayName(String action) {
|
|
final shortcut = ShortcutAction.fromId(action);
|
|
if (shortcut == null) return action;
|
|
return shortcut.label(seekTimeSmall: _seekTimeSmall, seekTimeLarge: _seekTimeLarge);
|
|
}
|
|
|
|
String? getActionForHotkey(HotKey hotkey) {
|
|
for (final entry in _hotkeys.entries) {
|
|
final assignedHotkey = entry.value;
|
|
if (assignedHotkey != null && _hotkeyEquals(assignedHotkey, hotkey)) {
|
|
return entry.key;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
bool _hotkeyEquals(HotKey a, HotKey b) {
|
|
if (a.key != b.key) return false;
|
|
|
|
final aModifiers = Set.from(a.modifiers ?? []);
|
|
final bModifiers = Set.from(b.modifiers ?? []);
|
|
|
|
return aModifiers.length == bModifiers.length && aModifiers.every((modifier) => bModifiers.contains(modifier));
|
|
}
|
|
}
|