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))); }