public LoginViewModel(IPageSwitchingService pageSwitchingService, IEventAggregator eventAggregator, IAudioStationSession audioStationSession, IOpenSynoSettings synoSettings, ISignInService signInService, IPlaybackService playbackService) { if (pageSwitchingService == null) throw new ArgumentNullException("pageSwitchingService"); if (eventAggregator == null) throw new ArgumentNullException("eventAggregator"); if (audioStationSession == null) throw new ArgumentNullException("audioStationSession"); SignInCommand = new DelegateCommand(OnSignIn); _pageSwitchingService = pageSwitchingService; _eventAggregator = eventAggregator; _audioStationSession = audioStationSession; _synoSettings = synoSettings; _signInService = signInService; _signInService.SignInCompleted += OnSignInCompleted; // Unregister the registered events to make sure we don't execute the event handler twice in case of exceptions _signInService.CheckTokenValidityCompleted += (o, e) => { if (e.Error != null) { _signInService.CheckTokenValidityCompleted -= OnCheckTokenValidityCompleted; } }; _playbackService = playbackService; UserName = _synoSettings.UserName; UseSsl = _synoSettings.UseSsl; Password = _synoSettings.Password; Host = _synoSettings.Host; Port = _synoSettings.Port; }
public LastFmScrobblingService(IPlaybackService playbackService) { this.playbackService = playbackService; this.playbackService.PlaybackSuccess += PlaybackService_PlaybackSuccess; this.playbackService.PlaybackProgressChanged += PlaybackService_PlaybackProgressChanged; this.playbackService.PlaybackSkipped += PlaybackService_PlaybackSkipped; this.username = SettingsClient.Get <string>("Lastfm", "Username"); this.password = SettingsClient.Get <string>("Lastfm", "Password"); this.sessionKey = SettingsClient.Get <string>("Lastfm", "Key"); if (!string.IsNullOrEmpty(this.username) && !string.IsNullOrEmpty(this.password) && !string.IsNullOrEmpty(this.sessionKey)) { this.signInState = SignInState.SignedIn; } else { this.signInState = SignInState.SignedOut; } }
public ApplicationViewModel(ISyllablesService syllablesService, ITranscriptionService transcriptionService, IPlaybackService playbackService) { Guard.NotNull(syllablesService, "syllablesService"); Guard.NotNull(transcriptionService, "transcriptionService"); Guard.NotNull(playbackService, "playbackService"); this._syllablesService = syllablesService; this._transcriptionService = transcriptionService; this._playbackService = playbackService; this._playbackService.PlaybackCompleted += this.PlaybackServiceOnPlaybackCompleted; this._inputText = ""; this._isInputTextBoxEnabled = true; this._outputMode = OutputMode.Transcription; this.OutputText = ""; this._words = new List <string>(); this.Commands = new ApplicationViewModelCommands(this); }
public ApplicationViewModel(ISyllablesService syllablesService, ITranscriptionService transcriptionService, IPlaybackService playbackService) { Guard.NotNull(syllablesService, "syllablesService"); Guard.NotNull(transcriptionService, "transcriptionService"); Guard.NotNull(playbackService, "playbackService"); this._syllablesService = syllablesService; this._transcriptionService = transcriptionService; this._playbackService = playbackService; this._playbackService.PlaybackCompleted += this.PlaybackServiceOnPlaybackCompleted; this._inputText = ""; this._isInputTextBoxEnabled = true; this._outputMode = OutputMode.Transcription; this.OutputText = ""; this._words = new List<string>(); this.Commands = new ApplicationViewModelCommands(this); }
public PlaybackInfoControlViewModel(IPlaybackService playbackService) { this.playbackService = playbackService; this.refreshTimer.Interval = this.refreshTimerIntervalMilliseconds; this.refreshTimer.Elapsed += RefreshTimer_Elapsed; this.playbackService.PlaybackSuccess += (isPlayingPreviousTrack) => { this.SlideDirection = isPlayingPreviousTrack ? SlideDirection.UpToDown : SlideDirection.DownToUp; this.refreshTimer.Stop(); this.refreshTimer.Start(); }; this.playbackService.PlaybackProgressChanged += (_, __) => this.UpdateTime(); this.playbackService.PlayingTrackPlaybackInfoChanged += (_, __) => this.RefreshPlaybackInfoAsync(this.playbackService.CurrentTrack.Value, true); // Defaults this.SlideDirection = SlideDirection.DownToUp; this.RefreshPlaybackInfoAsync(this.playbackService.CurrentTrack.Value, false); }
public SpectrumAnalyzerControlViewModel(IPlaybackService playbackService, IAppearanceService appearanceService, IEventAggregator eventAggregator) { this.playbackService = playbackService; this.eventAggregator = eventAggregator; this.appearanceService = appearanceService; this.playbackService.SpectrumVisibilityChanged += isSpectrumVisible => this.ShowSpectrumAnalyzer = isSpectrumVisible; this.appearanceService.ColorSchemeChanged += (_, __) => Application.Current.Dispatcher.Invoke(() => this.SetSpectrumStyle((SpectrumStyle)SettingsClient.Get <int>("Playback", "SpectrumStyle"))); this.playbackService.PlaybackFailed += (_, __) => this.IsPlaying = false; this.playbackService.PlaybackStopped += (_, __) => this.IsPlaying = false; this.playbackService.PlaybackPaused += (_, __) => this.IsPlaying = false; this.playbackService.PlaybackResumed += (_, __) => this.IsPlaying = true; this.playbackService.PlaybackSuccess += (_, __) => this.IsPlaying = true; SettingsClient.SettingChanged += (_, e) => { if (SettingsClient.IsSettingChanged(e, "Playback", "SpectrumStyle")) { this.SetSpectrumStyle((SpectrumStyle)e.SettingValue); } }; this.ShowSpectrumAnalyzer = SettingsClient.Get <bool>("Playback", "ShowSpectrumAnalyzer"); // Initial value if (!this.playbackService.IsStopped & this.playbackService.IsPlaying) { this.IsPlaying = true; } else { this.IsPlaying = false; } // Default spectrum this.SetSpectrumStyle((SpectrumStyle)SettingsClient.Get <int>("Playback", "SpectrumStyle")); }
public PlaybackControlsWithPlaylistNotificationViewModel(ICollectionService collectionService, IPlaybackService playbackService, IPlaylistService playlistService) { this.collectionService = collectionService; this.playbackService = playbackService; this.playlistService = playlistService; this.PlaylistNotificationMouseEnterCommand = new DelegateCommand(() => this.HideText()); this.playlistService.TracksAdded += (numberTracksAdded, playlist) => { string text = ResourceUtils.GetString("Language_Added_Track_To_Playlist"); if (numberTracksAdded > 1) { text = ResourceUtils.GetString("Language_Added_Tracks_To_Playlist"); } this.AddedTracksToPlaylistText = text.Replace("%numberoftracks%", numberTracksAdded.ToString()).Replace("%playlistname%", playlist); this.ShowAddedTracksToPlaylistText = true; }; this.playbackService.AddedTracksToQueue += iNumberOfTracks => { string text = ResourceUtils.GetString("Language_Added_Track_To_Now_Playing"); if (iNumberOfTracks > 1) { text = ResourceUtils.GetString("Language_Added_Tracks_To_Now_Playing"); } this.AddedTracksToPlaylistText = text.Replace("%numberoftracks%", iNumberOfTracks.ToString()); this.ShowAddedTracksToPlaylistText = true; }; this.showAddedTracksToPlaylistTextTimer = new Timer(); this.showAddedTracksToPlaylistTextTimer.Interval = TimeSpan.FromSeconds(this.showAddedTracksToPlaylistTextTimeout).TotalMilliseconds; this.showAddedTracksToPlaylistTextTimer.Elapsed += ShowAddedTracksToPlaylistTextTimerElapsedHandler; }
public CollectionFrequentViewModel(IAlbumRepository albumRepository, IPlaybackService playbackService, ICacheService cacheService, IIndexingService indexingService, IRegionManager regionManager) { this.albumRepository = albumRepository; this.playbackService = playbackService; this.cacheService = cacheService; this.indexingService = indexingService; this.regionManager = regionManager; this.playbackService.PlaybackCountersChanged += async(_, __) => await this.PopulateAlbumHistoryAsync(); this.indexingService.IndexingStopped += async(_, __) => await this.PopulateAlbumHistoryAsync(); this.ClickCommand = new DelegateCommand <object>((album) => { try { if (album != null) { this.playbackService.EnqueueAsync(((Album)album).ToList(), false, false); } } catch (Exception ex) { LogClient.Error("An error occurred during Album enqueue. Exception: {0}", ex.Message); } }); this.LoadedCommand = new DelegateCommand(async() => { if (!isFirstLoad) { return; } isFirstLoad = false; await Task.Delay(Constants.CommonListLoadDelay); await this.PopulateAlbumHistoryAsync(); }); }
public TracksViewModelBase(IContainerProvider container) : base(container) { // Dependency injection this.container = container; this.trackRepository = container.Resolve <ITrackRepository>(); this.dialogService = container.Resolve <IDialogService>(); this.searchService = container.Resolve <ISearchService>(); this.playbackService = container.Resolve <IPlaybackService>(); this.collectionService = container.Resolve <ICollectionService>(); this.i18nService = container.Resolve <II18nService>(); this.eventAggregator = container.Resolve <IEventAggregator>(); this.providerService = container.Resolve <IProviderService>(); this.playlistService = container.Resolve <IPlaylistService>(); // Commands this.ToggleTrackOrderCommand = new DelegateCommand(() => this.ToggleTrackOrder()); this.AddTracksToPlaylistCommand = new DelegateCommand <string>(async(playlistName) => await this.AddTracksToPlaylistAsync(playlistName, this.SelectedTracks)); this.PlaySelectedCommand = new DelegateCommand(async() => await this.PlaySelectedAsync()); this.PlayNextCommand = new DelegateCommand(async() => await this.PlayNextAsync()); this.AddTracksToNowPlayingCommand = new DelegateCommand(async() => await this.AddTracksToNowPlayingAsync()); // Settings SettingsClient.SettingChanged += (_, e) => { if (SettingsClient.IsSettingChanged(e, "Behaviour", "ShowRemoveFromDisk")) { RaisePropertyChanged(nameof(this.ShowRemoveFromDisk)); } }; // Events this.i18nService.LanguageChanged += (_, __) => { RaisePropertyChanged(nameof(this.TotalDurationInformation)); RaisePropertyChanged(nameof(this.TotalSizeInformation)); this.RefreshLanguage(); }; this.playbackService.PlaybackCountersChanged += PlaybackService_PlaybackCountersChanged; }
public void UpdateMessage(IPlaybackService playbackService, IProtoService protoService, Message message) { _playbackService = playbackService; _protoService = protoService; _message = message; _playbackService.PropertyChanged -= OnCurrentItemChanged; _playbackService.PropertyChanged += OnCurrentItemChanged; _playbackService.PlaybackStateChanged -= OnPlaybackStateChanged; _playbackService.PlaybackStateChanged += OnPlaybackStateChanged; var voiceNote = GetContent(message.Content); if (voiceNote == null) { return; } var user = protoService.GetUser(message.SenderUserId); if (user != null) { Title.Text = user.GetFullName(); } else { var chat = protoService.GetChat(message.ChatId); if (chat != null) { Title.Text = chat.Title; } else { Title.Text = string.Empty; } } UpdateFile(message, voiceNote.Voice); }
public CoverArtControlViewModel(IPlaybackService playbackService, ICacheService cacheService, IMetadataService metadataService) { this.playbackService = playbackService; this.cacheService = cacheService; this.metadataService = metadataService; this.refreshTimer.Interval = this.refreshTimerIntervalMilliseconds; this.refreshTimer.Elapsed += RefreshTimer_Elapsed; this.playbackService.PlaybackSuccess += (_, e) => { this.SlideDirection = e.IsPlayingPreviousTrack ? SlideDirection.UpToDown : SlideDirection.DownToUp; this.refreshTimer.Stop(); this.refreshTimer.Start(); }; this.playbackService.PlayingTrackArtworkChanged += (_, __) => this.RefreshCoverArtAsync(this.playbackService.CurrentTrack); // Defaults this.SlideDirection = SlideDirection.DownToUp; this.RefreshCoverArtAsync(this.playbackService.CurrentTrack); }
public MainViewModel(IProtoService protoService, ICacheService cacheService, ISettingsService settingsService, IEventAggregator aggregator, INotificationsService pushService, IContactsService contactsService, IVibrationService vibrationService, ILiveLocationService liveLocationService, IPasscodeService passcodeService, ILifetimeService lifecycle, ISessionService session, IVoIPService voipService, ISettingsSearchService settingsSearchService, IEmojiSetService emojiSetService, IPlaybackService playbackService) : base(protoService, cacheService, settingsService, aggregator) { _pushService = pushService; _contactsService = contactsService; _vibrationService = vibrationService; _liveLocationService = liveLocationService; _passcodeService = passcodeService; _lifetimeService = lifecycle; _sessionService = session; _voipService = voipService; _emojiSetService = emojiSetService; _playbackService = playbackService; Chats = new ChatsViewModel(protoService, cacheService, settingsService, aggregator, pushService, new ChatListMain()); ArchivedChats = new ChatsViewModel(protoService, cacheService, settingsService, aggregator, pushService, new ChatListArchive()); Contacts = new ContactsViewModel(protoService, cacheService, settingsService, aggregator, contactsService); Calls = new CallsViewModel(protoService, cacheService, settingsService, aggregator); Settings = new SettingsViewModel(protoService, cacheService, settingsService, aggregator, pushService, contactsService, settingsSearchService); // This must represent pivot tabs Children.Add(Chats); Children.Add(Contacts); Children.Add(Calls); Children.Add(Settings); // Any additional child Children.Add(ArchivedChats); Children.Add(_voipService as TLViewModelBase); aggregator.Subscribe(this); LiveLocationCommand = new RelayCommand(LiveLocationExecute); StopLiveLocationCommand = new RelayCommand(StopLiveLocationExecute); ReturnToCallCommand = new RelayCommand(ReturnToCallExecute); ToggleArchiveCommand = new RelayCommand(ToggleArchiveExecute); }
public SettingsAppearanceViewModel(IPlaybackService playbackService, IEventAggregator eventAggregator) { this.playbackService = playbackService; this.eventAggregator = eventAggregator; this.ColorSchemesDirectory = System.IO.Path.Combine(SettingsClient.ApplicationFolder(), ApplicationPaths.ColorSchemesFolder); this.OpenColorSchemesDirectoryCommand = new DelegateCommand <string>((colorSchemesDirectory) => { try { Actions.TryOpenPath(colorSchemesDirectory); } catch (Exception ex) { LogClient.Error("Could not open the ColorSchemes directory. Exception: {0}", ex.Message); } }); this.GetCheckBoxesAsync(); this.GetSpectrumStylesAsync(); }
public AlbumsViewModelBase(IUnityContainer container) : base(container) { // Dependency injection this.container = container; this.collectionService = container.Resolve <ICollectionService>(); this.playbackService = container.Resolve <IPlaybackService>(); this.dialogService = container.Resolve <IDialogService>(); this.searchService = container.Resolve <ISearchService>(); this.playlistService = container.Resolve <IPlaylistService>(); this.albumRepository = container.Resolve <IAlbumRepository>(); this.cacheService = container.Resolve <ICacheService>(); // Commands this.ToggleAlbumOrderCommand = new DelegateCommand(() => this.ToggleAlbumOrder()); this.ShuffleSelectedAlbumsCommand = new DelegateCommand(async() => await this.playbackService.EnqueueAlbumsAsync(this.SelectedAlbumIds, true, false)); this.AddAlbumsToPlaylistCommand = new DelegateCommand <string>(async(playlistName) => await this.AddAlbumsToPlaylistAsync(this.SelectedAlbumIds, playlistName)); this.EditAlbumCommand = new DelegateCommand(() => this.EditSelectedAlbum(), () => !this.IsIndexing); this.AddAlbumsToNowPlayingCommand = new DelegateCommand(async() => await this.AddAlbumsToNowPlayingAsync(this.SelectedAlbumIds)); this.DelaySelectedAlbumsCommand = new DelegateCommand(() => this.delaySelectedAlbums = true); this.SelectedAlbumsCommand = new DelegateCommand <object>(async(parameter) => { if (this.delaySelectedAlbums) { await Task.Delay(Constants.DelaySelectedAlbumsDelay); } this.delaySelectedAlbums = false; await this.SelectedAlbumsHandlerAsync(parameter); }); this.SetCoverSizeCommand = new DelegateCommand <string>(async(coverSize) => { if (int.TryParse(coverSize, out int selectedCoverSize)) { await this.SetCoversizeAsync((CoverSizeType)selectedCoverSize); } }); }
public LoginViewModel(IPageSwitchingService pageSwitchingService, IEventAggregator eventAggregator, IAudioStationSession audioStationSession, IOpenSynoSettings synoSettings, ISignInService signInService, IPlaybackService playbackService) { if (pageSwitchingService == null) { throw new ArgumentNullException("pageSwitchingService"); } if (eventAggregator == null) { throw new ArgumentNullException("eventAggregator"); } if (audioStationSession == null) { throw new ArgumentNullException("audioStationSession"); } SignInCommand = new DelegateCommand(OnSignIn); _pageSwitchingService = pageSwitchingService; _eventAggregator = eventAggregator; _audioStationSession = audioStationSession; _synoSettings = synoSettings; _signInService = signInService; _signInService.SignInCompleted += OnSignInCompleted; // Unregister the registered events to make sure we don't execute the event handler twice in case of exceptions _signInService.CheckTokenValidityCompleted += (o, e) => { if (e.Error != null) { _signInService.CheckTokenValidityCompleted -= OnCheckTokenValidityCompleted; } }; _playbackService = playbackService; UserName = _synoSettings.UserName; UseSsl = _synoSettings.UseSsl; Password = _synoSettings.Password; Host = _synoSettings.Host; Port = _synoSettings.Port; }
/// <summary> /// Parameterless Constructor used by child classes. /// </summary> /// <remarks></remarks> public CommonTracksViewModel() { // Unity Container this.container = ServiceLocator.Current.GetInstance <IUnityContainer>(); // EventAggregator this.eventAggregator = ServiceLocator.Current.GetInstance <IEventAggregator>(); // Services this.indexingService = ServiceLocator.Current.GetInstance <IIndexingService>(); this.playbackService = ServiceLocator.Current.GetInstance <IPlaybackService>(); this.searchService = ServiceLocator.Current.GetInstance <ISearchService>(); this.dialogService = ServiceLocator.Current.GetInstance <IDialogService>(); this.collectionService = ServiceLocator.Current.GetInstance <ICollectionService>(); this.metadataService = ServiceLocator.Current.GetInstance <IMetadataService>(); this.i18nService = ServiceLocator.Current.GetInstance <II18nService>(); // Repositories this.trackRepository = ServiceLocator.Current.GetInstance <ITrackRepository>(); // Initialize this.Initialize(); }
/// <summary> /// Constructor which allows Dependency Injection. This can be useful for Unit Testing. /// </summary> /// <param name="container"></param> /// <param name="indexingService"></param> /// <param name="eventAggregator"></param> /// <param name="playbackService"></param> /// <param name="searchService"></param> /// <param name="dialogService"></param> /// <param name="collectionService"></param> /// <param name="trackRepository"></param> /// <param name="i18nService"></param> /// <remarks></remarks> public CommonTracksViewModel(IUnityContainer container, IIndexingService indexingService, IEventAggregator eventAggregator, IPlaybackService playbackService, ISearchService searchService, IDialogService dialogService, ICollectionService collectionService, ITrackRepository trackRepository, IMetadataService metadataService, II18nService i18nService) { // Unity Container this.container = container; // EventAggregator this.eventAggregator = eventAggregator; // Services this.indexingService = indexingService; this.playbackService = playbackService; this.searchService = searchService; this.dialogService = dialogService; this.collectionService = collectionService; this.metadataService = metadataService; this.i18nService = i18nService; // Repositories this.trackRepository = trackRepository; // Initialize this.Initialize(); }
public MetadataService(ICacheService cacheService, IPlaybackService playbackService, ITrackRepository trackRepository, IFileMetadataFactory metadataFactory, IContainerProvider container) { this.cacheService = cacheService; this.playbackService = playbackService; this.trackRepository = trackRepository; this.metadataFactory = metadataFactory; this.container = container; this.fileMetadataDictionary = new Dictionary <string, IFileMetadata>(); this.updateFileMetadataTimer = new Timer(); this.updateFileMetadataTimer.Interval = this.updateFileMetadataLongTimeout; this.updateFileMetadataTimer.Elapsed += async(_, __) => await this.UpdateFileMetadataAsync(); this.playbackService.PlaybackStopped += async(_, __) => await this.UpdateFileMetadataAsync(); this.playbackService.PlaybackFailed += async(_, __) => await this.UpdateFileMetadataAsync(); this.playbackService.PlaybackSuccess += async(_, __) => await this.UpdateFileMetadataAsync(); }
public void Update(IProtoService cacheService, IPlaybackService playbackService, INavigationService navigationService, IEventAggregator aggregator) { _cacheService = cacheService; _playbackService = playbackService; _navigationService = navigationService; _aggregator = aggregator; _playbackService.MediaFailed -= OnMediaFailed; _playbackService.MediaFailed += OnMediaFailed; _playbackService.PropertyChanged -= OnCurrentItemChanged; _playbackService.PropertyChanged += OnCurrentItemChanged; _playbackService.PlaybackStateChanged -= OnPlaybackStateChanged; _playbackService.PlaybackStateChanged += OnPlaybackStateChanged; _playbackService.PositionChanged -= OnPositionChanged; _playbackService.PositionChanged += OnPositionChanged; _playbackService.PlaylistChanged -= OnPlaylistChanged; _playbackService.PlaylistChanged += OnPlaylistChanged; Items.ItemsSource = _playbackService.Items; UpdateRate(); UpdateGlyph(); }
public MetadataService(ICacheService cacheService, IPlaybackService playbackService, ITrackRepository trackRepository, ITrackStatisticRepository trackStatisticRepository, IAlbumRepository albumRepository, IGenreRepository genreRepository, IArtistRepository artistRepository) { this.cacheService = cacheService; this.playbackService = playbackService; this.trackStatisticRepository = trackStatisticRepository; this.trackRepository = trackRepository; this.albumRepository = albumRepository; this.genreRepository = genreRepository; this.artistRepository = artistRepository; this.fileMetadataDictionary = new Dictionary <string, FileMetadata>(); this.updateFileMetadataTimer = new Timer(); this.updateFileMetadataTimer.Interval = this.updateFileMetadataLongTimeout; this.updateFileMetadataTimer.Elapsed += async(_, __) => await this.UpdateFileMetadataAsync(); this.playbackService.PlaybackStopped += async(_, __) => await this.UpdateFileMetadataAsync(); this.playbackService.PlaybackFailed += async(_, __) => await this.UpdateFileMetadataAsync(); this.playbackService.PlaybackSuccess += async(_) => await this.UpdateFileMetadataAsync(); }
public ShellViewModel(IPlaybackService playbackService, ITaskbarService taskbarService, IDialogService dialogService) { this.TaskbarService = taskbarService; this.dialogService = dialogService; this.dialogService.DialogVisibleChanged += isDialogVisible => { this.IsOverlayVisible = isDialogVisible; }; this.PlayPreviousCommand = new DelegateCommand(async() => await playbackService.PlayPreviousAsync()); this.PlayNextCommand = new DelegateCommand(async() => await playbackService.PlayNextAsync()); this.PlayOrPauseCommand = new DelegateCommand(async() => await playbackService.PlayOrPauseAsync()); this.ShowLogfileCommand = new DelegateCommand(() => { try { Actions.TryViewInExplorer(LogClient.Logfile()); } catch (Exception ex) { LogClient.Error("Could not view the log file {0} in explorer. Exception: {1}", LogClient.Logfile(), ex.Message); } }); }
public EqualizerControlViewModel(IPlaybackService playbackService, IEqualizerService equalizerService, IDialogService dialogService) { // Variables this.playbackService = playbackService; this.equalizerService = equalizerService; this.dialogService = dialogService; this.IsEqualizerEnabled = XmlSettingsClient.Instance.Get <bool>("Equalizer", "IsEnabled"); // Commands this.ResetCommand = new DelegateCommand(() => { this.canApplyManualPreset = false; this.Band0 = this.Band1 = this.Band2 = this.Band3 = this.Band4 = this.Band5 = this.Band6 = this.Band7 = this.Band8 = this.Band9 = 0.0; this.canApplyManualPreset = true; this.ApplyManualPreset(); }); this.DeleteCommand = new DelegateCommand(async() => { await this.DeletePresetAsync(); }, () => { if (this.SelectedPreset != null) { return(this.SelectedPreset.IsRemovable); } else { return(false); } }); this.SaveCommand = new DelegateCommand(async() => { await this.SavePresetToFileAsync(); }); // Initialize this.InitializeAsync(); }
public CommonViewModelBase(IUnityContainer container) : base(container) { // EventAggregator this.eventAggregator = container.Resolve <IEventAggregator>(); // Services this.indexingService = container.Resolve <IIndexingService>(); this.playbackService = container.Resolve <IPlaybackService>(); this.searchService = container.Resolve <ISearchService>(); this.dialogService = container.Resolve <IDialogService>(); this.collectionService = container.Resolve <ICollectionService>(); this.metadataService = container.Resolve <IMetadataService>(); this.i18nService = container.Resolve <II18nService>(); this.playlistService = container.Resolve <IPlaylistService>(); // Handlers this.ProviderService.SearchProvidersChanged += (_, __) => { this.GetSearchProvidersAsync(); }; // Initialize the search providers in the ContextMenu this.GetSearchProvidersAsync(); // Initialize this.Initialize(); }
public ArtistInfoControlViewModel(IUnityContainer container, IPlaybackService playbackService, II18nService i18nService) { this.container = container; this.playbackService = playbackService; this.i18nService = i18nService; this.OpenLinkCommand = new DelegateCommand <string>((url) => { try { Actions.TryOpenLink(url); } catch (Exception ex) { LogClient.Error("Could not open link {0}. Exception: {1}", url, ex.Message); } }); this.playbackService.PlaybackSuccess += async(isPlayingPreviousTrack) => { this.SlideDirection = isPlayingPreviousTrack ? SlideDirection.RightToLeft : SlideDirection.LeftToRight; await this.ShowArtistInfoAsync(this.playbackService.CurrentTrack.Value, false); }; this.i18nService.LanguageChanged += async(_, __) => { if (this.playbackService.HasCurrentTrack) { await this.ShowArtistInfoAsync(this.playbackService.CurrentTrack.Value, true); } }; // Defaults this.SlideDirection = SlideDirection.LeftToRight; this.ShowArtistInfoAsync(this.playbackService.CurrentTrack.Value, true); }
public SpectrumAnalyzerControlViewModel(IPlaybackService playbackService) { this.playbackService = playbackService; this.playbackService.SpectrumVisibilityChanged += isSpectrumVisible => this.ShowSpectrumAnalyzer = isSpectrumVisible; this.playbackService.PlaybackFailed += (_, __) => this.IsPlaying = false; this.playbackService.PlaybackStopped += (_, __) => this.IsPlaying = false; this.playbackService.PlaybackPaused += (_, __) => this.IsPlaying = false; this.playbackService.PlaybackResumed += (_, __) => this.IsPlaying = true; this.playbackService.PlaybackSuccess += (_) => this.IsPlaying = true; this.ShowSpectrumAnalyzer = XmlSettingsClient.Instance.Get <bool>("Playback", "ShowSpectrumAnalyzer"); // Initial value if (!this.playbackService.IsStopped & this.playbackService.IsPlaying) { this.IsPlaying = true; } else { this.IsPlaying = false; } }
public ArtistInfoControlViewModel(IUnityContainer container, IPlaybackService playbackService, II18nService i18nService) { this.container = container; this.playbackService = playbackService; this.i18nService = i18nService; this.playbackService.PlaybackSuccess += async(isPlayingPreviousTrack) => { this.SlideDirection = isPlayingPreviousTrack ? SlideDirection.RightToLeft : SlideDirection.LeftToRight; await this.ShowArtistInfoAsync(this.playbackService.CurrentTrack.Value, false); }; this.i18nService.LanguageChanged += async(_, __) => { if (this.playbackService.HasCurrentTrack) { await this.ShowArtistInfoAsync(this.playbackService.CurrentTrack.Value, true); } }; // Defaults this.SlideDirection = SlideDirection.LeftToRight; this.ShowArtistInfoAsync(this.playbackService.CurrentTrack.Value, true); }
public ChatSharedMediaViewModel(IProtoService protoService, ICacheService cacheService, ISettingsService settingsService, IStorageService storageService, IEventAggregator aggregator, IPlaybackService playbackService) : base(protoService, cacheService, settingsService, aggregator) { _playbackService = playbackService; _storageService = storageService; Items = new ObservableCollection <ProfileItem>(); Media = new SearchCollection <MessageWithOwner, MediaCollection>(SetSearch, new SearchMessagesFilterPhotoAndVideo(), new MessageDiffHandler()); Files = new SearchCollection <MessageWithOwner, MediaCollection>(SetSearch, new SearchMessagesFilterDocument(), new MessageDiffHandler()); Links = new SearchCollection <MessageWithOwner, MediaCollection>(SetSearch, new SearchMessagesFilterUrl(), new MessageDiffHandler()); Music = new SearchCollection <MessageWithOwner, MediaCollection>(SetSearch, new SearchMessagesFilterAudio(), new MessageDiffHandler()); Voice = new SearchCollection <MessageWithOwner, MediaCollection>(SetSearch, new SearchMessagesFilterVoiceNote(), new MessageDiffHandler()); Animations = new SearchCollection <MessageWithOwner, MediaCollection>(SetSearch, new SearchMessagesFilterAnimation(), new MessageDiffHandler()); MessagesForwardCommand = new RelayCommand(MessagesForwardExecute, MessagesForwardCanExecute); MessagesDeleteCommand = new RelayCommand(MessagesDeleteExecute, MessagesDeleteCanExecute); MessagesUnselectCommand = new RelayCommand(MessagesUnselectExecute); MessageViewCommand = new RelayCommand <MessageWithOwner>(MessageViewExecute); MessageSaveCommand = new RelayCommand <MessageWithOwner>(MessageSaveExecute); MessageDeleteCommand = new RelayCommand <MessageWithOwner>(MessageDeleteExecute); MessageForwardCommand = new RelayCommand <MessageWithOwner>(MessageForwardExecute); MessageSelectCommand = new RelayCommand <MessageWithOwner>(MessageSelectExecute); }
public CollectionPlaylistsViewModel(IContainerProvider container, IDialogService dialogService, IPlaybackService playbackService, IPlaylistService playlistService, IMetadataService metadataService, IFileService fileService, IEventAggregator eventAggregator) : base(container) { this.dialogService = dialogService; this.playlistService = playlistService; this.playbackService = playbackService; this.fileService = fileService; this.eventAggregator = eventAggregator; this.dialogService = dialogService; this.metadataService = metadataService; this.container = container; // Events this.playlistService.PlaylistFolderChanged += PlaylistService_PlaylistFolderChanged; this.playlistService.TracksAdded += PlaylistService_TracksAdded; this.playlistService.TracksDeleted += PlaylistService_TracksDeleted; this.metadataService.LoveChanged += async(_) => await this.GetTracksIfSmartPlaylistSelectedAsync(); this.metadataService.RatingChanged += async(_) => await this.GetTracksIfSmartPlaylistSelectedAsync(); this.metadataService.MetadataChanged += async(_) => await this.GetTracksIfSmartPlaylistSelectedAsync(); this.playbackService.PlaybackCountersChanged += async(_) => await this.GetTracksIfSmartPlaylistSelectedAsync(); // Commands this.EditSelectedPlaylistCommand = new DelegateCommand(async() => await this.EditSelectedPlaylistAsync()); this.DeletePlaylistCommand = new DelegateCommand <PlaylistViewModel>(async(playlist) => await this.ConfirmDeletePlaylistAsync(playlist)); this.ImportPlaylistsCommand = new DelegateCommand(async() => await this.ImportPlaylistsAsync()); this.AddPlaylistToNowPlayingCommand = new DelegateCommand(async() => await this.AddPlaylistToNowPlayingAsync()); this.ShuffleSelectedPlaylistCommand = new DelegateCommand(async() => await this.ShuffleSelectedPlaylistAsync()); this.LoadedCommand = new DelegateCommand(async() => await this.LoadedCommandAsync()); this.NewPlaylistCommand = new DelegateCommand(async() => await this.ConfirmCreateNewPlaylistAsync()); this.RemoveSelectedTracksCommand = new DelegateCommand(async() => await this.DeleteTracksFromPlaylistsAsync()); this.DeleteSelectedPlaylistCommand = new DelegateCommand(async() => { if (this.IsPlaylistSelected) { await this.ConfirmDeletePlaylistAsync(this.SelectedPlaylist); } }); // Settings changed SettingsClient.SettingChanged += (_, e) => { if (SettingsClient.IsSettingChanged(e, "Behaviour", "EnableRating")) { this.EnableRating = (bool)e.Entry.Value; } if (SettingsClient.IsSettingChanged(e, "Behaviour", "EnableLove")) { this.EnableLove = (bool)e.Entry.Value; } }; // Load settings this.LeftPaneWidthPercent = SettingsClient.Get <int>("ColumnWidths", "PlaylistsLeftPaneWidthPercent"); }
public MainViewModel(IProtoService protoService, ICacheService cacheService, ISettingsService settingsService, IEventAggregator aggregator, INotificationsService pushService, IContactsService contactsService, IVibrationService vibrationService, IPasscodeService passcodeService, ILifetimeService lifecycle, ISessionService session, IVoIPService voipService, ISettingsSearchService settingsSearchService, IEmojiSetService emojiSetService, IPlaybackService playbackService, IShortcutsService shortcutService) : base(protoService, cacheService, settingsService, aggregator) #endif { _pushService = pushService; _contactsService = contactsService; _vibrationService = vibrationService; _passcodeService = passcodeService; _lifetimeService = lifecycle; _sessionService = session; _voipService = voipService; _emojiSetService = emojiSetService; #if CLOUDUPDATES _cloudUpdateService = cloudUpdateService; #endif _playbackService = playbackService; _shortcutService = shortcutService; Filters = new ChatFilterCollection(); Chats = new ChatsViewModel(protoService, cacheService, settingsService, aggregator, pushService, new ChatListMain()); ArchivedChats = new ChatsViewModel(protoService, cacheService, settingsService, aggregator, pushService, new ChatListArchive()); Contacts = new ContactsViewModel(protoService, cacheService, settingsService, aggregator, contactsService); Calls = new CallsViewModel(protoService, cacheService, settingsService, aggregator); Settings = new SettingsViewModel(protoService, cacheService, settingsService, aggregator, settingsSearchService); // This must represent pivot tabs Children.Add(Chats); Children.Add(Contacts); Children.Add(Calls); Children.Add(Settings); // Any additional child Children.Add(ArchivedChats); Children.Add(_voipService as TLViewModelBase); aggregator.Subscribe(this); ReturnToCallCommand = new RelayCommand(ReturnToCallExecute); ToggleArchiveCommand = new RelayCommand(ToggleArchiveExecute); CreateSecretChatCommand = new RelayCommand(CreateSecretChatExecute); SetupFiltersCommand = new RelayCommand(SetupFiltersExecute); #if CLOUDUPDATES UpdateAppCommand = new RelayCommand(UpdateAppExecute); #endif FilterEditCommand = new RelayCommand <ChatFilterViewModel>(FilterEditExecute); FilterAddCommand = new RelayCommand <ChatFilterViewModel>(FilterAddExecute); FilterMarkAsReadCommand = new RelayCommand <ChatFilterViewModel>(FilterMarkAsReadExecute); FilterDeleteCommand = new RelayCommand <ChatFilterViewModel>(FilterDeleteExecute); }
public MainViewModel(IProtoService protoService, ICacheService cacheService, ISettingsService settingsService, IEventAggregator aggregator, INotificationsService pushService, IContactsService contactsService, IVibrationService vibrationService, IPasscodeService passcodeService, ILifetimeService lifecycle, ISessionService session, IVoIPService voipService, ISettingsSearchService settingsSearchService, IEmojiSetService emojiSetService, ICloudUpdateService cloudUpdateService, IPlaybackService playbackService, IShortcutsService shortcutService) : base(protoService, cacheService, settingsService, aggregator)
private void OnPositionChanged(IPlaybackService sender, object args) { this.BeginOnUIThread(UpdatePosition); }
private void ResolvePrivateMembers() { _playbackService = IoC.Container.Get<IPlaybackService>(); }
public CollectionGenresViewModel(IContainerProvider container) : base(container) { // Dependency injection this.collectionService = container.Resolve <ICollectionService>(); this.dialogService = container.Resolve <IDialogService>(); this.indexingService = container.Resolve <IIndexingService>(); this.playbackService = container.Resolve <IPlaybackService>(); this.playlistService = container.Resolve <IPlaylistService>(); this.searchService = container.Resolve <ISearchService>(); this.eventAggregator = container.Resolve <IEventAggregator>(); // Commands this.ToggleTrackOrderCommand = new DelegateCommand(async() => await this.ToggleTrackOrderAsync()); this.ToggleAlbumOrderCommand = new DelegateCommand(async() => await this.ToggleAlbumOrderAsync()); this.RemoveSelectedTracksCommand = new DelegateCommand(async() => await this.RemoveTracksFromCollectionAsync(this.SelectedTracks), () => !this.IsIndexing); this.AddGenresToPlaylistCommand = new DelegateCommand <string>(async(playlistName) => await this.AddGenresToPlaylistAsync(this.SelectedGenres, playlistName)); this.SelectedGenresCommand = new DelegateCommand <object>(async(parameter) => await this.SelectedGenresHandlerAsync(parameter)); this.ShowGenresZoomCommand = new DelegateCommand(async() => await this.ShowSemanticZoomAsync()); this.AddGenresToNowPlayingCommand = new DelegateCommand(async() => await this.AddGenresToNowPlayingAsync(this.SelectedGenres)); this.ShuffleSelectedGenresCommand = new DelegateCommand(async() => await this.playbackService.EnqueueGenresAsync(this.SelectedGenres, true, false)); this.SemanticJumpCommand = new DelegateCommand <string>((header) => { this.HideSemanticZoom(); this.eventAggregator.GetEvent <PerformSemanticJump>().Publish(new Tuple <string, string>("Genres", header)); }); // Settings SettingsClient.SettingChanged += async(_, e) => { if (SettingsClient.IsSettingChanged(e, "Behaviour", "EnableRating")) { this.EnableRating = (bool)e.SettingValue; this.SetTrackOrder("GenresTrackOrder"); await this.GetTracksAsync(null, this.SelectedGenres, this.SelectedAlbums, this.TrackOrder); } if (SettingsClient.IsSettingChanged(e, "Behaviour", "EnableLove")) { this.EnableLove = (bool)e.SettingValue; this.SetTrackOrder("GenresTrackOrder"); await this.GetTracksAsync(null, this.SelectedGenres, this.SelectedAlbums, this.TrackOrder); } }; // PubSub Events this.eventAggregator.GetEvent <ShellMouseUp>().Subscribe((_) => this.IsGenresZoomVisible = false); // Set the initial AlbumOrder this.AlbumOrder = (AlbumOrder)SettingsClient.Get <int>("Ordering", "GenresAlbumOrder"); // Set the initial TrackOrder this.SetTrackOrder("GenresTrackOrder"); // Set width of the panels this.LeftPaneWidthPercent = SettingsClient.Get <int>("ColumnWidths", "GenresLeftPaneWidthPercent"); this.RightPaneWidthPercent = SettingsClient.Get <int>("ColumnWidths", "GenresRightPaneWidthPercent"); // Cover size this.SetCoversizeAsync((CoverSizeType)SettingsClient.Get <int>("CoverSizes", "GenresCoverSize")); }
/// <summary> /// Initializes a new instance of the <see cref="PlayQueueViewModel"/> class. /// </summary> /// <param name="eventAggregator">The event aggregator.</param> /// <param name="playbackService">The playback service.</param> /// <param name="openSynoSettings"></param> public PlayQueueViewModel(IEventAggregator eventAggregator, IPlaybackService playbackService, INotificationService notificationService, IOpenSynoSettings openSynoSettings, ILogService logService, ITrackViewModelFactory trackViewModelFactory, IPageSwitchingService pageSwitchingService) { if (eventAggregator == null) { throw new ArgumentNullException("eventAggregator"); } if (playbackService == null) { throw new ArgumentNullException("playbackService"); } if (notificationService == null) { throw new ArgumentNullException("notificationService"); } if (openSynoSettings == null) { throw new ArgumentNullException("openSynoSettings"); } if (trackViewModelFactory == null) { throw new ArgumentNullException("trackViewModelFactory"); } if (pageSwitchingService == null) { throw new ArgumentNullException("pageSwitchingService"); } _trackViewModelFactory = trackViewModelFactory; RemoveTracksFromQueueCommand = new DelegateCommand<IEnumerable<object>>(OnRemoveTracksFromQueue); Action consecutiveAlbumsIdPatcher = () => { var previousAlbumGuid = Guid.Empty; string previousAlbumId = null; foreach (var trackViewModel in this.PlayQueueItems) { if (previousAlbumId != trackViewModel.TrackInfo.ItemPid) { previousAlbumId = trackViewModel.TrackInfo.ItemPid; previousAlbumGuid = Guid.NewGuid(); } trackViewModel.ConsecutiveAlbumIdentifier = previousAlbumGuid; } }; _playbackService = playbackService; this.PlayQueueItems = new ObservableCollection<TrackViewModel>(playbackService.GetTracksInQueue().Select(o => _trackViewModelFactory.Create(o.Guid, o.Track, this._pageSwitchingService))); this.PlayQueueItems.CollectionChanged += (s, ea) => { consecutiveAlbumsIdPatcher(); }; consecutiveAlbumsIdPatcher(); _playbackService.PlayqueueChanged += this.OnPlayqueueChanged; // FIXME : using aggregated event is not a great idea here : we'd rather use a service : that would be cleaner and easier to debug ! eventAggregator.GetEvent<CompositePresentationEvent<PlayListOperationAggregatedEvent>>().Subscribe(OnPlayListOperation, true); this._notificationService = notificationService; _openSynoSettings = openSynoSettings; _logService = logService; _pageSwitchingService = pageSwitchingService; _playbackService.TrackStarted += (o, e) => { CurrentArtwork = new Uri(e.Track.AlbumArtUrl, UriKind.Absolute); this.ActiveTrack = this._trackViewModelFactory.Create(e.Guid, e.Track, this._pageSwitchingService); }; _playbackService.BufferingProgressUpdated += (o, e) => { // throttle refresh through binding. if (_lastBufferProgressUpdate.AddMilliseconds(500) < DateTime.Now || e.BytesLeft == 0) { _lastBufferProgressUpdate = DateTime.Now; this.BufferedBytesCount = e.FileSize - e.BytesLeft; this.CurrentFileSize = e.FileSize; Debug.WriteLine("Download progress : " + (double)(e.FileSize - e.BytesLeft) / (double)e.FileSize * (double)100.0); } }; _playbackService.TrackCurrentPositionChanged += (o, e) => { CurrentPlaybackPercentComplete = e.PlaybackPercentComplete;; CurrentTrackPosition = e.Position; }; PlayCommand = new DelegateCommand<TrackViewModel>(o => OnPlay(o), track => track != null); PlayNextCommand = new DelegateCommand(OnPlayNext); PausePlaybackCommand = new DelegateCommand(OnPausePlayback); ResumePlaybackCommand = new DelegateCommand(OnResumePlayback); PlayPreviousCommand = new DelegateCommand(OnPlayPrevious); SavePlaylistCommand = new DelegateCommand<IEnumerable<TrackViewModel>>(OnSavePlaylist); SelectAllAlbumTracksCommand = new DelegateCommand<Guid>(OnSelectAllAlbumTracks); }