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 Lobby() { InitializeComponent(); _spotifyApi = new SpotifyApi(); _user = _spotifyApi.GetUser(); }
public ExportPlaylist(SpotifyApi _spotifyApi) { InitializeComponent(); spotifyApi = _spotifyApi; Task.Run(() => RunView()).Wait(); }
public R <IList <AudioResource>, LocalStr> Search(ResolveContext ctx, string keyword) { var searchResult = api.Request(() => api.Client.Search.Item( new SearchRequest(SearchRequest.Types.Track, keyword)) ); if (!searchResult.Ok) { return(searchResult.Error); } if (searchResult.Value.Tracks.Total > SearchLimit) { return(new LocalStr("Too many search results, please make your search query more specific.")); } var pagesTask = api.Client.PaginateAll(searchResult.Value.Tracks, (s) => s.Tracks); var pagesTaskResolveResult = api.ResolveRequestTask(pagesTask); if (!pagesTaskResolveResult.Ok) { return(pagesTaskResolveResult.Error.Item2); } var result = new List <AudioResource>(); foreach (var item in pagesTask.Result) { result.Add(new AudioResource(item.Uri, SpotifyApi.TrackToName(item), ResolverFor)); } return(result); }
public R <PlayResource, LocalStr> GetResource(ResolveContext ctx, string uriOrUrl) { string uri; // Convert if it is a URL. var uriResult = SpotifyApi.UrlToUri(uriOrUrl); if (uriResult.Ok) { uri = uriResult.Value; } else { uri = uriOrUrl; } var trackOption = api.UriToTrack(uri); if (!trackOption.Ok) { return(trackOption.Error); } var resource = new AudioResource(uri, SpotifyApi.TrackToName(trackOption.Value), ResolverFor); return(new PlayResource(resource.ResourceId, resource)); }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "callback")] HttpRequest req, [Table( TableConstants.AuthorizeStateTable, Connection = Constants.StorageConnection )] CloudTable authorizeTable, [Table( TableConstants.UserTable, Connection = Constants.StorageConnection )] CloudTable userTable, ILogger log) { await authorizeTable.CreateIfNotExistsAsync(); await userTable.CreateIfNotExistsAsync(); string code = req.Query["code"]; string error = req.Query["error"]; string state = req.Query["state"]; if (!string.IsNullOrWhiteSpace(error)) { log.LogError("Received error from Spotify authorization: {Error}", error); return(new BadRequestResult()); } var getAuthorizedOperation = TableOperation.Retrieve <AuthorizeEntity>(TableConstants.AuthorizePartitionKey, state); var result = await authorizeTable.ExecuteAsync(getAuthorizedOperation); var entity = result.Result as AuthorizeEntity; if (entity == null) { log.LogError("Could not find associated authorize entity. Callback may have been called twice."); return(new NotFoundResult()); } var deleteAuthorizeOperation = TableOperation.Delete(entity); await authorizeTable.ExecuteAsync(deleteAuthorizeOperation); var tokenResponse = await SpotifyApi.FinishAuthorizeAsync(code, $"{req.Scheme}://{req.Host}/api/callback"); var spotifyUserInfo = await SpotifyApi.GetUserInfoAsync(tokenResponse.access_token); var user = UserEntity.Map(spotifyUserInfo); var repo = new UserRepository(userTable); await repo.AddUser(user); await SecretRepository.SaveToken(user.RowKey, new TokenSecrets { AccessToken = tokenResponse.access_token, RefreshToken = tokenResponse.refresh_token, ExpiresInUtc = DateTime.UtcNow.AddSeconds(tokenResponse.expires_in) }); return(new RedirectResult("/")); }
public PlaylistMenuFunctions(TracksConverter tracksConverter, PlaylistsUtils playlistsUtils, TrackMenuFunctions trackMenuFunctions, ExitFunctions exitFunctions, SpotifyApi spotifyApi) { _tracksConverter = tracksConverter; _playlistsUtils = playlistsUtils; _trackMenuFunctions = trackMenuFunctions; _exitFunctions = exitFunctions; _spotifyApi = spotifyApi; }
public async Task <Playlist> CopyPlaylist(Models.PlaylistRequest request) { var playlist = Playlists.First(t => t.Id == request.PlaylistId); var savedCopy = await _spotifyWebApi.CreatePlaylist(playlist, SpotifyApi.Playlists(Me), Token); Playlists.Add(savedCopy); return(savedCopy); }
public async Task <IActionResult> PlayLists() { var envelope = await _spotify.Get <Envelope <Playlist> >(SpotifyApi.Playlists(_playlistManager.Me), _playlistManager.Token); _playlistManager.Reset(); _playlistManager.Playlists.AddRange(envelope.Items); return(new OkObjectResult(_playlistManager.Playlists)); }
public ResourceResolver(ConfFactories conf, SpotifyApi spotifyApi) { AddResolver(new MediaResolver()); AddResolver(new YoutubeResolver(conf.Youtube)); AddResolver(new SoundcloudResolver()); AddResolver(new TwitchResolver()); AddResolver(new BandcampResolver()); AddResolver(new SpotifyResolver(spotifyApi)); }
public AlbumMenuFunctions(AlbumsUtils albumsUtils, TracksConverter tracksConverter, ExitFunctions exitFunctions, TrackMenuFunctions trackMenuFunctions, SpotifyApi spotifyApi) { _albumsUtils = albumsUtils; _tracksConverter = tracksConverter; _exitFunctions = exitFunctions; _trackMenuFunctions = trackMenuFunctions; _spotifyApi = spotifyApi; }
public ArtistMenuFunctions(ArtistsUtils artistsUtils, SpotifyApi spotifyApi, TracksGenerator tracksGenerator, AlbumsGenerator albumsGenerator, ExitFunctions exitFunctions) { _artistsUtils = artistsUtils; _spotifyApi = spotifyApi; _tracksGenerator = tracksGenerator; _albumsGenerator = albumsGenerator; _exitFunctions = exitFunctions; }
public MatchCertainty MatchResource(ResolveContext ctx, string uri) { if (SpotifyApi.UriToTrackId(uri).Ok || SpotifyApi.UrlToTrackId(uri).Ok) { return(MatchCertainty.Always); } return(MatchCertainty.Never); }
private void Forward() { avaiability(async() => { playback = await SpotifyApi.GetPlaybackAsync(); if (playback.Context != null || playback.Item != null) { ErrorResponse x = await SpotifyApi.ResumePlaybackAsync(playback.Device.Id, string.Empty, new List <string>() { playback.Item.Uri }, "", playback.ProgressMs + 10000); } }); }
public async Task AddTracks(AddTracksRequest requestedTracks, string token) { var request = new HttpRequestMessage(HttpMethod.Post, SpotifyApi.PlaylistTracks(requestedTracks.PlaylistId)); request.Headers.Add("Authorization", $"Bearer {token}"); request.Content = new StringContent(JsonSerializer.Serialize(requestedTracks.Tracks)); request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); var client = _httpClient.CreateClient(); var response = await client.SendAsync(request); if (!response.IsSuccessStatusCode) { var error = new Exception($"Add tracks failed with: {response.StatusCode} - {await response.Content.ReadAsStringAsync()}"); _logger.Error(error, string.Empty); throw error; } }
public R <Uri, LocalStr> GetThumbnailUrl(ResolveContext ctx, PlayResource playResource) { var trackId = SpotifyApi.UriToTrackId(playResource.BaseData.ResourceId); if (!trackId.Ok) { return(trackId.Error); } var response = api.Request(() => api.Client.Tracks.Get(trackId.Value)); if (!response.Ok) { return(response.Error); } return(new Uri(response.Value.Album.Images.OrderByDescending(item => item.Height).ToList()[0].Url)); }
public static void Initialize(TestContext tc) { IO.WriteLine = _ => { }; IO.Write = _ => { }; IO.ReadKey = () => new ConsoleKeyInfo(); IO.ReadLine = () => "string"; IO.Clear = () => { }; var a = new SpotifyApi(); var spotifyApi = new SpotifyApi { Spotify = Authorization.Authorize() }; var privateProfile = spotifyApi.Spotify.GetPrivateProfile(); spotifyApi.CurrentUserId = privateProfile.Id; SpotifyApi = spotifyApi; }
public async Task <ShuffleResponse> ShufflePlaylist(Models.PlaylistRequest request) { var copiedPlaylist = await CopyPlaylist(request); var tracks = await GetPlaylistTracks(request); await AddTracks(new AddTracksRequest { PlaylistId = copiedPlaylist.Id, Tracks = tracks.Select(t => t.Uri).Shuffle() }); Reset(); var envelope = await _spotifyWebApi.Get <Envelope <Playlist> >(SpotifyApi.Playlists(Me), Token); Playlists.AddRange(envelope.Items); tracks = await GetPlaylistTracks(new Models.PlaylistRequest { PlaylistId = copiedPlaylist.Id }); return(new ShuffleResponse { PlaylistName = copiedPlaylist.Name, TracksAdded = tracks.Count() }); }
private async void avaiability(Action action) { if (SpotifyApi != null) { if ((await SpotifyApi.GetDevicesAsync()).Devices.Count != 0) { playback = await SpotifyApi.GetPlaybackAsync(); if (playback.CurrentlyPlayingType.Equals(TrackType.Track)) { if (Logged) { if (playback.Item != null || playback.Item.Name != (await SpotifyApi.GetPlaybackAsync()).Item.Name) { action(); } else { CrossToastPopUp.Current.ShowToastMessage("Errore durante il download del testo"); } } else { CrossToastPopUp.Current.ShowToastMessage("login richiesto"); } } else { CrossToastPopUp.Current.ShowToastMessage("Impossibile scaricare il testo, non è una canzone"); } } else { CrossToastPopUp.Current.ShowToastMessage("Accedi a spotify da uno dei tuoi dispositivi!"); } } else { CrossToastPopUp.Current.ShowToastMessage("Login Richiesto"); } }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "authorize")] HttpRequest req, [Table( TableConstants.AuthorizeStateTable, Connection = Constants.StorageConnection )] CloudTable table, ILogger log) { await table.CreateIfNotExistsAsync(); var state = Guid.NewGuid().ToString(); var operation = TableOperation.Insert(new AuthorizeEntity { PartitionKey = TableConstants.AuthorizePartitionKey, RowKey = state }); await table.ExecuteAsync(operation); return(new RedirectResult(SpotifyApi.StartAuthorizeRedirectUrl($"{req.Scheme}://{req.Host}/api/callback", state))); }
private async Task UpdateUI() { playback = await SpotifyApi.GetPlaybackAsync(); AlbumName = playback.Item.Album.Name; AlbumImage = playback.Item.Album.Images.FirstOrDefault().Url; TrackName = playback.Item.Name; ArtistName = playback.Item.Artists.FirstOrDefault().Name; if (playback.IsPlaying) { PlayerImage = "ic_action_pause.png"; } else { PlayerImage = "ic_action_play.png"; } SetLyrics(playback.Item.Artists.FirstOrDefault().Name, playback.Item.Album.Name, playback.Item.Name); App.Mongo.UpdateMongoDbArtist(playback.Item.Artists.FirstOrDefault().Name, playback.Item.Album.Name, playback.Item.Name, Lyrics); }
private async void TestAuth() { //Problemi // - funziona solo quando spotify è già in riproduzione // - funziona solo quando spotify è aperto in uno dei qualsiasi dispositivi a cui è collegato l'account // Istanzio qui il playback dato che ad ogni click deve scaricare le informazioni sul brano playback = await SpotifyApi.GetPlaybackAsync(); if (playback.Context != null || playback.Item != null) { if (playback.IsPlaying) { ErrorResponse x = await SpotifyApi.PausePlaybackAsync(); } else { ErrorResponse x = await SpotifyApi.ResumePlaybackAsync(playback.Device.Id, string.Empty, new List <string>() { playback.Item.Uri }, "", playback.ProgressMs); } } }
private static async Task <string> GetAccessToken(string userId) { TokenSecrets tokens = null; try { tokens = await SecretRepository.GetToken(userId); } catch (TokenExpiredException ex) { var tokenResponse = await SpotifyApi.RefreshTokenAsync(ex.RefreshToken); tokens = new TokenSecrets { AccessToken = tokenResponse.access_token, RefreshToken = tokenResponse.refresh_token ?? ex.RefreshToken, ExpiresInUtc = DateTime.UtcNow.AddSeconds(tokenResponse.expires_in) }; await SecretRepository.SaveToken(userId, tokens); } return(tokens.AccessToken); }
public string RestoreLink(ResolveContext ctx, AudioResource resource) { return(SpotifyApi.UriToUrl(resource.ResourceId).OkOr(null)); }
public Login() { InitializeComponent(); _spotifyApi = new SpotifyApi(); }
public SpotifyResolver(SpotifyApi api) { this.api = api; }
public LibrespotPlayer(SpotifyApi api, ConfLibrespot conf) { this.api = api; this.conf = conf; state = State.NotSetUp; Log.Trace("Changed librespot state to notsetup."); output = new List <string>(); void Fail(string message) { Log.Error(message); state = State.NotSetUp; Log.Trace("Failed setup of librespot, changed state to notsetup."); if (process != null && !process.HasExitedSafe()) { process.Kill(); } if (process != null) { process.Close(); process = null; } } // Check if spotify is available. if (api.Client == null) { Fail($"Failed to setup Librespot: Spotify API access was not set up correctly. Cannot play from spotify."); return; } // Get device ID for librespot. // 1. Connect librespot for it to appear in the API. var processOption = LaunchLibrespot(); if (!processOption.Ok) { Fail($"Failed to setup Librespot: {processOption.Error}"); return; } // 2. Fetch device ID via API. var response = api.Request(() => api.Client.Player.GetAvailableDevices()); if (!response.Ok) { Fail($"Failed to setup Librespot: Could not get device ID - {response.Error}."); return; } deviceId = ""; foreach (var device in response.Value.Devices.Where(device => device.Name == conf.LibrespotDeviceName)) { deviceId = device.Id; } // 3. Check for success. if (deviceId == "") { Fail("Failed to setup Librespot: Could not get device ID."); return; } // 4. Exit Librespot. process.Kill(); process.Close(); process = null; Log.Trace("Set up Librespot, changed state to idle."); state = State.Idle; }
public TracksUtils(TracksConverter tracksConverter, SpotifyApi spotifyApi) { _tracksConverter = tracksConverter; _spotifyApi = spotifyApi; }
private async void getPlaylist() { //show progress indicator setProgressIndicator(true); SystemTray.ProgressIndicator.Text = "Getting your Tweet Mix"; try { //set an int as the id int id = 0; //build twitter url string url = twitter.getUrl(username, apiAttempt); //call twitter vaI base api class, we only want the response code at this point string apiResponse = await twitter.Call(url); //if the response did not come back null or contain an error code if (apiResponse != null || apiResponse.Contains("Error: ")) { //use json.net to turn json into an opject TwitterItems apiData = JsonConvert.DeserializeObject <TwitterItems>(apiResponse); //loop through and set everything to the list foreach (Status data in apiData.statuses) { PlayListItems items = new PlayListItems(); //add id to list items.ID = id.ToString(); //add twitter details to list items.Message = data.text; items.ProfileImage = data.user.profile_image_url; items.Username = data.user.name; //go spilt the message via the Song class Song song = spiltMessage(data.text); //add those values to the list items.ArtistName = song.Artist; items.SongName = song.Track; //now we need the artowrk so go get it from spotify as its more reliable SpotifyApi spotify = new SpotifyApi(); //build a url of the songname to go ask spotify for its details string spotifySearchUrl = spotify.BuildSearchUrl(song.Track); string response = await spotify.Call(spotifySearchUrl); //add in method so that calls can be used again if (response != null) { List <SpotifyItem> tracks = new List <SpotifyItem>(); SpotifyItem spotifyApiData = JsonConvert.DeserializeObject <SpotifyItem>(response); //call the spotify embed api to go get artwork string spotifyArtowrkUrl = spotify.buildEmbedUrl(spotifyApiData.tracks[0].href); string artworkResponse = await spotify.Call(spotifyArtowrkUrl); SpotifyImageItems imageData = JsonConvert.DeserializeObject <SpotifyImageItems>(artworkResponse); items.AlbumArtworkUrl = imageData.thumbnail_url; } Items.Add(items); id++; } } else if (apiResponse.Contains("Error: ")) { //lets go see what error it is int errorCode = twitter.getCorrectError(apiResponse); if (errorCode == 429 && apiAttempt < 3) { setProgressIndicator(false); //call again; callAgain(); } else { string errorMessage = twitter.ErrorMesssage(errorCode); showError(errorMessage); callAgain(); setProgressIndicator(false); } } setProgressIndicator(false); } catch (UnauthorizedAccessException) { MessageBox.Show("Wifi is disabled in phone settings"); } catch (Exception e) { MessageBox.Show(e.Message); setProgressIndicator(false); callAgain(); } setDataContext(); }
public TrackMenuFunctions(TracksUtils tracksUtils, ExitFunctions exitFunctions, SpotifyApi spotifyApi) { _tracksUtils = tracksUtils; _exitFunctions = exitFunctions; _spotifyApi = spotifyApi; }