Add keyboard shortcuts for controlling media playback

Telegram/SourceFiles/core/shortcuts.cpp

@@ -37,6 +37,12 @@ const auto AutoRepeatCommands = base::flat_set<Command>{
 	Command::ChatNext,
 	Command::ChatFirst,
 	Command::ChatLast,
+	Command::VolumeUp,
+	Command::VolumeDown,
+	Command::PlaybackSpeedUp,
+	Command::PlaybackSpeedDown,
+	Command::Rewind,
+	Command::FastForward,
 };
 
 const auto MediaCommands = base::flat_set<Command>{
@@ -46,6 +52,15 @@ const auto MediaCommands = base::flat_set<Command>{
 	Command::MediaStop,
 	Command::MediaPrevious,
 	Command::MediaNext,
+	Command::Shuffle,
+	Command::Repeat,
+	Command::VolumeUp,
+	Command::VolumeDown,
+	Command::PlaybackSpeedUp,
+	Command::PlaybackSpeedDown,
+	Command::Rewind,
+	Command::FastForward,
+	Command::CloseMedia,
 };
 
 const auto SupportCommands = base::flat_set<Command>{
@@ -118,6 +133,15 @@ const auto CommandByName = base::flat_map<QString, Command>{
 	{ u"media_viewer_video_fullscreen"_q , Command::MediaViewerFullscreen },
 	{ u"show_scheduled"_q                , Command::ShowScheduled },
 	{ u"archive_chat"_q                  , Command::ArchiveChat },
+	{ u"shuffle"_q                       , Command::Shuffle },
+	{ u"repeat"_q                        , Command::Repeat },
+	{ u"volume_up"_q                     , Command::VolumeUp },
+	{ u"volume_down"_q                   , Command::VolumeDown },
+	{ u"playback_speed_up"_q             , Command::PlaybackSpeedUp },
+	{ u"playback_speed_down"_q           , Command::PlaybackSpeedDown },
+	{ u"rewind"_q                        , Command::Rewind },
+	{ u"fast_forward"_q                  , Command::FastForward },
+	{ u"close_media"_q                   , Command::CloseMedia },
 	//
 };
 
@@ -139,6 +163,15 @@ const base::flat_map<Command, QString> &CommandNames() {
 	Command::MediaViewerFullscreen,
 	Command::ShowScheduled,
 	Command::ArchiveChat,
+	Command::Shuffle,
+	Command::Repeat,
+	Command::VolumeUp,
+	Command::VolumeDown,
+	Command::PlaybackSpeedUp,
+	Command::PlaybackSpeedDown,
+	Command::Rewind,
+	Command::FastForward,
+	Command::CloseMedia,
 };
 
 class Manager {
@@ -507,6 +540,19 @@ void Manager::fillDefaults() {
 
 	set(u"ctrl+\\"_q, Command::ShowChatMenu);
 
+	set(u"mod+n"_q, Command::MediaNext);
+	set(u"mod+p"_q, Command::MediaPrevious);
+	set(u"mod+c"_q, Command::MediaPlayPause);
+	set(u"mod+s"_q, Command::Shuffle);
+	set(u"mod+r"_q, Command::Repeat);
+	set(u"mod+-"_q, Command::VolumeDown);
+	set(u"mod+="_q, Command::VolumeUp);
+	set(u"mod+<"_q, Command::PlaybackSpeedDown);
+	set(u"mod+>"_q, Command::PlaybackSpeedUp);
+	set(u"mod+shift+left"_q, Command::Rewind);
+	set(u"mod+shift+right"_q, Command::FastForward);
+	set(u"mod+x"_q, Command::CloseMedia);
+
 	_defaults = keysCurrents();
 }
 

Telegram/SourceFiles/media/player/media_player_instance.cpp

@@ -251,7 +251,9 @@ void Instance::setHistory(
 		setSession(data, &history->session());
 	} else {
 		data->history = data->migrated = nullptr;
-		setSession(data, sessionFallback);
+		setSession(
+			data,
+			sessionFallback);
 	}
 }
 
@@ -1290,6 +1292,42 @@ void Instance::setupShortcuts() {
 			next();
 			return true;
 		});
+		request->check(Command::Shuffle) && request->handle([=] {
+			toggleShuffle();
+			return true;
+		});
+		request->check(Command::Repeat) && request->handle([=] {
+			toggleRepeat();
+			return true;
+		});
+		request->check(Command::VolumeUp) && request->handle([=] {
+			adjustVolume(0.1);
+			return true;
+		});
+		request->check(Command::VolumeDown) && request->handle([=] {
+			adjustVolume(-0.1);
+			return true;
+		});
+		request->check(Command::PlaybackSpeedUp) && request->handle([=] {
+			adjustPlaybackSpeed(0.1);
+			return true;
+		});
+		request->check(Command::PlaybackSpeedDown) && request->handle([=] {
+			adjustPlaybackSpeed(-0.1);
+			return true;
+		});
+		request->check(Command::Rewind) && request->handle([=] {
+			seekRelative(-10);
+			return true;
+		});
+		request->check(Command::FastForward) && request->handle([=] {
+			seekRelative(10);
+			return true;
+		});
+		request->check(Command::CloseMedia) && request->handle([=] {
+			stopAndClose();
+			return true;
+		});
 	}, _lifetime);
 }
 
@@ -1382,5 +1420,69 @@ void Instance::handleStreamingError(
 	}
 }
 
