Ejemplo n.º 1
0
        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());
        }
Ejemplo n.º 2
0
        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));
        }
Ejemplo n.º 3
0
        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;
            });
        }
Ejemplo n.º 5
0
        public AudioViewModel()
        {
            _playbackService = DependencyService.Get <PlaybackService>();

            IsPlaying = true;
            Icon      = "pause";
        }
Ejemplo n.º 6
0
        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()"));
        }
Ejemplo n.º 9
0
        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);
        }
Ejemplo n.º 11
0
 /// <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 = "";
     }
 }
Ejemplo n.º 14
0
 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;
 }
Ejemplo n.º 15
0
 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);
        }
Ejemplo n.º 18
0
        /// <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);
        }
Ejemplo n.º 23
0
        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();
        }
Ejemplo n.º 24
0
 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;
 }
Ejemplo n.º 25
0
 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;
 }
Ejemplo n.º 26
0
        /// <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);
        }
Ejemplo n.º 27
0
        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);
                    }
                });
            }
        }
Ejemplo n.º 28
0
 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;
 }
Ejemplo n.º 29
0
        /// <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;
        }
Ejemplo n.º 31
0
        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();
        }
Ejemplo n.º 32
0
        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());
        }
Ejemplo n.º 33
0
        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);
        }
Ejemplo n.º 34
0
        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);
        }