private async void _selectedTracks_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
await DispatchHelper.InvokeAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
OnPropertyChanged(nameof(IsTracksSelectedVisibility));
});
}
Task InitializeArtists()
{
return(Task.Run(async() =>
{
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
Locator.MainVM.InformationText = Strings.LoadingMusic;
LoadingStateArtists = LoadingState.Loading;
GroupedArtists = new ObservableCollection <GroupItemList <ArtistItem> >();
});
if (Locator.MediaLibrary.Artists != null)
{
Locator.MediaLibrary.Artists.CollectionChanged += Artists_CollectionChanged;
}
await Locator.MediaLibrary.LoadArtistsFromDatabase();
var recommendedArtists = await Locator.MediaLibrary.LoadRandomArtistsFromDatabase();
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
RecommendedArtists = recommendedArtists;
Locator.MainVM.InformationText = String.Empty;
LoadingStateArtists = LoadingState.Loaded;
OnPropertyChanged(nameof(IsMusicLibraryEmpty));
OnPropertyChanged(nameof(MusicLibraryEmptyVisible));
});
}));
}
async Task InsertIntoGroupArtist(ArtistItem artist)
{
try
{
var supposedFirstChar = Strings.HumanizedArtistFirstLetter(artist.Name);
var firstChar = GroupedArtists.FirstOrDefault(x => (string)x.Key == supposedFirstChar);
if (firstChar == null)
{
var newChar = new GroupItemList <ArtistItem>(artist)
{
Key = supposedFirstChar
};
if (GroupedArtists == null)
{
return;
}
int i = GroupedArtists.IndexOf(GroupedArtists.LastOrDefault(x => string.Compare((string)x.Key, (string)newChar.Key) < 0));
i++;
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () => GroupedArtists.Insert(i, newChar));
}
else
{
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () => firstChar.Add(artist));
}
}
catch { }
}
public SpecialThanksViewModel()
{
var _ = ThreadPool.RunAsync(async aa =>
{
List <Backer> backers = await ParseBackers();
var backerDictionary = new SortedDictionary <string, List <string> >();
foreach (Backer backer in backers)
{
if (!backerDictionary.ContainsKey(backer.Country))
{
backerDictionary.Add(backer.Country, new List <string>());
}
backerDictionary[backer.Country].Add(backer.Name);
}
var backerCountries = new ObservableCollection <BackerCountryViewModel>();
foreach (string countryName in backerDictionary.Keys)
{
if (!string.IsNullOrWhiteSpace(countryName))
{
string flagPath = "ms-appx:///Assets/Flags/flag_of_" + countryName.Replace(" ", "_") + ".png";
var backerCountry = new BackerCountryViewModel(countryName, new Uri(flagPath));
backerCountry.BackerNames = new List <string>(backerDictionary[countryName]);
backerCountries.Add(backerCountry);
}
}
await DispatchHelper.InvokeAsync(() => BackerCountries = backerCountries);
});
}
public async Task SetMediaTransportControlsInfo(string title)
{
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
try
{
if (_systemMediaTransportControls == null)
{
return;
}
LogHelper.Log("PLAYVIDEO: Updating SystemMediaTransportControls");
SystemMediaTransportControlsDisplayUpdater updater = _systemMediaTransportControls.DisplayUpdater;
updater.Type = MediaPlaybackType.Video;
_systemMediaTransportControls.IsPreviousEnabled = false;
_systemMediaTransportControls.IsNextEnabled = false;
//Video metadata
updater.VideoProperties.Title = title;
//TODO: add full thumbnail suport
updater.Thumbnail = null;
updater.Update();
}
catch (Exception e)
{
LogHelper.Log(StringsHelper.ExceptionToString(e));
}
});
}
public override async void Execute(object parameter)
{
var selectedTracks = Locator.MusicLibraryVM.CurrentTrackCollection.SelectedTracks;
foreach (var selectedItem in selectedTracks)
{
var trackItem = selectedItem as TrackItem;
if (trackItem == null)
{
continue;
}
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, async() =>
{
try
{
await
Locator.MediaLibrary.RemoveTrackInPlaylist(trackItem.Id,
Locator.MusicLibraryVM.CurrentTrackCollection.Id);
Locator.MusicLibraryVM.CurrentTrackCollection.Remove(trackItem);
}
catch (Exception exception)
{
LogHelper.Log(StringsHelper.ExceptionToString(exception));
}
});
}
await
DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal,
() => Locator.MusicLibraryVM.CurrentTrackCollection.SelectedTracks.Clear());
}
private async void onDefaultAudioRenderDeviceChanged(object sender, DefaultAudioRenderDeviceChangedEventArgs args)
{
if (args.Role != AudioDeviceRole.Default || args.Id == AudioDeviceID)
{
return;
}
AudioDeviceID = args.Id;
// If we don't have an instance yet, no need to fetch the audio client as it will be done upon
// instance creation.
if (Instance == null)
{
return;
}
await DispatchHelper.InvokeAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
// Always fetch the new audio client, as we always assign it when starting a new playback
AudioClient = new AudioDeviceHandler(AudioDeviceID);
// But if a playback is in progress, inform VLC backend that we changed device
if (MediaPlayer != null)
{
MediaPlayer.outputDeviceSet(AudioClient.audioClient());
}
});
}
public async Task PopulateAlbumsWithTracks(ArtistItem artist)
{
try
{
var albums = musicDatabase.LoadAlbumsFromIdWithTracks(artist.Id).ToObservable();
var groupedAlbums = new ObservableCollection <GroupItemList <TrackItem> >();
var groupQuery = from album in albums
orderby album.Name
group album.Tracks by album into a
select new { GroupName = a.Key, Items = a };
foreach (var g in groupQuery)
{
GroupItemList <TrackItem> tracks = new GroupItemList <TrackItem>();
tracks.Key = g.GroupName;
foreach (var track in g.Items)
{
tracks.AddRange(track);
}
groupedAlbums.Add(tracks);
}
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
artist.Albums = albums;
artist.AlbumsGrouped = groupedAlbums;
});
}
catch { }
}
async Task PerformMediaLibraryIndexing()
{
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Low, () => MediaLibraryIndexingState = LoadingState.Loading);
StorageFolder folder = await FileUtils.GetLocalStorageMediaFolder();
await MediaLibraryHelper.ForeachSupportedFile(folder, async (IReadOnlyList <StorageFile> files) => await DiscoverMediaItems(files));
await MediaLibraryHelper.ForeachSupportedFile(KnownFolders.VideosLibrary, async (IReadOnlyList <StorageFile> files) => await DiscoverMediaItems(files));
await MediaLibraryHelper.ForeachSupportedFile(KnownFolders.MusicLibrary, async (IReadOnlyList <StorageFile> files) => await DiscoverMediaItems(files));
await MediaLibraryHelper.ForeachSupportedFile(KnownFolders.CameraRoll, async (IReadOnlyList <StorageFile> files) => await DiscoverMediaItems(files, true));
// Cortana gets all those artists, albums, songs names
var artists = LoadArtists(null);
if (artists != null)
{
await CortanaHelper.SetPhraseList("artistName", artists.Where(x => !string.IsNullOrEmpty(x.Name)).Select(x => x.Name).ToList());
}
var albums = LoadAlbums(null);
if (albums != null)
{
await CortanaHelper.SetPhraseList("albumName", albums.Where(x => !string.IsNullOrEmpty(x.Name)).Select(x => x.Name).ToList());
}
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Low, () => MediaLibraryIndexingState = LoadingState.Loaded);
}
public async Task OnNavigatedFrom()
{
ResetLibrary();
switch (_musicView)
{
case MusicView.Albums:
if (Locator.MediaLibrary.Albums != null)
{
Locator.MediaLibrary.Albums.CollectionChanged -= Albums_CollectionChanged;
Locator.MediaLibrary.Albums.Clear();
}
RecommendedAlbums?.Clear();
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
GroupedAlbums = null;
LoadingStateAlbums = LoadingState.NotLoaded;
});
break;
case MusicView.Artists:
if (Locator.MediaLibrary.Artists != null)
{
Locator.MediaLibrary.Artists.CollectionChanged -= Artists_CollectionChanged;
Locator.MediaLibrary.Artists.Clear();
}
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
GroupedArtists = null;
LoadingStateArtists = LoadingState.NotLoaded;
});
break;
case MusicView.Songs:
if (Locator.MediaLibrary.Tracks != null)
{
Locator.MediaLibrary.Tracks.CollectionChanged -= Tracks_CollectionChanged;
Locator.MediaLibrary.Tracks.Clear();
}
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, async() =>
{
await OrderTracks();
LoadingStateTracks = LoadingState.NotLoaded;
});
break;
case MusicView.Playlists:
break;
default:
break;
}
}
public async Task RemoveMediaFromCollectionAndDatabase(IMediaItem media)
{
if (media is TrackItem)
{
var trackItem = media as TrackItem;
var trackDB = LoadTrackById(trackItem.Id);
if (trackDB == null)
{
return;
}
musicDatabase.Remove(trackDB);
var albumDB = LoadAlbum(trackItem.AlbumId);
if (albumDB == null)
{
return;
}
var albumTracks = LoadTracksByAlbumId(albumDB.Id);
if (!albumTracks.Any())
{
Albums.Remove(Albums.FirstOrDefault(x => x.Id == trackItem.AlbumId));
musicDatabase.Remove(albumDB);
}
var artistDB = LoadArtist(trackItem.ArtistId);
if (artistDB == null)
{
return;
}
var artistAlbums = LoadAlbums(artistDB.Id);
if (!artistAlbums.Any())
{
Artists.Remove(Artists.FirstOrDefault(x => x.Id == trackItem.ArtistId));
musicDatabase.Remove(artistDB);
}
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
Tracks.Remove(Tracks.FirstOrDefault(x => x.Path == trackItem.Path));
var playingTrack = Locator.MediaPlaybackViewModel.PlaybackService.Playlist.FirstOrDefault(x => x.Id == trackItem.Id);
if (playingTrack != null)
{
Locator.MediaPlaybackViewModel.PlaybackService.Playlist.Remove(playingTrack);
}
});
}
else if (media is VideoItem)
{
var videoItem = media as VideoItem;
var videoDb = LoadVideoById(videoItem.Id);
if (videoDb == null)
{
return;
}
videoDatabase.Remove(videoDb);
Videos.Remove(Videos.FirstOrDefault(x => x.Path == videoItem.Path));
}
}
private async void CameraRoll_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
OnPropertyChanged(nameof(CameraRoll));
});
}
Task InitializeVideos()
{
return(Task.Run(async() =>
{
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
Locator.MainVM.InformationText = Strings.Loading;
LoadingStateAllVideos = LoadingState.Loading;
});
if (Locator.MediaLibrary.Videos != null)
{
Locator.MediaLibrary.Videos.CollectionChanged += Videos_CollectionChanged;
}
await Locator.MediaLibrary.LoadVideosFromDatabase();
await Locator.MediaLibrary.LoadViewedVideosFromDatabase();
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
OnPropertyChanged(nameof(ViewedVideos));
OnPropertyChanged(nameof(Videos));
Locator.MainVM.InformationText = String.Empty;
LoadingStateAllVideos = LoadingState.Loaded;
});
}));
}
async Task Initialize()
{
if (storageItem != null)
{
var props = await storageItem.GetBasicPropertiesAsync();
var size = await storageItem.GetSizeAsync();
var sizeString = "";
if (size > 0)
{
sizeString = size.GetSizeString();
}
name = storageItem.DisplayName;
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Low, () =>
{
lastModified = props.DateModified.ToString("dd/MM/yyyy hh:mm");
sizeHumanizedString = sizeString;
OnPropertyChanged(nameof(LastModified));
OnPropertyChanged(nameof(SizeHumanizedString));
OnPropertyChanged(nameof(SizeAvailable));
OnPropertyChanged(nameof(Name));
});
}
else if (media != null)
{
this.name = media.meta(MediaMeta.Title);
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Low, () =>
{
OnPropertyChanged(nameof(Name));
});
}
}
public override async void Execute(object parameter)
{
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
Locator.NavigationService.Go(VLCPage.CreateNewPlaylistDialog);
});
}
private Task ExternalDeviceService_MustIndexExternalDevice(string deviceId)
{
return(Task.Run(async() =>
{
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Low, () => MediaLibraryIndexingState = LoadingState.Loading);
StorageFolder folder;
// Windows.Devices.Portable.StorageDevice.FromId blocks forever on Xbox... so work around
if (Helpers.DeviceHelper.GetDeviceType() != DeviceTypeEnum.Xbox &&
Helpers.DeviceHelper.GetDeviceType() != DeviceTypeEnum.Phone)
{
folder = Windows.Devices.Portable.StorageDevice.FromId(deviceId);
}
else
{
var devices = KnownFolders.RemovableDevices;
var allFolders = await devices.GetFoldersAsync();
folder = allFolders.Last();
}
if (!StorageApplicationPermissions.FutureAccessList.CheckAccess(folder))
{
StorageApplicationPermissions.FutureAccessList.Add(folder);
}
await MediaLibraryHelper.ForeachSupportedFile(folder, async(IReadOnlyList <StorageFile> files) => await DiscoverMediaItems(files));
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Low, () => MediaLibraryIndexingState = LoadingState.Loaded);
}));
}
private async void Playback_MediaSet(IMediaItem media)
{
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
OnPropertyChanged(nameof(IsMiniPlayerVisible));
OnPropertyChanged(nameof(CurrentTrack));
});
if (!(media is TrackItem))
{
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
CurrentAlbum = null;
CurrentArtist = null;
});
return;
}
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, async() =>
{
await SetCurrentArtist();
await SetCurrentAlbum();
await UpdatePlayingUI();
await Scrobble();
await UpdateWindows8UI();
if (CurrentArtist != null)
{
CurrentArtist.PlayCount++;
await Locator.MediaLibrary.Update(CurrentArtist);
}
});
}
// Remove items that are no longer reachable.
public async Task CleanMediaLibrary()
{
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Low, () => MediaLibraryIndexingState = LoadingState.Loading);
// Clean videos
var videos = LoadVideos(x => true);
foreach (var video in videos)
{
try
{
var file = await StorageFile.GetFileFromPathAsync(video.Path);
}
catch
{
await RemoveMediaFromCollectionAndDatabase(video);
}
}
// Clean tracks
var tracks = LoadTracks();
foreach (var track in tracks)
{
try
{
var file = await StorageFile.GetFileFromPathAsync(track.Path);
}
catch
{
await RemoveMediaFromCollectionAndDatabase(track);
}
}
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Low, () => MediaLibraryIndexingState = LoadingState.Loaded);
}
public static async Task LoadImageToMemory(AlbumItem item)
{
/*
* Normally, We would need more tight calls to try and make sure that the file
* exists in our database. However, since this is on the UI thread, we can't do that.
* Since binding images directly through XAML leads to blocked files when we
* need to delete them, we have to load them up manually. This should be enough
* of a check, for now, to make sure images load correctly.
*/
bool fileExists = item.IsPictureLoaded;
try
{
if (fileExists)
{
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Low, () => item.AlbumImage = new BitmapImage(new Uri(item.AlbumCoverFullUri)));
}
}
catch (Exception)
{
LogHelper.Log("Error getting album picture : " + item.Name);
}
if (!fileExists)
{
try
{
await Locator.MediaLibrary.FetchAlbumCoverOrWaitAsync(item);
}
catch { }
}
}
public async Task AddTvShow(VideoItem episode)
{
episode.IsTvShow = true;
try
{
TvShow show = Shows.FirstOrDefault(x => x.ShowTitle == episode.ShowTitle);
if (show == null)
{
// Generate a thumbnail for the show
await Locator.MediaLibrary.FetchVideoThumbnailOrWaitAsync(episode);
show = new TvShow(episode.ShowTitle);
show.Episodes.Add(episode);
Shows.Add(show);
}
else
{
if (show.Episodes.FirstOrDefault(x => x.Id == episode.Id) == null)
{
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () => show.Episodes.Add(episode));
}
}
}
catch (Exception e)
{
LogHelper.Log(StringsHelper.ExceptionToString(e));
}
}
public async Task LoadTracks(IReadOnlyList <StorageFile> tracks)
{
if (tracks == null)
{
return;
}
int i = 0;
foreach (var track in tracks)
{
i++;
var trackItem = await GetInformationsFromMusicFile.GetTrackItemFromFile(track, Artist, Name, i, ArtistId, Id);
var databaseTrack = await _trackDataRepository.LoadTrack(ArtistId, Id, trackItem.Name);
if (databaseTrack == null)
{
await _trackDataRepository.Add(trackItem);
Tracks.Add(trackItem);
}
await DispatchHelper.InvokeAsync(() =>
{
Locator.MusicLibraryVM.Track.Add(trackItem);
OnPropertyChanged("Track");
});
}
}
async void UpdateTrack(IMediaItem media)
{
await DispatchHelper.InvokeAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () =>
{
if (Track == null)
{
return;
}
if (Locator.MediaPlaybackViewModel.PlaybackService.CurrentMedia == -1 || Locator.MediaPlaybackViewModel.PlaybackService.Playlist?.Count == 0)
{
return;
}
if (Track.IsCurrentPlaying())
{
previousBrush = NameTextBlock.Foreground;
NameTextBlock.Foreground = (Brush)App.Current.Resources["MainColor"];
}
else
{
if (previousBrush != null)
{
NameTextBlock.Foreground = previousBrush;
}
}
});
}
public async void SetEqualizerUI(VLCEqualizer eq)
{
if (eq == null)
{
return;
}
await DispatchHelper.InvokeAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
for (int i = 0; i < eq.Amps.Count; i++)
{
var anim = new DoubleAnimation();
anim.Duration = TimeSpan.FromMilliseconds(600);
anim.EasingFunction = new ExponentialEase()
{
EasingMode = EasingMode.EaseOut,
Exponent = 3,
};
anim.To = Convert.ToDouble(eq.Amps[i]);
anim.EnableDependentAnimation = true;
Storyboard.SetTarget(anim, RootGrid.Children[i]);
Storyboard.SetTargetProperty(anim, nameof(Slider.Value));
var sb = new Storyboard();
sb.Children.Add(anim);
sb.Begin();
}
});
}
private async Task LaunchTheApp(bool disableConsumingTasks = false)
{
Dispatcher = Window.Current.Dispatcher;
Window.Current.Content = new MainPage();
Window.Current.Activate();
await SplitShell.TemplateApplied.Task;
SetLanguage();
SetShellDecoration();
await LoadLibraries(disableConsumingTasks).ConfigureAwait(false);
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
Locator.NavigationService.Go(Locator.SettingsVM.HomePage);
if (Locator.SettingsVM.MediaCenterMode)
{
Locator.NavigationService.Go(VLCPage.MainPageXBOX);
}
else
{
App.SplitShell.FooterContent = new CommandBarBottom();
}
}).ConfigureAwait(false);
}
private async void Albums_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
try
{
if (Locator.MediaLibrary.Albums?.Count == 0 || Locator.MediaLibrary.Albums?.Count == 1)
{
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
OnPropertyChanged(nameof(IsMusicLibraryEmpty));
OnPropertyChanged(nameof(MusicLibraryEmptyVisible));
});
}
if (e.Action == NotifyCollectionChangedAction.Add && e.NewItems.Count > 0)
{
foreach (var newItem in e.NewItems)
{
var album = (AlbumItem)newItem;
await InsertIntoGroupAlbum(album);
}
}
else
{
await OrderAlbums();
}
}
catch { }
}
private async Task RedirectFromSecondaryTile(string args)
{
try
{
var query = "";
int id;
if (args.Contains("Album"))
{
query = args.Replace("SecondaryTile-Album-", "");
id = int.Parse(query);
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () => Locator.MusicLibraryVM.AlbumClickedCommand.Execute(id));
}
else if (args.Contains("Artist"))
{
query = args.Replace("SecondaryTile-Artist-", "");
id = int.Parse(query);
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () => Locator.MusicLibraryVM.ArtistClickedCommand.Execute(id));
}
}
catch (Exception e)
{
LogHelper.Log("Failed to open from secondary tile : " + e.ToString());
}
}
async Task OrderTracks()
{
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
OnPropertyChanged(nameof(GroupedTracks));
});
}
private async void MediaControl_PlayPressed(object sender, object e)
{
await DispatchHelper.InvokeAsync(() =>
{
Play();
});
}
private async void DeviceAdded(DeviceWatcher sender, DeviceInformation args)
{
switch (Locator.SettingsVM.ExternalDeviceMode)
{
case ExternalDeviceMode.AskMe:
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal,
() => new ShowExternalDevicePage().Execute(args));
break;
case ExternalDeviceMode.IndexMedias:
await AskExternalDeviceIndexing(args.Id);
break;
case ExternalDeviceMode.SelectMedias:
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, async() =>
{
await AskContentToCopy(args.Id);
});
break;
case ExternalDeviceMode.DoNothing:
break;
default:
throw new NotImplementedException();
}
if (ExternalDeviceAdded != null)
{
await ExternalDeviceAdded(sender, args.Id);
}
}
public static async Task AddTvShow(String name, VideoItem episode)
{
try
{
TvShow show = Locator.VideoLibraryVM.Shows.FirstOrDefault(x => x.ShowTitle == name);
if (show == null)
{
show = new TvShow(name);
await DispatchHelper.InvokeAsync(() =>
{
show.Episodes.Add(episode);
Locator.VideoLibraryVM.Shows.Add(show);
if (Locator.VideoLibraryVM.Shows.Count == 1)
{
Locator.VideoLibraryVM.CurrentShow = Locator.VideoLibraryVM.Shows[0];
}
});
}
else
{
if (show.Episodes.FirstOrDefault(x => x.Id == episode.Id) == null)
{
await DispatchHelper.InvokeAsync(() => show.Episodes.Add(episode));
}
}
}
catch (Exception e)
{
ExceptionHelper.CreateMemorizedException("VideoLibaryManagement.AddTvShow", e);
}
}