+void Instance::toggleShuffle() {
+	auto &settings = Core::App().settings();
+	settings.setPlayerOrderMode([&] {
+		switch (settings.playerOrderMode()) {
+		case OrderMode::Default: return OrderMode::Shuffle;
+		case OrderMode::Shuffle: return OrderMode::Default;
+		case OrderMode::Reverse: return OrderMode::Default;
+		}
+		Unexpected("Order mode in Settings.");
+	}());
+	Core::App().saveSettingsDelayed();
+}
+
+void Instance::toggleRepeat() {
+	auto &settings = Core::App().settings();
+	settings.setPlayerRepeatMode([&] {
+		switch (settings.playerRepeatMode()) {
+		case RepeatMode::None: return RepeatMode::One;
+		case RepeatMode::One: return RepeatMode::All;
+		case RepeatMode::All: return RepeatMode::None;
+		}
+		Unexpected("Repeat mode in Settings.");
+	}());
+	Core::App().saveSettingsDelayed();
+}
+
+void Instance::adjustVolume(float delta) {
+	auto &settings = Core::App().settings();
+	auto volume = settings.songVolume();
+	volume = std::clamp(volume + delta, 0.0, 1.0);
+	settings.setSongVolume(volume);
+	Core::App().saveSettingsDelayed();
+	mixer()->setSongVolume(volume);
+}
+
+void Instance::adjustPlaybackSpeed(float delta) {
+	auto &settings = Core::App().settings();
+	auto speed = settings.voicePlaybackSpeed();
+	speed = std::clamp(speed + delta, 0.5, 2.0);
+	settings.setVoicePlaybackSpeed(speed);
+	Core::App().saveSettingsDelayed();
+	updateVoicePlaybackSpeed();
+}
+
+void Instance::seekRelative(int seconds) {
+	if (const auto data = getData(getActiveType())) {
+		if (const auto streamed = data->streamed.get()) {
+			const auto &info = streamed->instance.info();
+			const auto duration = info.audio.state.duration;
+			if (duration != kTimeUnknown) {
+				const auto currentPosition = info.audio.state.position;
+				const auto newPosition = std::clamp(
+					currentPosition + seconds * 1000,
+					0LL,
+					duration);
+				streamed->instance.play(streamingOptions(
+					streamed->id,
+					newPosition));
+				emitUpdate(data->type);
+			}
+		}
+	}
+}
+
 } // namespace Player
 } // namespace Media

Telegram/SourceFiles/media/view/media_view_playback_controls.cpp

@@ -20,6 +20,7 @@ For license and copyright information please follow this link:
 #include "ui/cached_round_corners.h"
 #include "lang/lang_keys.h"
 #include "styles/style_media_view.h"
+#include "core/shortcuts.h"
 
 namespace Media {
 namespace View {
@@ -131,6 +132,75 @@ PlaybackControls::PlaybackControls(
 		_playbackProgress->setValue(value, false);
 		handleSeekFinished(value);
 	});
+
+	Shortcuts::Requests(
+	) | rpl::start_with_next([=](not_null<Shortcuts::Request*> request) {
+		using Command = Shortcuts::Command;
+		request->check(Command::MediaPlay) && request->handle([=] {
+			_delegate->playbackControlsPlay();
+			return true;
+		});
+		request->check(Command::MediaPause) && request->handle([=] {
+			_delegate->playbackControlsPause();
+			return true;
+		});
+		request->check(Command::MediaPlayPause) && request->handle([=] {
+			if (_showPause) {
+				_delegate->playbackControlsPause();
+			} else {
+				_delegate->playbackControlsPlay();
+			}
+			return true;
+		});
+		request->check(Command::MediaStop) && request->handle([=] {
+			_delegate->playbackControlsStop();
+			return true;
+		});
+		request->check(Command::MediaPrevious) && request->handle([=] {
+			_delegate->playbackControlsPrevious();
+			return true;
+		});
+		request->check(Command::MediaNext) && request->handle([=] {
+			_delegate->playbackControlsNext();
+			return true;
+		});
+		request->check(Command::Shuffle) && request->handle([=] {
+			_delegate->playbackControlsShuffle();
+			return true;
+		});
+		request->check(Command::Repeat) && request->handle([=] {
+			_delegate->playbackControlsRepeat();
+			return true;
+		});
+		request->check(Command::VolumeUp) && request->handle([=] {
+			_delegate->playbackControlsVolumeUp();
+			return true;
+		});
+		request->check(Command::VolumeDown) && request->handle([=] {
+			_delegate->playbackControlsVolumeDown();
+			return true;
+		});
+		request->check(Command::PlaybackSpeedUp) && request->handle([=] {
+			_delegate->playbackControlsSpeedUp();
+			return true;
+		});
+		request->check(Command::PlaybackSpeedDown) && request->handle([=] {
+			_delegate->playbackControlsSpeedDown();
+			return true;
+		});
+		request->check(Command::Rewind) && request->handle([=] {
+			_delegate->playbackControlsRewind();
+			return true;
+		});
+		request->check(Command::FastForward) && request->handle([=] {
+			_delegate->playbackControlsFastForward();
+			return true;
+		});
+		request->check(Command::CloseMedia) && request->handle([=] {
+			_delegate->playbackControlsClose();
+			return true;
+		});
+	}, lifetime());
 }
 
 void PlaybackControls::handleSeekProgress(float64 progress) {