public static void SkipPlayback(SpotifyWebAPI api) { //Console.WriteLine(Prog.Mot[6]); if (Convert.ToDouble(Prog.Mot[6]) < 7900) { api.SkipPlaybackToNext(); PlaybackContext Music = api.GetPlayback(); Console.WriteLine($"You are listening {Music.Item.Name} now!"); } else if (Convert.ToDouble(Prog.Mot[6]) > 8750) { api.SkipPlaybackToPrevious(); PlaybackContext Music2 = api.GetPlayback(); Console.WriteLine($"You are listening {Music2.Item.Name} now!"); } else { } Thread.Sleep(1000); }
private void GlobalHookMouseWheelExt(object sender, MouseEventExtArgs e) { if (e.IsHorizontalScroll) { timer.Stop(); SpotifySeekerOverlaySetOpacity(0.75D); if (playbackContext == null) { playbackContext = spotifyWebAPI.GetPlayback(); String currentTrackArtists = null; foreach (SimpleArtist simpleArtist in playbackContext.Item.Artists) { currentTrackArtists += simpleArtist.Name + ", "; } currentTrackArtists = currentTrackArtists.TrimEnd(", ".ToCharArray()); String currentTrackName = playbackContext.Item.Name; CurrentTrackLabelSetText(currentTrackArtists + " - " + currentTrackName); CurrentProgressLabelSetText(TimeSpan.FromMilliseconds(playbackContext.ProgressMs).ToString("mm\\:ss")); } if (e.Delta > 0) { seekBalance++; } else if (e.Delta < 0) { seekBalance--; } ProgressModifierLabelSetText(TimeSpan.FromMilliseconds((seekBalance * SeekIncrement)).ToString()); FutureProgressLabelSetText(TimeSpan.FromMilliseconds(playbackContext.ProgressMs + (seekBalance * SeekIncrement)).ToString("mm\\:ss")); timer.Start(); } }
public TrackInfo WhatIsNowPlaying() { DateTime expireDate = accessToken.CreateDate.AddSeconds(accessToken.ExpiresIn); if (DateTime.Compare(DateTime.Now, expireDate.AddMinutes(-1)) > 0) { accessToken = authorization.RefreshToken(refreshToken.RefreshToken).Result; webApi.AccessToken = accessToken.AccessToken; if (accessToken.RefreshToken != null) { refreshToken = accessToken; } } try { PlaybackContext context = webApi.GetPlayingTrack(); if (context.IsPlaying && !TrackType.Ad.Equals(context.CurrentlyPlayingType)) { FullTrack track = context.Item; return(new TrackInfo(track.Artists[0].Name, track.Name, track.Album.Images[0].Url)); } } catch (AggregateException) { } return(null); }
public void GetTrackname(string command, string args) { var chat = this.pluginInterface.Framework.Gui.Chat; PlaybackContext context = _spotify.GetPlayingTrack(); if (context.Item != null) { String songname = context.Item.Name; String artists = ""; for (int i = 0; i < context.Item.Artists.Count; i++) { if (i == context.Item.Artists.Count - 1) { artists += context.Item.Artists[i].Name; } else { artists += context.Item.Artists[i].Name + " - "; } } chat.Print($"Now Playing: {artists} - {songname}"); } else { chat.Print($"Not playing"); } }
public async Task Play(RadioStation station) { if (!await App.CheckForOffline()) { return; } if (station == null) { App.ShowAlert(Strings.RenameError, Strings.PleaseTryAgain); return; } LogManager.Shared.LogPlay(station); var online = station as OnlineRadioStation; if (online != null) { await MusicManager.Shared.AddTemp(online); } SendEndNotification(ScrobbleManager.PlaybackEndedReason.Skipped); var context = new PlaybackContext { IsContinuous = true, Type = PlaybackContext.PlaybackType.Radio, ParentId = station.Id }; if (context.ParentId != "IFL" && context.Equals(Settings.CurrentPlaybackContext) && CurrentPlaylistSongCount > 0) { Play(); return; } using (new Spinner(Strings.StartingStation)) { Settings.CurrentPlaybackContext = context; var success = await MusicManager.Shared.LoadRadioStationTracks(station); if (!success) { App.ShowAlert(Strings.RenameError, Strings.PleaseTryAgain); return; } } if (Settings.CurrentPlaybackContext?.ParentId != station.Id) { return; } await Task.Run(async() => { string query = $"select SongId as Id from RadioStationSong where StationId = ? order by SOrder"; await SetupCurrentPlaylist(query, "", new[] { station.Id }); }); var song = GetSong(CurrentSongIndex); await NativePlayer.PlaySong(song); await PrepareNextTrack(); }
// Use this for initialization void Start() { ServicePointManager.ServerCertificateValidationCallback = MyRemoteCertificateValidationCallback; ImplicitGrantAuth(); context = _spotify.GetPlayback(); Debug.Log("Device Id: " + context.Device.Id); shuffleState = context.ShuffleState; repeatState = context.RepeatState; privateProfile = _spotify.GetPrivateProfile(); Debug.Log(privateProfile.Country); audioVisualizer = GameObject.Find("AudioVisualizer"); audioVisualizerScript = audioVisualizer.GetComponent <AudioVisualizer>(); featuredPlaylistTabScript = FeaturedPlaylistTab.GetComponent <FeaturedPlaylistTabScript>(); searchResultsScript = searchResultsTab.GetComponent <SearchResultsScript>(); currentSongScript = CurrentSongGameObject.GetComponent <CurrentSong>(); recordPlayerScript = recordPlayer.GetComponent <RecordPlayer>(); //Ignore collisions between character controller and vinyls Physics.IgnoreLayerCollision(8, 9); OnClicked += SendAudioAnaylisToParticleVisualizer; }
private void Resume() { avaiability(async() => { playback = await SpotifyApi.GetPlaybackAsync(); if (playback.Context != null || playback.Item != null) { if (playback.IsPlaying) { PlayerImage = "ic_action_play.png"; ErrorResponse x = await SpotifyApi.PausePlaybackAsync(); } else { PlayerImage = "ic_action_pause.png"; ErrorResponse x = await SpotifyApi.ResumePlaybackAsync(playback.Device.Id, string.Empty, new List <string>() { playback.Item.Uri }, "", playback.ProgressMs); } } }); }
public static void PausePlaySong() { try { using var _spotify = new SpotifyWebAPI() { AccessToken = (string)App.Current.Properties["AccessToken"], TokenType = (string)App.Current.Properties["TokenType"] }; PlaybackContext context = _spotify.GetPlayback(); if (context.IsPlaying) { ErrorResponse error = _spotify.PausePlayback(); App.Current.Properties["userPause"] = true; } else { ErrorResponse error = _spotify.ResumePlayback(offset: ""); App.Current.Properties["userPause"] = false; } } catch { System.Diagnostics.Debug.WriteLine("Failed at Spotify/PausePlaySong"); } }
public static int GetSetVolume(int volume = 255) { try { using var _spotify = new SpotifyWebAPI() { AccessToken = (string)App.Current.Properties["AccessToken"], TokenType = (string)App.Current.Properties["TokenType"] }; // Below should in theory work, but doesn't seem to PlaybackContext context = _spotify.GetPlayback(); if (volume == 255) { return(context.Device.VolumePercent); } else { ErrorResponse _ = _spotify.SetVolume(volume); return(1); } } catch { System.Diagnostics.Debug.WriteLine("Failed at Spotify/GetSetVolume"); return(-1); } }
// ReSharper disable ConstantConditionalAccessQualifier // ReSharper disable once ConstantNullCoalescingCondition public CurrentlyPlayingObject([NotNull] PlaybackContext playbackContext) : this(playbackContext?.ProgressMs ?? 0, playbackContext?.IsPlaying ?? false, null, SpotifyTrackType.Unknown) { if (playbackContext == null) { throw new ArgumentNullException(nameof(playbackContext)); } switch (playbackContext.CurrentlyPlayingType) { case TrackType.Track: if (playbackContext.Item != null) { this.Track = new Song(playbackContext.Item); } break; case TrackType.Episode: this.Track = new SpotifyTrack(SpotifyTrackType.Episode, playbackContext.Item?.Name, (playbackContext.Item?.DurationMs ?? 0) / 1000); break; case TrackType.Ad: this.Track = new SpotifyTrack(SpotifyTrackType.Ad); break; case TrackType.Unknown: this.Track = new SpotifyTrack(SpotifyTrackType.Unknown, playbackContext.Item?.Name, (playbackContext.Item?.DurationMs ?? 0) / 1000); break; default: throw new ArgumentOutOfRangeException(); } this.Type = this.Track?.Type ?? SpotifyTrackType.Unknown; }
protected async void Execute() { while (true) { Thread.Sleep(30000); PlaybackContext Context = await Api.GetPlayingTrackAsync(); if (!Context.HasError() && Context.IsPlaying && IsNotAd(Context)) { List <string> Artists = new List <string>(); Context.Item.Artists.ForEach(Artist => Artists.Add(Artist.Name)); string SlackMessage = String.Format("Listening To: {0} by {1} ({2})", Context.Item.Name, String.Join(", ", Artists), Context.Item.Album.Name); string UserId = Environment.GetEnvironmentVariable("SPLACK_SLACK_USER_ID"); JObject Profile = new JObject(); Profile["status_text"] = SlackMessage; Profile["status_emoji"] = ":notes:"; Profile["status_expiration"] = (long)DateTimeOffset.Now.ToUnixTimeSeconds() + ((Context.Item.DurationMs - Context.ProgressMs) / 1000); Dictionary <string, string> Values = new Dictionary <string, string> { { "user", UserId }, { "profile", Profile.ToString() } }; FormUrlEncodedContent Content = new FormUrlEncodedContent(Values); HttpResponseMessage Response = await SlackClient.PostAsync("https://slack.com/api/users.profile.set", Content); } } }
private void Button_Click(object sender, RoutedEventArgs e) { // Get the selected track info TrackInfo ti = ArtistListBox.SelectedItem as TrackInfo; // If the track info is good, play it (or pause if playing) if (ti == null) { return; } ErrorResponse err = null; PlaybackContext playback = _spotify.GetPlayback(); if (_trackIsPlaying) { err = _spotify.PausePlayback(); } else { List <string> trackUris = new List <string> { "spotify:track:" + ti.TrackId }; err = _spotify.ResumePlayback(deviceId: _spotifyPlaybackDevice, contextUri: "", uris: trackUris, offset: "", positionMs: 0); } if (err?.Error?.Status != 0) { _trackIsPlaying = !_trackIsPlaying; } else { // TODO: evaluate error } }
/// <summary> /// Displays the current song being played from Spotify /// </summary> /// <param name="chatter">User that sent the message</param> public static async Task <string> SpotifyCurrentSongAsync(TwitchChatter chatter, SpotifyWebClient spotify) { PlaybackContext playbackContext = await spotify.GetPlaybackAsync(); if (playbackContext != null && playbackContext.IsPlaying) { string artistName = ""; foreach (SimpleArtist simpleArtist in playbackContext.Item.Artists) { artistName += $"{simpleArtist.Name}, "; } artistName = artistName.ReplaceLastOccurrence(", ", ""); TimeSpan progressTimeSpan = TimeSpan.FromMilliseconds(playbackContext.ProgressMs); TimeSpan durationTimeSpan = TimeSpan.FromMilliseconds(playbackContext.Item.DurationMs); return($"@{chatter.DisplayName} <-- Now playing from Spotify: \"{playbackContext.Item.Name}\" by {artistName} " + "https://open.spotify.com/track/" + playbackContext.Item.Id + " " + $"Currently playing at {progressTimeSpan.ReformatTimeSpan()} of {durationTimeSpan.ReformatTimeSpan()}"); } else { return($"Nothing is playing at the moment @{chatter.DisplayName}"); } }
internal static PlaybackResponse MapContext(this PlaybackContext context) { if (context == null) { return(new PlaybackResponse("Could not reach Spotify services")); } if (context.HasError()) { return(new PlaybackResponse(context.Error.Message)); } if (context.Item == null) { return(new PlaybackResponse("Could not find a playable device/track")); } return(new PlaybackResponse( isPlaying: context.IsPlaying, progress: context.ProgressMs, track: new Track( name: context.Item.Name, artist: string.Join(", ", context.Item.Artists.Select(artist => artist.Name)), album: context.Item.Album.Name, albumArt: context.Item.Album.Images.FirstOrDefault()?.Url, duration: context.Item.DurationMs))); }
private void trackChanged(object sender, AudioChangeArgs e) { if (e.getPlayback().Item != null) { PlaybackContext track = e.getPlayback(); pictureBox1.Load(track.Item.Album.Images[0].Url); WriteTextSafe(track.Item.Name); try { ArduinoInterface.sendFromImageUrl(track.Item.Album.Images[0].Url); ArduinoInterface.sendPlay(track.ProgressMs * 1000, track.Item.DurationMs * 1000); } catch (Exception ee) { RefreshButton.Visible = true; } } else { pictureBox1.Image = Properties.Resources.NoSong; WriteTextSafe("No Song Playing"); try { ArduinoInterface.sendImage(Properties.Resources.NoSong); ArduinoInterface.sendPause(0, 0); } catch (Exception ee) { RefreshButton.Visible = true; } } }
public void PlayURIThread(string playlistURI) { PlaybackContext context = _spotify.GetPlayback(); if (context.Device == null || context.Device.Id == null || context.Device.Id == "") { Debug.LogError("Invalid device"); return; } else { Debug.Log("In PlayURIThread, have gotten spotify playback, device id is " + context.Device.Id); } // float before = Time.realtimeSinceStartup; ErrorResponse error = _spotify.ResumePlayback(context.Device.Id, playlistURI); // Debug.Log("Time taken to play URI: " + (Time.realtimeSinceStartup - before)); if (error.Error != null) { Debug.LogError(error.Error.Message); Debug.LogError(error.Error.Status); Debug.LogError(playlistURI); } }
public void PausePlaybackThread() { PlaybackContext context = _spotify.GetPlayback(); if (context.Device == null || context.Device.Id == null || context.Device.Id == "") { Debug.LogError("Invalid device"); return; } else { Debug.Log("In PausePlaybackThread, have gotten spotify playback, device id is " + context.Device.Id); } if (context.IsPlaying) { ErrorResponse error = _spotify.PausePlayback(context.Device.Id); audioVisualizerScript.repeat = false; if (error.Error != null) { Debug.LogError(error.Error.Status); Debug.LogError(error.Error.Message); } } // pausePlaybackRunning = false; }
public void PlaySongURIThread(string songURI) { Debug.Log("In PlaySongUriThread"); PlaybackContext context = _spotify.GetPlayback(); if (context.Device == null || context.Device.Id == null || context.Device.Id == "") { Debug.LogError("Invalid device"); threadRunning = false; return; } else { Debug.Log("In PlaySongUriThread, have gotten spotify playback, device id is " + context.Device.Id); } ErrorResponse error = _spotify.ResumePlayback(context.Device.Id, uris: new List <string> { songURI }); Debug.Log("Spotify Resume Playback has been called"); if (error.HasError()) { Debug.LogError(error.Error.Message); Debug.LogError(error.Error.Status); } threadRunning = false; }
public void SkipPlaybackToPreviousThread() { PlaybackContext context = _spotify.GetPlayback(); if (context.Device == null || context.Device.Id == null || context.Device.Id == "") { Debug.LogError("Invalid device"); return; } else { Debug.Log("In SkipPlaybackToNext, have gotten spotify playback, device id is " + context.Device.Id); } if (context.IsPlaying) { ErrorResponse error = _spotify.SkipPlaybackToPrevious(); if (error.Error != null) { Debug.LogError(error.Error.Message); } } else { Debug.Log("Can't skip playback to previous if not currently playing"); } // skipPlaybackToPreviousRunning = false; }
public JsonResult NowPlaying() { Dictionary <string, string> nowPlaying = new Dictionary <string, string>(); if (User.Identity.IsAuthenticated) { string accessToken = HttpContext.GetTokenAsync("access_token").Result; try { // For usage visit: https://github.com/JohnnyCrazy/SpotifyAPI-NET/ SpotifyWebAPI spotifyAPI = new SpotifyWebAPI { AccessToken = accessToken, TokenType = "Bearer" }; PrivateProfile profile = spotifyAPI.GetPrivateProfileAsync().Result; PlaybackContext context = spotifyAPI.GetPlayback(); if (!profile.HasError()) { nowPlaying.Add("SpotifyName", profile.DisplayName); nowPlaying.Add("SpotifyAvatar", profile.Images.FirstOrDefault().Url); nowPlaying.Add("SpotifyProfileUrl", "https://open.spotify.com/user/" + profile.Id); } if (context.Item != null && (context.IsPlaying)) { nowPlaying.Add("SongName", context.Item.Name); nowPlaying.Add("SongUrl", context.Item.Href); nowPlaying.Add("ArtistName", context.Item.Artists.FirstOrDefault().Name); nowPlaying.Add("ArtistUrl", context.Item.Artists.FirstOrDefault().Href); nowPlaying.Add("NowPlaying", nowPlaying["SongName"] + " by " + nowPlaying["ArtistName"]); nowPlaying.Add("AlbumArt", context.Item.Album.Images.FirstOrDefault().Url); nowPlaying.Add("AlbumUrl", context.Item.Album.ExternalUrls["spotify"]); nowPlaying.Add("IsPlaying", "true"); } else { nowPlaying.Add("SongName", null); nowPlaying.Add("SongUrl", null); nowPlaying.Add("ArtistName", null); nowPlaying.Add("ArtistUrl", null); nowPlaying.Add("NowPlaying", null); nowPlaying.Add("AlbumArt", null); nowPlaying.Add("AlbumUrl", null); nowPlaying.Add("IsPlaying", "false"); } GeniusService geniusService = new GeniusService(nowPlaying["SongName"], nowPlaying["ArtistName"]); nowPlaying.Add("Lyrics", geniusService.Lyrics); nowPlaying.Add("LyricsContribution", geniusService.Url); } catch (Exception ex) { // show the users some error } } return(new JsonResult(nowPlaying)); }
public HoldEffectBinding(PlaybackContext playbackContext, ObjectReference attachedObject) : base(playbackContext) { AttachedObject = attachedObject; CreateEffect(playbackContext.Playback.Beatmap.GetEffectSettings(Hold.EffectType)); // Apply object parameters to hold note effect EffectState.ApplyObjectParameters(attachedObject); }
public RockolappScreenData GetCurrentTrack(string spotifyUserId) { string token; var user = dataAccess.GetUser(spotifyUserId); var spotify = new SpotifyWebAPI() { TokenType = "Bearer", AccessToken = user.Token, UseAuth = true }; PlaybackContext context = spotify.GetPlayingTrack(); if (context.HasError() && context.Error.Status == 401) { AutorizationCodeAuth auth = new AutorizationCodeAuth(); //Datos de mi aplicacion Rocolapp auth.ClientId = DataAccess.GetRocolappData().ClientId; auth.RedirectUri = DataAccess.GetRocolappData().RedirectUri; string clientSecret = DataAccess.GetRocolappData().ClientSecret; Token newToken = auth.RefreshToken(user.RefreshToken, DataAccess.GetRocolappData().ClientSecret); dataAccess.UpdateToken(user.Id.ToString(), newToken.AccessToken); token = newToken.AccessToken; var withRefreshedToken = new SpotifyWebAPI() { TokenType = "Bearer", AccessToken = newToken.AccessToken, UseAuth = true }; context = withRefreshedToken.GetPlayingTrack(); } RockolappScreenData screenData = new RockolappScreenData(); try { screenData.TrackName = context.Item.Name; screenData.Artist = context.Item.Artists.First().Name; screenData.Duration = context.Item.DurationMs; screenData.LapsedTime = context.ProgressMs; screenData.ImageUrl = context.Item.Album.Images.First().Url; } catch (Exception) { } return(screenData); }
private void CheckEventCallback( ICollection <EventToSend> eventsToSend, ICollection <ReceivedEvent> expectedReceivedEvents, TimeSpan changeCallbackAfter, EventCallback eventCallback, EventCallback secondEventCallback) { var playbackContext = new PlaybackContext(); var receivedEvents = playbackContext.ReceivedEvents; var sentEvents = playbackContext.SentEvents; var stopwatch = playbackContext.Stopwatch; var tempoMap = playbackContext.TempoMap; var eventsForPlayback = GetEventsForPlayback(eventsToSend, tempoMap); var notesStarted = new List <Note>(); var notesFinished = new List <Note>(); using (var outputDevice = OutputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { SendReceiveUtilities.WarmUpDevice(outputDevice); outputDevice.EventSent += (_, e) => sentEvents.Add(new SentEvent(e.Event, stopwatch.Elapsed)); using (var playback = new Playback(eventsForPlayback, tempoMap, outputDevice)) { playback.NotesPlaybackStarted += (_, e) => notesStarted.AddRange(e.Notes); playback.NotesPlaybackFinished += (_, e) => notesFinished.AddRange(e.Notes); playback.EventCallback = eventCallback; using (var inputDevice = InputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { inputDevice.EventReceived += (_, e) => { lock (playbackContext.ReceivedEventsLockObject) { receivedEvents.Add(new ReceivedEvent(e.Event, stopwatch.Elapsed)); } }; inputDevice.StartEventsListening(); stopwatch.Start(); playback.Start(); SpinWait.SpinUntil(() => stopwatch.Elapsed >= changeCallbackAfter); playback.EventCallback = secondEventCallback; var timeout = TimeSpan.FromTicks(eventsToSend.Sum(e => e.Delay.Ticks)) + SendReceiveUtilities.MaximumEventSendReceiveDelay; var playbackStopped = SpinWait.SpinUntil(() => !playback.IsRunning, timeout); Assert.IsTrue(playbackStopped, "Playback is running after completed."); } } } CompareReceivedEvents(receivedEvents, expectedReceivedEvents.ToList()); }
public async Task PausePlayback() { PlaybackContext context = await api.GetPlaybackAsync(); if (context.IsPlaying) { await api.PausePlaybackAsync(); } }
public async Task ResumePlayback() { PlaybackContext context = await api.GetPlaybackAsync(); if (context.IsPlaying == false) { await api.ResumePlaybackAsync("", "", null, "", 0); } }
public void Refresh(PlaybackContext playback) { if (playback?.HasError() == false && playback.Item?.HasError() == false && playback.ProgressMs != currentTime) { TrackTimeChanged?.Invoke(new TrackTimeInfo((uint)playback.ProgressMs, (uint)playback.Item.DurationMs)); currentTime = playback.ProgressMs; } }
public static void Main(string[] args) { string artistName = string.Empty; string trackName = string.Empty; try { PlaybackContext pc = Spotify.GetPlayback(); if (pc == null) { throw new Exception("PlaybackContext null"); } if (pc.Error != null) { throw new Exception($"{pc.Error.Status} - {pc.Error.Message}"); } if (pc.Item == null) { throw new Exception("FullTrack null"); } artistName = pc.Item.Artists?.FirstOrDefault()?.Name; trackName = pc.Item.Name; foreach (ILyrics lyrics in LyricsWebsites) { string lyricsResult = lyrics.SearchLyricsUrl(artistName, trackName); if (string.IsNullOrWhiteSpace(lyricsResult)) { continue; } Process.Start(lyricsResult); return; } MessageBox.Show($"Artist: {artistName}\nTrack: {trackName}", "Lyrics not found"); } catch (Exception e) { if (EhDebug) { throw; } string message = e.ToString(); if (!string.IsNullOrWhiteSpace(artistName) || !string.IsNullOrWhiteSpace(trackName)) { message = $"Artist: {artistName}\nTrack: {trackName}\n{message}"; } Trace.TraceError(message); MessageBox.Show(message, "Exception"); } }
public static void ChangePlayback(SpotifyWebAPI api, FullPlaylist playlist) { String UriTrack = GetUriRandom(api, playlist); PlaybackContext play = api.GetPlayingTrack(); api.SetVolume(50); api.ResumePlayback(deviceId: "", contextUri: playlist.Uri, uris: null, offset: ""); }
private void CheckTrackControlValueWithOutputDevice( ICollection <EventToSend> eventsToSend, ICollection <EventToSend> eventsWillBeSent, TimeSpan moveFrom, TimeSpan moveTo) { var playbackContext = new PlaybackContext(); var receivedEvents = playbackContext.ReceivedEvents; var sentEvents = playbackContext.SentEvents; var stopwatch = playbackContext.Stopwatch; var tempoMap = playbackContext.TempoMap; var eventsForPlayback = GetEventsForPlayback(eventsToSend, tempoMap); var notes = eventsForPlayback.GetNotes().ToArray(); using (var outputDevice = OutputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { SendReceiveUtilities.WarmUpDevice(outputDevice); outputDevice.EventSent += (_, e) => sentEvents.Add(new SentEvent(e.Event, stopwatch.Elapsed)); using (var playback = new Playback(eventsForPlayback, tempoMap, outputDevice)) { playback.TrackControlValue = true; using (var inputDevice = InputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { inputDevice.EventReceived += (_, e) => { lock (playbackContext.ReceivedEventsLockObject) { receivedEvents.Add(new ReceivedEvent(e.Event, stopwatch.Elapsed)); } }; inputDevice.StartEventsListening(); stopwatch.Start(); playback.Start(); SpinWait.SpinUntil(() => stopwatch.Elapsed >= moveFrom); playback.MoveToTime((MetricTimeSpan)moveTo); var timeout = TimeSpan.FromTicks(eventsWillBeSent.Sum(e => e.Delay.Ticks)) + SendReceiveUtilities.MaximumEventSendReceiveDelay; var areEventsReceived = SpinWait.SpinUntil(() => receivedEvents.Count == eventsWillBeSent.Count, timeout); Assert.IsTrue(areEventsReceived, $"Events are not received for timeout {timeout}."); stopwatch.Stop(); var playbackStopped = SpinWait.SpinUntil(() => !playback.IsRunning, SendReceiveUtilities.MaximumEventSendReceiveDelay); Assert.IsTrue(playbackStopped, "Playback is running after completed."); } } } CompareSentReceivedEvents(sentEvents, receivedEvents, eventsWillBeSent.ToList()); }
public static async Task <bool> AddHistoryToDatabase(PlaybackContext data, string userId) { using (var db = new AiApiDbContext()) { try { var fullTrack = new dFullTrack { Id = data.Item.Id, Explicit = data.Item.Explicit, Name = data.Item.Name, PreviewUrl = data.Item.PreviewUrl, TrackNumber = data.Item.TrackNumber, Uri = data.Item.Uri, Type = data.Item.Type }; if (data.Item.Artists.Any()) { fullTrack.Artist1Id = data.Item.Artists[0].Id; if (data.Item.Artists.Count > 1) { fullTrack.Artist2Id = data.Item.Artists[1].Id; } } //let's make sure we don't already have the song in here if (!db.Songs.Any(s => s.Name == fullTrack.Name && s.Artist1Id == fullTrack.Artist1Id)) { //add the track to query db.Songs.Add(fullTrack); } //then we'll grab the instance of it. var playHistory = new dPlayHistory { PrivateProfile = db.PrivateProfiles.SingleOrDefault(x => x.Id == userId), PrivateProfilesId = userId, Name = data.Item.Name, PlayedAt = DateTime.Now, TrackId = data.Item.Id }; db.RecentlyPlayed.Add(playHistory); await db.SaveChangesAsync(); } catch (Exception ex) { return(false); } return(true); } }