public async Task <IActionResult> Create(QuizQuestionsVm vm, int trackIndex, string trackTitle) { if (ModelState.IsValid) { var question = vm.Question; var quiz = await _context.Quizzes.FindAsync(vm.Quiz.Id); var service = new PlaybackService(); var result = service.GetSpotifyTracks(vm.Question.TrackTitle).Result; question.TrackId = result.tracks.items[trackIndex].id; question.TrackTitle = result.tracks.items[trackIndex].name; question.QuizQuestions.Add(new QuizQuestion { Quiz = quiz }); _context.Add(question); await _context.SaveChangesAsync(); return(RedirectToAction("Create", new { quizId = quiz.Id, quizName = quiz.Name })); } return(View()); }
public async Task <IActionResult> Edit(int id, QuizQuestionsVm vm, int quizId) { if (id != vm.Question.Id) { return(NotFound()); } if (ModelState.IsValid) { try { var service = new PlaybackService(); var result = service.GetSpotifyTracks(vm.Question.TrackTitle).Result; vm.Question.TrackId = result.tracks.items[0].id; vm.Question.TrackTitle = result.tracks.items[0].name; _context.Update(vm.Question); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!QuestionExists(vm.Question.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction("Edit", "Quiz", new { vm.Quiz.Id })); } return(View(vm.Question.Id)); }
private async void SystemMediaTransportControlsOnButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args) { switch (args.Button) { case SystemMediaTransportControlsButton.Pause: PlaybackService.Pause(); break; case SystemMediaTransportControlsButton.Play: PlaybackService.Play(); break; case SystemMediaTransportControlsButton.Stop: PlaybackService.Stop(); break; case SystemMediaTransportControlsButton.Previous: await PlaybackService.PlayPrevious(); break; case SystemMediaTransportControlsButton.Next: await PlaybackService.PlayNext(); break; case SystemMediaTransportControlsButton.FastForward: Locator.MediaPlaybackViewModel.FastSeekCommand.Execute(30000); break; case SystemMediaTransportControlsButton.Rewind: Locator.MediaPlaybackViewModel.FastSeekCommand.Execute(-30000); break; } }
public PlaybackSliderViewModel() { var _progressSliderIsDragging = false; ProgressSliderManipulationStarted .ObservableOnThreadPool() .Subscribe(_ => _progressSliderIsDragging = true); ProgressSliderManipulationCompleted .ObservableOnThreadPool() .Subscribe(_ => { _progressSliderIsDragging = false; PlaybackService.Seek(TimeSpan.FromSeconds(SliderCurrentPosition)); }); PlaybackService.NewTrackPlayed .ObserveOnCoreDispatcher() .Subscribe(x => { SliderNaturalPosition = x.PlaybackItem.Source.Duration.Value.TotalSeconds; }); PlaybackService.PlaybackPosition .Where(_ => !_progressSliderIsDragging) .ObserveOnCoreDispatcher() .Subscribe(x => { SliderCurrentPosition = x.Position.TotalSeconds; }); }
public AudioViewModel() { _playbackService = DependencyService.Get <PlaybackService>(); IsPlaying = true; Icon = "pause"; }
public async void InitializeSystem() { try { this.InitializeComponent(); /* * if (LightningProvider.IsLightningEnabled) * { * LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider(); * } * else * { * var msg = new MessageDialog("Error: Lightning not enabled"); * await msg.ShowAsync(); * } */ this.panTiltServo = new PanTiltServo(); this.playbackService = new PlaybackService(); } catch (Exception ex) { this.isSystemInitialized = false; this.WriteToOutputTextBlock("Error: " + ex.Message); var msg = new MessageDialog(ex.Message); await msg.ShowAsync(); // this will show error message(if Any) } }
private async void SystemMediaTransportControlsOnButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args) { switch (args.Button) { case SystemMediaTransportControlsButton.Pause: PlaybackService.Pause(); break; case SystemMediaTransportControlsButton.Play: PlaybackService.Play(); break; case SystemMediaTransportControlsButton.Stop: PlaybackService.Stop(); break; case SystemMediaTransportControlsButton.Previous: await PlaybackService.PlayPrevious(); break; case SystemMediaTransportControlsButton.Next: await PlaybackService.PlayNext(); break; } }
public void SetState_PlayingWithoutSong_PlayMedia() { var media = new MockMediaService(); var service = new PlaybackService(media, new SettingsService(new MockSettingsStorage())); service.State = PlaybackState.Playing; Assert.IsTrue(media.CalledMethods.Contains("Play()")); }
protected override void OnNavigatedFrom(NavigationEventArgs e) { base.OnNavigatedFrom(e); if (_isHost) { PlaybackService.CleanUp(); } }
public async Task Constructor_LoadsStateFromSettings() { var media = new MockMediaService(); var settings = new SettingsService(new MockSettingsStorage()); await settings.Write("PlaybackState", PlaybackState.Loading); var service = new PlaybackService(media, settings); Assert.AreEqual(PlaybackState.Loading, service.State); }
/// <summary> /// Initializes a new instance of the <see cref="MediaPlayerViewModel"/> class. /// </summary> /// <param name="playback">Playback Service.</param> /// <param name="mouse">Mouse Handler.</param> /// <param name="error">Error Handler.</param> /// <param name="navigation">Navigation Handler.</param> public MediaPlayerViewModel(PlaybackService playback, IMouseService mouse, IErrorHandler error, INavigationHandler navigation) : base(error, navigation) { this.playback = playback ?? throw new ArgumentNullException(nameof(playback)); this.playback.RaiseCanExecuteChanged += this.VideoPlayerViewModel_RaiseCanExecuteChanged; this.mouse = mouse ?? throw new ArgumentNullException(nameof(mouse)); this.mouse.OnMoved += this.Mouse_OnMoved; this.mouse.OnHidden += this.Mouse_OnHidden; this.mouse.StartService(); }
public void SetSong_PausedWithSong_PlayMedia() { var song = new Song(); var media = new MockMediaService(); var service = new PlaybackService(media, new SettingsService(new MockSettingsStorage())); service.State = PlaybackState.Paused; media.CalledMethods.Clear(); service.Song = song; Assert.AreEqual(0, media.CalledMethods.Count); }
private void LoadAnimation(string filepath) { if (PlaybackService.LoadInputAnimation(filepath)) { loadedFilePath = filepath; } else { loadedFilePath = ""; } }
public RfcommServiceManager( PlaybackService playbackService, DisplayManager displayManager, CommandProcessor.CommandProcessor commandProcessor, HttpServer httpServer) { this.playbackService = playbackService; this.displayManager = displayManager; this.commandProcessor = commandProcessor; this.httpServer = httpServer; this.commandProcessor.NotifyCallerEventHandler += this.CommandProcessor_NotifyCallerEventHandler; }
public void IntilizePlayback(bool kill = false) { if (kill) { PlaybackService = null; } else { PlaybackService = new PlaybackService(ViewModel.LoadedAnimationFile, this); PlaybackService.OnFrameChanged += PlaybackService_OnFrameChanged; } }
public void SetSong_Null_PauseMedia() { var media = new MockMediaService(); var service = new PlaybackService(media, new SettingsService(new MockSettingsStorage())); service.State = PlaybackState.Playing; service.Song = new Song(); media.CalledMethods.Clear(); service.Song = null; Assert.IsTrue(media.CalledMethods.Contains("Pause()")); Assert.AreEqual(1, media.CalledMethods.Count); }
public void SetSong_LoadingWithSong_PlayMedia() { var song = new Song(); var media = new MockMediaService(); var service = new PlaybackService(media, new SettingsService(new MockSettingsStorage())); service.State = PlaybackState.Loading; media.CalledMethods.Clear(); service.Song = song; Assert.IsTrue(media.CalledMethods.Contains("Play(Stoffi.Core.Models.Song)")); Assert.AreEqual(1, media.CalledMethods.Count); }
/// <summary>Initializes a new instance of the <see cref="PlaylistTrackItemViewModel" /> class inside the context of the given container.</summary> /// <param name="container">The container.</param> public PlaylistTrackItemViewModel(IUnityContainer container) { this.playbackService = container.Resolve <PlaybackService>(); this.ReadingDataModel += this.ReadDataModel; this.PlayCommand = new DelegateCommand(this.PlayCommandExecute); var eventAggregator = container.Resolve <IEventAggregator>(); eventAggregator.GetEvent <CurrentlyPlayingContextChangedEvent>().Subscribe(this.HandleCurrentlyPlayingContextChanged); }
public async Task ChangeState_SavesToSettings() { var media = new MockMediaService(); var settings = new SettingsService(new MockSettingsStorage()); var service = new PlaybackService(media, settings); service.Song = new Song() { Id = 1337 }; service.State = PlaybackState.Loading; Assert.AreEqual(PlaybackState.Loading, await settings.Read <PlaybackState>("PlaybackState", PlaybackState.Paused)); }
public async Task ChangeSong_SavesToSettings() { var media = new MockMediaService(); var settings = new SettingsService(new MockSettingsStorage()); var service = new PlaybackService(media, settings); var song = new Song() { Id = 1337 }; service.State = PlaybackState.Playing; service.Song = song; Assert.AreEqual(song, await settings.Read <Song>("PlaybackSong", null)); }
public async Task Constructor_LoadsSongFromSettings() { var media = new MockMediaService(); var settings = new SettingsService(new MockSettingsStorage()); var song = new Song() { Id = 1337 }; await settings.Write("PlaybackSong", song); var service = new PlaybackService(media, settings); Assert.AreEqual(song, service.Song); }
public void SetSong_NotNull_RaisePropertyChanged() { string firedEvent = null; var media = new MockMediaService(); var service = new PlaybackService(media, new SettingsService(new MockSettingsStorage())); service.PropertyChanged += delegate(object sender, PropertyChangedEventArgs e) { firedEvent = e.PropertyName; }; service.Song = new Song(); Assert.IsNotNull(firedEvent); Assert.AreEqual("Song", firedEvent); }
public static async Task StartupAsync() { //Locator.CurrentMutable.RegisterConstant(new EnumToStringConverter(), typeof(IBindingTypeConverter)); //await ApplicationData.Current.LocalFolder.CreateFileAsync("FluentMusic.db", CreationCollisionOption.OpenIfExists); var dbpath = Path.Combine(ApplicationData.Current.LocalFolder.Path, "FluentMusic.db"); await Db.InitializeAsync(dbpath); await Setting.InitializeAsync(); await IndexService.InitializeAsync(); await CacheService.InitializeAsync(); PlaybackService = new PlaybackService(); await PlaybackService.InitializeAsync(); }
public CommandProcessor( Arduino.Arduino arduino, DisplayManager displayManager, PlaybackService playbackService, HttpServer httpServer, PanTiltServo panTiltServo, HCSR04 ultrasonicsensor) { this.arduino = arduino; this.displayManager = displayManager; this.playbackService = playbackService; this.httpServer = httpServer; this.panTiltServo = panTiltServo; this.ultrasonicsensor = ultrasonicsensor; this.arduino.I2CDataReceived += this.Arduino_I2CDataReceived; this.httpServer.NotifyCallerEventHandler += this.NotifyOnObstacleEventHandler; }
public SpotifyService( WebApiManager webApiManager, AuthorizationService spotifyServiceAuth, ContextsService spotifyServiceContext, ExploreService spotifyServiceExplore, LibraryService spotifyServiceLibrary, PlaybackService spotifyServicePlayback, UserService spotifyServiceUser) { dispatcher = webApiManager; Auth = spotifyServiceAuth; Context = spotifyServiceContext; Explore = spotifyServiceExplore; Library = spotifyServiceLibrary; Playback = spotifyServicePlayback; User = spotifyServiceUser; }
/// <summary>Initializes a new instance of the <see cref="PlaylistPageViewModel" /> class.</summary> /// <param name="container">The container.</param> public PlaylistPageViewModel(IUnityContainer container) { this.container = container; this.playListService = container.Resolve <PlaylistService>(); this.playBackService = container.Resolve <PlaybackService>(); var eventAggregator = container.Resolve <IEventAggregator>(); eventAggregator.GetEvent <PlaylistChangedEvent>().Subscribe(this.HandlePlaylistChanged); eventAggregator.GetEvent <PlaylistItemsAddedEvent>().Subscribe(this.HandlePlaylistItemsAdded); eventAggregator.GetEvent <PlaylistImageChangedEvent>().Subscribe(this.HandlePlaylistImageChanged); this.ReadingDataModel += this.ReadDataModel; this.NullingDataModel += this.NullDataModel; this.PlayCommand = new DelegateCommand(this.PlayCommandExecute); }
private async void Playback_MediaEndReach() { switch (PlaybackService.PlayingType) { case PlayingType.Music: break; case PlayingType.Video: await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Low, () => { if (Locator.VideoPlayerVm.CurrentVideo != null) { Locator.VideoPlayerVm.CurrentVideo.TimeWatchedSeconds = 0; } }); if (Locator.VideoPlayerVm.CurrentVideo != null) { await Locator.MediaLibrary.UpdateVideo(Locator.VideoPlayerVm.CurrentVideo).ConfigureAwait(false); } break; case PlayingType.NotPlaying: break; default: break; } if (!PlaybackService.CanGoNext()) { await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Low, () => { if (PlaybackService.PlayingType == PlayingType.Video) { App.RootPage.StopCompositionAnimationOnSwapChain(); } IsPlaying = false; if (!Locator.NavigationService.GoBack_Default()) { Locator.NavigationService.Go(Locator.SettingsVM.HomePage); } }); } }
public ShareController(ILogger <ShareController> logger, IConfiguration config, SpotApiService spotService, Helper helper, DataService dataService, LinkService linkService, PlaybackService playbackService, TokenService tokenService) { _logger = logger; _config = config; _spotService = spotService; _helper = helper; _dataService = dataService; _linkService = linkService; _playbackService = playbackService; _tokenService = tokenService; }
/// <summary>Initializes a new instance of the <see cref="PlayerPageViewModel" /> class inside the context of the given container.</summary> /// <param name="container">The container.</param> public PlayerPageViewModel(IUnityContainer container) { this.container = container; var eventAggregator = container.Resolve <IEventAggregator>(); eventAggregator.GetEvent <ConnectionEstablishedEvent>().Subscribe(this.HandleConnectionEstablished); eventAggregator.GetEvent <DevicesChangedEvent>().Subscribe(this.HandleDevicesChanged); eventAggregator.GetEvent <CurrentlyPlayingContextChangedEvent>().Subscribe(this.HandleCurrentlyPlayingContextChanged); eventAggregator.GetEvent <CurrentlyPlayingImageChanged>().Subscribe(this.HandleCurrentlyPlayingImageChanged); this.PlayPauseCommand = new DelegateCommand(this.PlayPauseCommandExecute); this.NextCommand = new DelegateCommand(this.NextCommandExecute); this.PreviousCommand = new DelegateCommand(this.PreviousCommandExecute); this.ShuffleCommand = new DelegateCommand(this.ShuffleCommandExecute); this.RepeatCommand = new DelegateCommand(this.RepeatCommandExecute); this.PropertyChanged += this.PlayerPageViewModelPropertyChanged; this.playbackService = this.container.Resolve <PlaybackService>(); }
private void playbackControlWindow_Load(object sender, EventArgs e) { var now = DateTime.Now; playbackService_ = new PlaybackService { TimeInterval = (start : now.AddHours(-1), end : now) }; dateTimePicker1.Value = playbackService_.TimeInterval.start; dateTimePicker2.Value = playbackService_.TimeInterval.end; playbackService_.OnStateChanged += onStateChanged; playbackService_.OnFramePlayed += onFramePlayed; string[] speedNames = Enum.GetNames(typeof(PlayerSpeed)).Select(name => name.Replace('_', '/')).ToArray(); fasterCb.Items.AddRange(speedNames); fasterCb.SelectedIndex = (int)playbackService_.PreviewSpeed; playedFramesLb.Text = string.Empty; }
public void CaptureStream_Instances_Are_Played_Back_In_Chronological_Order() { var resetEvent = new SlimResetEvent(20); var expectedStates = long.MaxValue; var executedStates = 0; var stateController = new WeatherStateController(new WeatherSimulator()); var stateResolver = new StateResolver(); stateResolver.Add(stateController); stateController.StateExecuted += delegate { executedStates++; if (executedStates == expectedStates) { resetEvent.Set(); } }; var playbackService = new PlaybackService(stateResolver); var ms = VastPark.FrameworkBase.IO.EmbeddedResource.GetMemoryStream("Continuum.Test.Samples.weather-simulation.continuum", Assembly.GetExecutingAssembly()); var stream1 = new ConcurrentStream(new MemoryStream(ms.ToArray())); var captureStream1 = new CaptureStream(stream1, System.IO.FileAccess.Read, stateResolver); var stream2 = new ConcurrentStream(new MemoryStream(ms.ToArray())); var captureStream2 = new CaptureStream(stream2, System.IO.FileAccess.Read, stateResolver); expectedStates = captureStream1.Count + captureStream2.Count; playbackService.Add(captureStream1); playbackService.Add(captureStream2); playbackService.Start(); resetEvent.Wait(); }
public void When_A_Filter_Is_Applied_That_Returns_True_The_State_Is_Not_Scheduled_For_Playback() { var stateController = new WeatherStateController(new WeatherSimulator()); var stateResolver = new StateResolver(); stateResolver.Add(stateController); var scheduler = new Mock<IScheduler>(); var taskFactory = new Mock<ITaskFactory>(); var playbackService = new PlaybackService(stateResolver, scheduler.Object, taskFactory.Object); var ms = VastPark.FrameworkBase.IO.EmbeddedResource.GetMemoryStream("Continuum.Test.Samples.weather-simulation.continuum", Assembly.GetExecutingAssembly()); var stream = new ConcurrentStream(new MemoryStream(ms.ToArray())); var captureStream = new CaptureStream(stream, System.IO.FileAccess.Read, stateResolver); playbackService.Add(captureStream); //add in a filter that will always return true to filter out the states playbackService.Add(new StreamFilter(f => true)); playbackService.Start(); //task factory should not have built any tasks taskFactory.Verify(t => t.Create(It.IsAny<ICaptureState>()), Times.Never()); scheduler.Verify(s => s.Add(It.IsAny<ITask>()), Times.Never()); }
public void When_A_Codec_Is_Not_Available_An_Event_Is_Raised_With_The_Guid_Of_The_Required_Codec() { var stateController = new WeatherStateController(new WeatherSimulator()); var stateResolver = new StateResolver(); stateResolver.Add(stateController); var playbackService = new PlaybackService(stateResolver); playbackService.CodecRequired += delegate(object sender, CodecRequiredEventArgs e) { Assert.Equal(stateController.Guid, e.Guid); }; var ms = VastPark.FrameworkBase.IO.EmbeddedResource.GetMemoryStream("Continuum.Test.Samples.weather-simulation.continuum", Assembly.GetExecutingAssembly()); var stream = new ConcurrentStream(new MemoryStream(ms.ToArray())); var captureStream = new CaptureStream(stream, System.IO.FileAccess.Read, stateResolver); playbackService.Add(captureStream); }
public void When_A_Codec_Is_Not_Available_An_Event_Is_Raised_Giving_The_Caller_An_Opportunity_To_Acquire_It() { var stateController = new WeatherStateController(new WeatherSimulator()); var stateResolver = new StateResolver(); var eventRaised = false; var playbackService = new PlaybackService(stateResolver); playbackService.CodecRequired += delegate { eventRaised = true; }; var ms = VastPark.FrameworkBase.IO.EmbeddedResource.GetMemoryStream("Continuum.Test.Samples.weather-simulation.continuum", Assembly.GetExecutingAssembly()); var stream = new ConcurrentStream(new MemoryStream(ms.ToArray())); var captureStream = new CaptureStream(stream, System.IO.FileAccess.Read, stateResolver); playbackService.Add(captureStream); Assert.True(eventRaised); }