public TrackViewModel(IContentManagerService contentManagerService, IMusicPlayerService musicPlayerService, IWebService webService, PlaylistTrack playlistTrack)
{
_contentManagerService = contentManagerService;
_musicPlayerService = musicPlayerService;
_webService = webService;
PlaylistTrack = playlistTrack;
}
public ShellViewModel(IMainViewModel mainViewModel, IMusicPlayerService musicPlayerService)
{
DisplayName = "Tornado Player";
MainViewModel = mainViewModel;
_musicPlayerService = musicPlayerService;
}
private async Task TryPlayUrlAsync(IMusicPlayerService music, ITextChannel textChan, IUserMessage msg, IGuildUser guser, string url)
{
if (string.IsNullOrWhiteSpace(url))
{
return; // can be null or empty apparently
}
IGuildUser botUser = await guser.Guild.GetCurrentUserAsync();
await msg.RemoveReactionAsync(Emote, botUser);
bool played = await this.TryPlaySpotifyAsync(music, textChan, guser, url);
if (played)
{
return;
}
SearchResult result = await music.LavaRestClient.SearchTracksAsync(url);
List <ILavaTrack> tracks = result.Tracks.ToList();
switch (result.LoadType)
{
case LoadType.SearchResult:
case LoadType.TrackLoaded:
if (tracks.Count > 0)
{
await music.AddTrackAsync(guser.VoiceChannel, textChan, tracks[0]);
}
break;
case LoadType.PlaylistLoaded:
if (tracks.Count > 0)
{
await music.AddPlaylistAsync(guser.VoiceChannel, textChan, result.PlaylistInfo.Name, tracks);
}
break;
case LoadType.LoadFailed:
await this.SendNonPlayableContentAsync(guser, msg, textChan, url, "File is corrupted or does not have audio");
this.Logger.Nice("music player", ConsoleColor.Yellow, $"Could add/play track from playable content ({url})");
break;
case LoadType.NoMatches:
await this.SendNonPlayableContentAsync(guser, msg, textChan, url, "Could not find the track to be added/played");
this.Logger.Nice("music player", ConsoleColor.Yellow, $"Could not find match for playable content ({url})");
break;
default:
await this.SendNonPlayableContentAsync(guser, msg, textChan, url, "Unkown error");
this.Logger.Nice("music player", ConsoleColor.Yellow, $"Unknown error ({url})");
break;
}
}
public RecordOptionsViewModel(IEventAggregator eventAggregator, ISongsService songsService, IMusicPlayerService musicPlayerService)
: base(eventAggregator)
{
Song = new Song();
Difficulty = Difficulty.Easy;
_songsService = songsService;
_musicPlayerService = musicPlayerService;
}
public PlaybarViewModel(IEventAggregator eventAggregator, IDataService dataService, IHotKeyService hotKeyService, IMusicPlayerService musicPlayerService)
{
_dataService = dataService;
_musicPlayerService = musicPlayerService;
eventAggregator.Subscribe(this);
_musicPlayerService.ProgressUpdated += (sender, e) =>
{
if (_syncPlayer)
{
_currentProgress = e.NewProgress;
NotifyOfPropertyChange(nameof(CurrentProgress));
}
ActivePlaylist.Playlist.TrackProgress = e.NewProgress;
};
_musicPlayerService.TrackChanged += (sender, e) => NotifyOfPropertyChange(nameof(Duration));
_musicPlayerService.Paused += (sender, e) => NotifyOfPropertyChange(nameof(Playing));
_musicPlayerService.Played += (sender, e) => NotifyOfPropertyChange(nameof(Playing));
_musicPlayerService.MediaEnded += (sender, e) =>
{
if (Loop)
{
_musicPlayerService.Stop();
_musicPlayerService.Play();
}
else
{
ActivePlaylist.SelectNext();
}
};
hotKeyService.HotKeyActuated += (sender, e) =>
{
switch (e.Shortcut)
{
case Shortcut.SkipBackward:
Previous();
break;
case Shortcut.SkipForward:
Next();
break;
}
};
PlaybarState playbarState = dataService.Load(Constants.DataStoreNames.PlaybarState, () => new PlaybarState(0.5, false));
Volume = playbarState.Volume;
Loop = playbarState.Loop;
}
public ManagedPlaylistViewModel
(
IViewModelFactory viewModelFactory,
IEventAggregator eventAggregator,
IContentManagerService contentManagerService,
IMusicPlayerService musicPlayerService,
Playlist playlist
)
: base(viewModelFactory, eventAggregator, contentManagerService, musicPlayerService, playlist)
{
_viewModelFactory = viewModelFactory;
}
public CustomPlaylistViewModel
(
IViewModelFactory viewModelFactory,
IEventAggregator eventAggregator,
IContentManagerService contentManagerService,
IMusicPlayerService musicPlayerService,
Playlist playlist
)
: base(viewModelFactory, eventAggregator, contentManagerService, musicPlayerService, playlist)
{
Items.AddRange(playlist.Tracks.Select(track => viewModelFactory.MakeViewModel <ITrackViewModel>(track)));
}
private async Task <bool> TryPlaySpotifyAsync(IMusicPlayerService music, ITextChannel textChan, IGuildUser guser, string url)
{
SpotifyTrack track = await this.SpotifyToTrackAsync(url);
if (track == null)
{
return(false);
}
await music.AddTrackAsync(guser.VoiceChannel, textChan, track);
return(true);
}
public PlaylistViewModel(ITrackFactory trackFactory, IMusicPlayerService musicPlayerService)
{
_musicPlayerService = musicPlayerService;
Tracks = new BindableCollection <ITrackViewModel>(_musicPlayerService.Tracks.Select(trackFactory.MakeTrackViewModel));
_musicPlayerService.PlaylistLoaded += (sender, e) =>
{
Tracks.Clear();
Tracks.AddRange(e.Tracks.Select(trackFactory.MakeTrackViewModel));
};
_musicPlayerService.TrackChanged += (sender, e) => NotifyOfPropertyChange(() => SelectedTrackIndex);
}
private static async Task OnPlayReactionAsync(PaginatorSenderService sender, Paginator <object> paginator, Cacheable <IUserMessage, ulong> cache, ISocketMessageChannel chan, SocketReaction reaction)
{
if (!(chan is IGuildChannel) || reaction.User.Value == null)
{
return;
}
IGuildUser guser = (IGuildUser)reaction.User.Value;
if (guser.VoiceChannel == null)
{
return;
}
ITextChannel textChan = (ITextChannel)chan;
IMusicPlayerService music = sender.ServiceManager.GetService <IMusicPlayerService>("Music");
switch (paginator.CurrentValue)
{
case ILavaTrack track:
await music.AddTrackAsync(guser.VoiceChannel, textChan, track);
await chan.DeleteMessageAsync(paginator.Message);
break;
case string url:
if (string.IsNullOrWhiteSpace(url))
{
return;
}
SearchResult result = await music.LavaRestClient.SearchTracksAsync(url);
List <ILavaTrack> tracks = result.Tracks.ToList();
if (tracks.Count > 0)
{
ILavaTrack tr = tracks[0];
await music.AddTrackAsync(guser.VoiceChannel, textChan, tr);
await chan.DeleteMessageAsync(paginator.Message);
}
else
{
await sender.MessageSender.SendWarningAsync(chan, "music player", $"Could not add the following Url to the queue\n{url}");
}
break;
}
}
public Game(IEventAggregator eventAggregator, IMusicPlayerService musicPlayerService)
{
MusicPlayerService = musicPlayerService;
_eventAggregator = eventAggregator;
eventAggregator.Subscribe(this);
_missedTimer.Elapsed += lookForMissedNotes_Tick;
Player1 = new Player()
{
PlayerID = PlayerID.Player1
};
Player2 = new Player()
{
PlayerID = PlayerID.Player2
};
}
public PlaybarViewModel(IMusicPlayerService musicPlayerService)
{
_musicPlayerService = musicPlayerService;
_musicPlayerService.ProgressUpdated += (sender, e) =>
{
if (_syncPlayer)
{
_syncPlayer = false;
CurrentProgress = e.NewProgress;
_syncPlayer = true;
}
};
_musicPlayerService.TrackChanged += (sender, e) => NotifyOfPropertyChange(() => Duration);
_musicPlayerService.PlaylistLoaded += (sender, e) => NotifyOfPropertyChange(() => Shuffle);
_musicPlayerService.Paused += (sender, e) => NotifyOfPropertyChange(() => Playing);
_musicPlayerService.Played += (sender, e) => NotifyOfPropertyChange(() => Playing);
}
private async Task OnReaction(Cacheable <IUserMessage, ulong> cache, ISocketMessageChannel chan, SocketReaction reaction)
{
if (!IsValidReaction(chan, reaction))
{
return;
}
IGuildUser guser = (IGuildUser)reaction.User.Value;
if (guser.VoiceChannel == null)
{
return;
}
ITextChannel textChan = (ITextChannel)chan;
IUserMessage msg = await cache.GetOrDownloadAsync();
if (!this.IsValidMessage(msg))
{
return;
}
IMusicPlayerService music = this.ServiceManager.GetService <IMusicPlayerService>("Music");
foreach (IEmbed embed in msg.Embeds)
{
if (IsValidUrl(embed.Url))
{
await this.TryPlayUrlAsync(music, textChan, msg, guser, embed.Url);
}
else if (embed.Video.HasValue)
{
await this.TryPlayUrlAsync(music, textChan, msg, guser, embed.Video.Value.Url);
}
}
foreach (IAttachment attachment in msg.Attachments)
{
if (attachment.IsPlayableAttachment())
{
await this.TryPlayUrlAsync(music, textChan, msg, guser, attachment.Url);
}
}
}
public async Task Execute(IJobExecutionContext context)
{
JobDataMap dataMap = context.JobDetail.JobDataMap;
IServiceManager serviceManager = (IServiceManager)dataMap["ServiceManager"];
DiscordShardedClient discordClient = (DiscordShardedClient)dataMap["DiscordClient"];
IMusicPlayerService music = serviceManager.GetService <IMusicPlayerService>("Music");
IRestartService restart = serviceManager.GetService <IRestartService>("Restart");
await music.DisconnectAllPlayersAsync("Weekly update on-going, disconnecting", true);
SocketChannel updateChan = discordClient.GetChannel(Config.Instance.Discord.UpdateChannelID);
if (updateChan != null)
{
await restart.WarnChannelAsync(updateChan, "Updating to the latest changes...");
}
await restart.RestartAsync();
}
private async void OnReconnectRequested(RemoteProcess proc, string publicIp)
{
if (string.IsNullOrWhiteSpace(publicIp) || proc.Name != "Watchdog")
{
return;
}
this.Log($"Remote nodes reconnected with IP: {publicIp}");
IMusicPlayerService music = this.ServiceManager.GetService <IMusicPlayerService>("Music");
await music.DisconnectAllPlayersAsync("Network issues detected, disconnecting to prevent further bugs");
await music.StartAsync(publicIp);
SocketChannel bugChan = this.DiscordClient.GetChannel(Config.Instance.Discord.BugReportChannelID);
if (bugChan != null)
{
await this.MessageSender.SendWarningAsync(bugChan, "network errors", "Reconnected to lavalink remote server");
}
}
public static void ShowCurrentTimeInsteadPoints(Storyboard animation, IMusicPlayerService musciPlayerService, GameView view)
{
#if DEBUG_TIMING
new Thread(new ThreadStart(() =>
{
while (true)
{
if (Application.Current == null)
{
return;
}
Application.Current.Dispatcher.BeginInvoke(new System.Action(() =>
{
var time = musciPlayerService.CurrentTime;
view.p1PointsBar.Points = "S: " + time.TotalSeconds.ToString("N2") + " | A: " + animation.GetCurrentTime().TotalSeconds.ToString("N2");
}));
Thread.Sleep(50);
}
})).Start();
#endif
}
private protected PlaylistViewModel(IViewModelFactory viewModelFactory, IEventAggregator eventAggregator, IContentManagerService contentManagerService, IMusicPlayerService musicPlayerService, Playlist playlist)
{
_viewModelFactory = viewModelFactory;
_contentManagerService = contentManagerService;
_musicPlayerService = musicPlayerService;
_tracksView = CollectionViewSource.GetDefaultView(Items);
DisplayName = playlist.Name;
Playlist = playlist;
SelectedIndex = Playlist.SelectedTrackIndex;
_tracksView.SortDescriptions.Add(new SortDescription(nameof(ITrackViewModel.PlaylistTrack), ListSortDirection.Ascending));
eventAggregator.Subscribe(this);
Playlist.PropertyChanged += (sender, e) =>
{
if (e.PropertyName == nameof(Playlist.IsShuffled))
{
_tracksView.Refresh();
}
};
}
public RecordSequenceViewModel(IEventAggregator eventAggregator, IMusicPlayerService musicPlayerService)
: base(eventAggregator)
{
_musicPlayerService = musicPlayerService;
}
