public async void SetEqualizerUI(VLCEqualizer eq)
{
if (eq == null)
{
return;
}
await DispatchHelper.InvokeInUIThread(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();
}
});
}
async void OnSizeChanged(object sender, WindowSizeChangedEventArgs windowSizeChangedEventArgs)
{
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, () =>
{
OnPropertyChanged(nameof(MiniPlayerVisibilityMediaCenter));
});
}
public async Task SetMediaTransportControlsInfo(string artistName, string albumName, string trackName, string albumUri)
{
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, () =>
{
var updater = CommonTransportControlInit();
updater.Type = MediaPlaybackType.Music;
// Music metadata.
updater.MusicProperties.AlbumArtist = artistName;
updater.MusicProperties.Artist = artistName;
updater.MusicProperties.Title = trackName;
// Set the album art thumbnail.
// RandomAccessStreamReference is defined in Windows.Storage.Streams
Uri thumbnailUri;
if (albumUri != null && !string.IsNullOrEmpty(albumUri))
{
thumbnailUri = new Uri(albumUri);
}
else
{
thumbnailUri = new Uri("ms-appx:///Assets/Icons/music.png");
}
updater.Thumbnail = RandomAccessStreamReference.CreateFromUri(thumbnailUri);
// Update the system media transport controls.
updater.Update();
});
}
private async void DeviceAdded(DeviceWatcher sender, DeviceInformation args)
{
switch (Locator.SettingsVM.ExternalDeviceMode)
{
case ExternalDeviceMode.AskMe:
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal,
() => new ShowExternalDevicePage().Execute(args));
break;
case ExternalDeviceMode.IndexMedias:
await AskExternalDeviceIndexing(args.Id);
break;
case ExternalDeviceMode.SelectMedias:
await DispatchHelper.InvokeInUIThread(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 override async void Execute(object parameter)
{
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, () =>
{
Locator.NavigationService.Go(VLCPage.CreateNewPlaylistDialog);
});
}
private async void OnMediaTrackDeleted(TrackType type, int trackId)
{
if (type == TrackType.Video)
{
return;
}
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, () =>
{
ObservableCollection <DictionaryKeyValue> target;
if (type == TrackType.Audio)
{
target = AudioTracks;
OnPropertyChanged(nameof(CurrentAudioTrack));
}
else
{
target = Subtitles;
OnPropertyChanged(nameof(CurrentSubtitle));
}
var res = target.FirstOrDefault((item) => item.Id == trackId);
if (res != null)
{
target.Remove(res);
}
});
}
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.InvokeInUIThread(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.InvokeInUIThread(CoreDispatcherPriority.Low, () =>
{
OnPropertyChanged(nameof(Name));
});
}
}
async Task CleanupAndHide()
{
if (_mediaPlayer == null)
{
Hide();
return;
}
if (_mediaPlayer.isPlaying())
{
_mediaPlayer.stop();
}
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, () =>
{
ProgressRing.IsActive = false;
ProgressRing.Visibility = Visibility.Collapsed;
});
_mediaPlayer.eventManager().OnPositionChanged -= OnOnPositionChanged;
_mediaPlayer.eventManager().OnEndReached -= OnOnEndReached;
_mediaPlayer.eventManager().OnEncounteredError -= OnOnEncounteredError;
Media.VlcMedia = null;
_mediaPlayer = null;
_instance = null;
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, Hide);
}
private async void _selectedTracks_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
await DispatchHelper.InvokeInUIThread(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
OnPropertyChanged(nameof(IsTracksSelectedVisibility));
});
}
private async void Playback_MediaEndReach()
{
switch (PlaybackService.PlayingType)
{
case PlayingType.Music:
break;
case PlayingType.Video:
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Low, () =>
{
if (Locator.VideoPlayerVm.CurrentVideo != null)
{
Locator.VideoPlayerVm.CurrentVideo.TimeWatchedSeconds = 0;
}
});
if (Locator.VideoPlayerVm.CurrentVideo != null)
{
Locator.MediaLibrary.UpdateVideo(Locator.VideoPlayerVm.CurrentVideo);
}
break;
case PlayingType.NotPlaying:
break;
default:
break;
}
}
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.InvokeInUIThread(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.InvokeInUIThread(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.InvokeInUIThread(CoreDispatcherPriority.Normal, () =>
{
GroupedTracks = null;
LoadingStateTracks = LoadingState.NotLoaded;
});
break;
case MusicView.Playlists:
break;
default:
break;
}
}
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.InvokeInUIThread(CoreDispatcherPriority.Normal, () => Locator.MusicLibraryVM.AlbumClickedCommand.Execute(id));
}
else if (args.Contains("Artist"))
{
query = args.Replace("SecondaryTile-Artist-", "");
id = int.Parse(query);
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, () => Locator.MusicLibraryVM.ArtistClickedCommand.Execute(id));
}
}
catch (Exception e)
{
LogHelper.Log("Failed to open from secondary tile : " + e.ToString());
}
}
async Task InsertIntoGroupTrack(TrackItem track)
{
try
{
var supposedFirstChar = Strings.HumanizedArtistFirstLetter(track.Name);
var firstChar = GroupedTracks.FirstOrDefault(x => (string)x.Key == supposedFirstChar);
if (firstChar == null)
{
var newChar = new GroupItemList <TrackItem>(track)
{
Key = supposedFirstChar
};
if (GroupedTracks == null)
{
return;
}
int i = GroupedTracks.IndexOf(GroupedTracks.LastOrDefault(x => string.Compare((string)x.Key, (string)newChar.Key) < 0));
i++;
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, () => GroupedTracks.Insert(i, newChar));
}
else
{
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, () => firstChar.Add(track));
}
}
catch { }
}
static public async Task Handle <T>(ObservableCollection <T> collection, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Move ||
e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Replace)
{
LogHelper.Log("Unexpected collection change: " + e.Action);
return;
}
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, () =>
{
switch (e.Action)
{
case System.Collections.Specialized.NotifyCollectionChangedAction.Add:
foreach (T v in e.NewItems)
{
collection.Add(v);
}
break;
case System.Collections.Specialized.NotifyCollectionChangedAction.Reset:
collection.Clear();
break;
case System.Collections.Specialized.NotifyCollectionChangedAction.Remove:
foreach (T v in e.OldItems)
{
collection.Remove(v);
}
break;
}
});
}
private async void Albums_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
try
{
if (Locator.MediaLibrary.Albums.Count == 0 || Locator.MediaLibrary.Albums.Count == 1)
{
await DispatchHelper.InvokeInUIThread(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 { }
}
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.InvokeInUIThread(CoreDispatcherPriority.Normal, () =>
{
try
{
Locator.MediaLibrary.RemoveTrackInPlaylist(trackItem.Id,
Locator.MusicLibraryVM.CurrentTrackCollection.Id);
Locator.MusicLibraryVM.CurrentTrackCollection.Remove(trackItem);
}
catch (Exception exception)
{
LogHelper.Log(StringsHelper.ExceptionToString(exception));
}
});
}
await
DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal,
() => Locator.MusicLibraryVM.CurrentTrackCollection.SelectedTracks.Clear());
}
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.InvokeInUIThread(CoreDispatcherPriority.Normal, () => BackerCountries = backerCountries);
});
}
private async void UpdateTrack(IMediaItem media)
{
await DispatchHelper.InvokeInUIThread(Windows.UI.Core.CoreDispatcherPriority.Low, () =>
{
if (Track == null)
{
return;
}
if (media.Id == Track.Id && media.IsCurrentPlaying())
{
_previousBrush = NameTextBlock.Foreground;
NameTextBlock.Foreground = (Brush)Application.Current.Resources["MainColor"];
MusicLogo.Visibility = Visibility.Visible;
}
else
{
MusicLogo.Visibility = Visibility.Collapsed;
if (_previousBrush != null)
{
NameTextBlock.Foreground = _previousBrush;
}
}
});
}
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.InvokeInUIThread(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());
}
});
}
private async void NotifyCommandBarDisplayModeChanged()
{
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, () =>
{
OnPropertyChanged(nameof(CommandBarDisplayMode));
});
}
private async void Playback_MediaParsed(ParsedStatus parsedStatus)
{
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, () =>
{
OnPropertyChanged(nameof(Chapters));
OnPropertyChanged(nameof(CurrentChapter));
});
}
async void OnOnPositionChanged(float transcodingProgress)
{
var progress = (int)(transcodingProgress * 100) + "%";
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, () =>
{
Progress.Text = progress;
});
}
async Task OrderTracks()
{
_groupedTracks = Locator.MediaLibrary.OrderTracks();
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, () =>
{
OnPropertyChanged(nameof(GroupedTracks));
});
}
async Task OrderArtists()
{
_groupedArtists = Locator.MediaLibrary.OrderArtists();
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Low, () =>
{
OnPropertyChanged(nameof(GroupedArtists));
});
}
public async Task OrderAlbums()
{
_groupedAlbums = Locator.MediaLibrary.OrderAlbums(Locator.SettingsVM.AlbumsOrderType, Locator.SettingsVM.AlbumsOrderListing);
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Low, () =>
{
OnPropertyChanged(nameof(GroupedAlbums));
});
}
async Task CreateFolderCategory(RootFolderType type)
{
var category = new GroupItemList <FileExplorer>()
{
Key = type
};
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, () => FileExplorersGrouped.Add(category));
}
private async void VLCService_MediaListItemAdded(libVLCX.Media media, int index)
{
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, async() =>
{
var localNetwork = new VLCFileExplorerViewModel(media, RootFolderType.Network);
await AddToFolder(localNetwork);
});
}
private async void OnPlayingTypeChanged(PlayingType pType)
{
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, () =>
{
OnPropertyChanged(nameof(MiniPlayerVisibility));
OnPropertyChanged(nameof(MiniPlayerVisibilityMediaCenter));
});
}
async Task SearchAlbums(string tag)
{
_searchResultsAlbums = SearchHelpers.SearchAlbums(tag, _searchResultsAlbums);
await DispatchHelper.InvokeInUIThread(Windows.UI.Core.CoreDispatcherPriority.Low, () =>
{
OnPropertyChanged(nameof(SearchResultsAlbums));
OnPropertyChanged(nameof(ResultsCount));
});
}
async void OnOnItemAdded(RendererItem rendererItem)
{
LogHelper.Log("Found new rendererItem " + rendererItem.name() +
" can render audio " + rendererItem.canRenderAudio() +
" can render video " + rendererItem.canRenderVideo());
RendererItems.Add(rendererItem);
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, () => OnPropertyChanged(nameof(HasRenderer)));
}
