/*
* Wrapper for Spotify Resume with specific requests for a playlist. Empty String will play from saved tracks
*/
public async void ResumePlayback(string uri)
{
var request = new PlayerResumePlaybackRequest();
if (uri.Length == 0)
{
request.Uris = GetSavedTracks();
}
else
{
request.ContextUri = uri;
}
try
{
var isSuccess = await spotify.Player.ResumePlayback(request);
if (!isSuccess)
{
Logger.Log("Playlist resume unsuccessful");
}
}
catch (APIException ex)
{
Logger.Log("Playlist resume failed: " + ex.Message);
}
}
public static async Task PlayPlaylist(SimplePlaylist playlist)
{
var json = await File.ReadAllTextAsync(CredentialsPath);
var token = JsonConvert.DeserializeObject <PKCETokenResponse>(json);
var authenticator = new PKCEAuthenticator(clientId !, token);
authenticator.TokenRefreshed += (sender, token) => File.WriteAllText(CredentialsPath, JsonConvert.SerializeObject(token));
var config = SpotifyClientConfig.CreateDefault()
.WithAuthenticator(authenticator);
var spotify = new SpotifyClient(config);
var me = await spotify.UserProfile.Current();
PlayerResumePlaybackRequest teste = new PlayerResumePlaybackRequest();
teste.ContextUri = playlist.Uri;
await spotify.Player.ResumePlayback(teste);
_server.Dispose();
// Environment.Exit(0);
}
public async Task <bool> PlaybackMediaItem(ItemMediaBase item, int index = 0, bool shuffle = false)
{
try
{
var spotify = await Authentication.GetSpotifyClientAsync();
if (spotify == null)
{
return(false);
}
PlayerResumePlaybackRequest request = new PlayerResumePlaybackRequest
{
ContextUri = item.Uri,
OffsetParam = new PlayerResumePlaybackRequest.Offset {
Position = index
},
};
if (await spotify.Player.ResumePlayback(request))
{
if (shuffle)
{
await spotify.Player.SetShuffle(new PlayerShuffleRequest(true));
}
return(true);
}
else
{
string webUrl = null;
try
{
webUrl = item.ExternalUrls.Where(c => c.Key.Equals("spotify", StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault().Value;
}
catch (Exception)
{
//
}
return(await ViewModels.Helpers.OpenSpotifyAppAsync(item.Uri, webUrl));
}
}
catch (Exception)
{
string webUrl = null;
try
{
webUrl = item.ExternalUrls.Where(c => c.Key.Equals("spotify", StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault().Value;
}
catch (Exception)
{
if (webUrl == null && item.ExternalUrls.Count > 0)
{
webUrl = item.ExternalUrls.FirstOrDefault().Value;
}
}
return(await ViewModels.Helpers.OpenSpotifyAppAsync(item.Uri, webUrl));
}
}
public async Task Play(IPlayableItem item)
{
var uri = GetUri(item);
var req = new PlayerResumePlaybackRequest
{
Uris = new List <string> {
uri
}
};
await _spotify.Player.ResumePlayback(req);
}
private void OnPlayArtist()
{
var client = SpotifyService.Instance.GetSpotifyClient();
if (client != null)
{
PlayerResumePlaybackRequest request = new PlayerResumePlaybackRequest()
{
ContextUri = _artist.Uri,
};
client.Player.ResumePlayback(request);
}
}
public void PlaySong(List <string> uris)
{
try
{
Device = SpotifyClient.Player.GetAvailableDevices().Result;
PlayerResumePlaybackRequest request = new PlayerResumePlaybackRequest()
{
Uris = uris,
PositionMs = 0,
DeviceId = Device.Devices.First().Id
};
SpotifyClient.Player.ResumePlayback(request);
}
catch (APIException e)
{
throw e;
}
}
public void PlayAlbum(string uri)
{
try
{
Device = SpotifyClient.Player.GetAvailableDevices().Result;
PlayerResumePlaybackRequest request = new PlayerResumePlaybackRequest()
{
ContextUri = "spotify:album:" + uri,
PositionMs = 0,
DeviceId = Device.Devices.First().Id
};
SpotifyClient.Player.ResumePlayback(request);
}
catch (APIException e)
{
throw e;
}
}
private async Task <bool> PlaySpotifyMedia(List <string> uris, int index = 0, bool shuffle = false)
{
try
{
var spotify = await Authentication.GetSpotifyClientAsync();
if (spotify == null)
{
return(false);
}
if (uris.Count > 0)
{
PlayerResumePlaybackRequest request = new PlayerResumePlaybackRequest
{
Uris = uris,
OffsetParam = new PlayerResumePlaybackRequest.Offset {
Position = index
},
};
if (await spotify.Player.ResumePlayback(request))
{
if (shuffle)
{
await spotify.Player.SetShuffle(new PlayerShuffleRequest(true));
}
return(true);
}
else
{
return(await ViewModels.Helpers.OpenSpotifyAppAsync(uris[index], null));
}
}
else
{
ViewModels.Helpers.DisplayDialog("Cannot play items", "An error occured, could not play items. Please give it another shot and make sure your internet connection is working");
return(false);
}
}
catch (Exception)
{
return(await ViewModels.Helpers.OpenSpotifyAppAsync(uris[index], null));
}
}
public void PlaySong(string uri)
{
try
{
Device = SpotifyClient.Player.GetAvailableDevices().Result;
List <string> temp = new List <string>();
temp.Add("spotify:track:" + uri);
PlayerResumePlaybackRequest request = new PlayerResumePlaybackRequest()
{
Uris = temp,
PositionMs = 0,
DeviceId = Device.Devices.First().Id
};
SpotifyClient.Player.ResumePlayback(request);
}
catch (APIException e)
{
throw e;
}
}
private void UpdateUI()
{
if (_playlist != null)
{
if (_nameText != null)
{
_nameText.text = _playlist.Name;
}
if (_creatorText != null)
{
_creatorText.text = "By " + _playlist.Owner.DisplayName;
}
if (_icon != null)
{
SpotifyAPI.Web.Image image = S4UUtility.GetLowestResolutionImage(_playlist.Images);
if (image != null)
{
StartCoroutine(S4UUtility.LoadImageFromUrl(image.Url, (loadedSprite) =>
{
_icon.sprite = loadedSprite;
}));
}
}
if (_playPlaylistBtn != null)
{
_playPlaylistBtn.onClick.AddListener(() =>
{
SpotifyClient client = SpotifyService.Instance.GetSpotifyClient();
PlayerResumePlaybackRequest request = new PlayerResumePlaybackRequest
{
ContextUri = _playlist.Uri
};
client.Player.ResumePlayback(request);
});
}
}
}
/*
* Spotify requests need to be made at the start of the game
*/
public async void InitialSpotifyRequests(string defaultPlaylistId)
{
if (obtainedSpotifyClient)
{
try
{
await spotify.Player.SetVolume(new PlayerVolumeRequest(0));
var resumeRequest = new PlayerResumePlaybackRequest();
if (defaultPlaylistId.Length != 0)
{
resumeRequest.ContextUri = "spotify:playlist:" + defaultPlaylistId;
}
await spotify.Player.ResumePlayback(resumeRequest);
}
catch (Exception ex)
{
Logger.Log("Error In Initial Spotify Requests: " + ex.Message);
}
}
}
private async void OnPlayTrack()
{
if (_track != null)
{
SpotifyClient client = SpotifyService.Instance.GetSpotifyClient();
if (client != null)
{
// Play track in context of the playlist
PlayerResumePlaybackRequest request = new PlayerResumePlaybackRequest()
{
ContextUri = _contextUri,
OffsetParam = new PlayerResumePlaybackRequest.Offset()
{
Uri = _track.Uri
},
};
await client.Player.ResumePlayback(request);
LogTrackChange("Playing track");
}
}
}
public override Task <DialogTurnResult> BeginDialogAsync(DialogContext dc, object options = null, CancellationToken cancellationToken = default(CancellationToken))
{
// Get searched artist
var artistQuery = Artist.GetValue(dc.State);
var token = SpotifyToken.GetValue(dc.State);
// Create Spotify Client
var spotify = new SpotifyClient(token);
// Find artist by name and take first match
var searchResponse = spotify.Search.Item(new SearchRequest(SearchRequest.Types.Artist, artistQuery)).Result;
var firstArtistId = searchResponse.Artists.Items[0].Id;
// Get artist top tracks
var topTracksResponse = spotify.Artists.GetTopTracks(firstArtistId, new ArtistsTopTracksRequest("PL")).Result;
// Select random track from the top tracks
Random random = new Random();
int i = random.Next(topTracksResponse.Tracks.Count);
var trackToStart = topTracksResponse.Tracks[i];
// Play track
var playerResumePlayback = new PlayerResumePlaybackRequest();
playerResumePlayback.Uris = new List <string> {
trackToStart.Uri
};
var isStarted = spotify.Player.ResumePlayback(playerResumePlayback).Result;
// Return the track as the action result
var startedArtistName = trackToStart.Artists[0].Name;
var startedTrackName = trackToStart.Name;
var result = new StartedTrack(startedArtistName, startedTrackName);
dc.State.SetValue(this.ResultProperty.GetValue(dc.State), result);
return(dc.EndDialogAsync(result: result, cancellationToken: cancellationToken));
}
private void UpdateUI()
{
if (_name != null)
{
_name.text = _track.Name;
}
if (_artist != null)
{
_artist.text = S4UUtility.ArtistsToSeparatedString(", ", _track.Artists);
}
if (_duration != null)
{
_duration.text = S4UUtility.MsToTimeString(_track.DurationMs);
}
if (_playBtn != null)
{
_playBtn.onClick.AddListener(() =>
{
var client = SpotifyService.Instance.GetSpotifyClient();
if (client != null)
{
PlayerResumePlaybackRequest request = new PlayerResumePlaybackRequest()
{
//ContextUri = , // Play within context of just the individual track
Uris = new List <string>()
{
_track.Uri
},
};
client.Player.ResumePlayback(request);
Debug.Log($"Spotify App | Playing searched song '{S4UUtility.ArtistsToSeparatedString(", ", _track.Artists)} - {_track.Name}'");
}
});
}
}
// Due to API Enhancements, the Spotify API can now return FullEpisodes or FullTracks
// which have different parameters, requiring casting within the Play method
public void Play(String uri)
{
PlayerResumePlaybackRequest startSongRequest = new PlayerResumePlaybackRequest();
//Uses contextUri for playlists, artists, albums, otherwise regular URI
if (uri.Contains(":track:"))
{
startSongRequest.Uris = new List <string>()
{
uri
};
}
else
{
startSongRequest.ContextUri = uri;
}
try {
_spotifyClient.Player.ResumePlayback(startSongRequest).GetAwaiter().GetResult();
} catch (Exception e) {
//Expect playing to fail if no device is active
Console.WriteLine(e);
return;
}
}
/*
* Wrapper for Spotify Resume Playback and to a specific device
*/
public void ResumePlayback(string deviceID, string defaultPlaylistId)
{
var request = new PlayerResumePlaybackRequest();
request.DeviceId = deviceID;
var curr = GetCurrentlyPlaying();
if (curr == null)
{
if (defaultPlaylistId.Length != 0)
{
request.ContextUri = "spotify:playlist:" + defaultPlaylistId;
}
else
{
request.Uris = GetSavedTracks();
}
}
else
{
if (curr.Context != null)
{
request.ContextUri = curr.Context.Uri;
if (curr.Item != null)
{
request.OffsetParam = new PlayerResumePlaybackRequest.Offset();
if (curr.Item.Type == ItemType.Track)
{
request.OffsetParam.Uri = ((FullTrack)curr.Item).Uri;
}
else
{
request.OffsetParam.Uri = ((FullEpisode)curr.Item).Uri;
}
request.PositionMs = curr.ProgressMs;
}
}
else if (defaultPlaylistId.Length != 0)
{
request.ContextUri = "spotify:playlist:" + defaultPlaylistId;
}
else
{
request.Uris = GetSavedTracks();
if (curr.Item != null)
{
request.OffsetParam = new PlayerResumePlaybackRequest.Offset();
if (curr.Item.Type == ItemType.Track)
{
request.Uris[0] = ((FullTrack)curr.Item).Uri;
}
else
{
request.Uris[0] = ((FullEpisode)curr.Item).Uri;
}
request.OffsetParam = new PlayerResumePlaybackRequest.Offset();
request.OffsetParam.Uri = request.Uris[0];
request.PositionMs = curr.ProgressMs;
}
}
}
var task = spotify.Player.ResumePlayback(request);
task.Wait();
}
Task <bool> IPlayerClient.ResumePlayback(PlayerResumePlaybackRequest request) => throw new NotImplementedException();
