/**
* Search and retrieve list of artists
*
* @param params
* @return
*/
@Override
protected ArtistsPager doInBackground(String... params) {
SpotifyApi api = new SpotifyApi();
;
SpotifyService spotify = null;
try {
if (params.length == 0) {
return null;
}
spotify = api.getService();
Log.v(LOG_TAG, "Artist to search " + params[0]);
return spotify.searchArtists(params[0]);
} catch (RetrofitError ex) {
Log.e(LOG_TAG, "Error at retrieving Artist data " + ex.getMessage());
Toast.makeText(getActivity().getApplicationContext(), ex.getMessage(), Toast.LENGTH_SHORT)
.show();
}
return null;
}
@Override
protected List<Artist> doInBackground(String... params) {
List<Artist> pResults = new ArrayList<>();
try {
SpotifyApi api = new SpotifyApi();
SpotifyService service = api.getService();
String artistName = params[0];
ArtistsPager results = service.searchArtists(artistName);
for (kaaes.spotify.webapi.android.models.Artist artist : results.artists.items) {
ArrayList<Image> pImages = new ArrayList<>();
if (artist.images != null && artist.images.size() > 0) {
for (kaaes.spotify.webapi.android.models.Image image : artist.images) {
Image pImage = new Image(image.height, image.width, image.url);
pImages.add(pImage);
}
}
Artist pArtist = new Artist(artist.id, artist.name, pImages);
pResults.add(pArtist);
}
} catch (Exception e) {
Artist artist = new Artist("", "ERROR: " + e.getMessage(), null);
pResults.add(artist);
}
return pResults;
}
@Override
protected List<Artist> doInBackground(String... params) {
SpotifyApi spotifyApi = new SpotifyApi();
SpotifyService spotifyService = spotifyApi.getService();
ArtistsPager artistsPager = spotifyService.searchArtists(params[0]);
return artistsPager.artists.items;
}
@Override
protected ArtistsPager doInBackground(String... params) {
try {
SpotifyApi api = new SpotifyApi();
SpotifyService spotify = api.getService();
return spotify.searchArtists(params[0]);
} catch (Exception e) {
return null;
}
}
@Override
protected ArtistsPager doInBackground(String... params) {
SpotifyApi api = new SpotifyApi();
SpotifyService spotify = api.getService();
try {
return spotify.searchArtists(params[0]);
} catch (Exception e) {
Log.e(LOG_TAG, "Error -> " + e.getMessage(), e);
return null;
}
}
private ArtistsPager getArtistDataFromSpotifyWrapper(
SpotifyService spotify, String artistQuery) {
ArtistsPager results = new ArtistsPager();
try {
if (artistQuery != null) results = spotify.searchArtists(artistQuery);
for (Artist artist : results.artists.items) {
String artistImageUrl;
if (!artist.images.isEmpty()) {
Image artistImage = (artist.images.get(artist.images.size() - 1));
artistImageUrl = artistImage.url;
} else {
artistImageUrl = "";
}
long artistRowId =
addArtist(artist.name, artist.id, artist.uri, artist.popularity, artistImageUrl);
if (artistRowId == -1)
throw new MalformedURLException(
"THERE WAS AN ERROR INSERTING " + artist.name + " - " + artist.id);
}
} catch (RetrofitError re) {
Log.d(LOG_TAG, "Retrofit error has occurred: " + re.getMessage());
} catch (Exception ex) {
Log.d(LOG_TAG, "An error has occurred: " + ex.getMessage());
}
return results;
}
@Override
protected List<SearchResult> doInBackground(String... params) {
if (params.length == 0) {
Log.i(LOG_TAG, "No parameter received for task");
return null;
}
SpotifyApi api = new SpotifyApi();
SpotifyService spotify = api.getService();
try {
ArtistsPager artistsPager = spotify.searchArtists(params[0]);
List<Artist> artists = artistsPager.artists.items;
if (artists.size() > 0) {
List<SearchResult> results = new ArrayList<SearchResult>();
for (Artist artist : artistsPager.artists.items) {
Log.v(LOG_TAG, "Found artist: " + artist.name);
String imgUrl =
SpotifyWrapperUtil.getImageUrlForSearchResultList(
artist.images,
getResources()
.getDimensionPixelSize(R.dimen.search_result_thumbnail_max_height),
getResources()
.getDimensionPixelSize(R.dimen.search_result_thumbnail_max_width));
SearchResult res = new SearchResult(artist.id, artist.name, imgUrl);
results.add(res);
}
return results;
}
} catch (RetrofitError error) {
Log.e(LOG_TAG, "Error while searching artist with param: [" + params[0] + "]");
SpotifyError spotifyError = SpotifyError.fromRetrofitError(error);
if (spotifyError.hasErrorDetails()) {
Log.e(LOG_TAG, spotifyError.getErrorDetails().message);
}
}
return null;
}
@Override
protected String doInBackground(String... params) {
try {
SpotifyApi spotifyApi = new SpotifyApi();
SpotifyService spotify = spotifyApi.getService();
// Look for Track
Track track = spotify.getTrack(params[0]);
StringBuilder result = new StringBuilder();
result.append(track.album.name + ",");
result.append(track.name + ",");
result.append(track.album.images.get(track.album.images.size() - 1).url);
Log.v(LOG_TAG + " doInBackground: ", result.toString());
return result.toString();
} catch (Exception e) {
this.exception = e;
return null;
}
}
// get song track uri...
public void getSongURI(String uri) {
service.searchTracks(
uri,
new Callback<TracksPager>() {
@Override
public void success(TracksPager tracksPager, Response response) {
song_path = tracksPager.tracks.items.get(0).uri;
Log.e(LOG_TAG, "song uri: " + song_path);
Intent intent = new Intent(Top10Songs.this, Player.class);
intent.putExtra("track", song_path);
startActivity(intent);
}
@Override
public void failure(RetrofitError error) {}
});
}
// get artists uri
public void getArtistID(String uri) {
service.searchArtists(
uri,
new Callback<ArtistsPager>() {
@Override
public void success(ArtistsPager artistsPager, Response response) {
String artist_uri = artistsPager.artists.items.get(0).id;
Log.e(LOG_TAG, "artist uri: " + artist_uri);
getTopTenParams(artist_uri);
}
@Override
public void failure(RetrofitError error) {
Toast.makeText(getApplicationContext(), "Failed...", Toast.LENGTH_LONG).show();
}
});
}
public void getTopTenParams(String uri) {
final List<String> songs_list = new ArrayList<>();
final List<String> album_list = new ArrayList<>();
final Map<String, String> artist = new HashMap<>();
String countryID = "GB";
String artistUri = uri;
Map<String, Object> options = new HashMap<>();
options.put(SpotifyService.COUNTRY, countryID);
service.getArtistTopTrack(
artistUri,
options,
new Callback<Tracks>() {
@Override
public void success(Tracks tracks, Response response) {
for (int i = 0; i < tracks.tracks.size(); i++) {
String songNames = tracks.tracks.get(i).name;
String albumName = tracks.tracks.get(i).album.name;
artist.put(tracks.tracks.get(i).name, tracks.tracks.get(i).album.name);
songs_list.add(songNames);
album_list.add(albumName);
}
String[] songs = songs_list.toArray(new String[songs_list.size()]);
String[] albums = album_list.toArray(new String[album_list.size()]);
FlowAdapter adapter = new FlowAdapter(Top10Songs.this, songs, albums);
listView.setAdapter(adapter);
}
@Override
public void failure(RetrofitError error) {
Toast.makeText(getApplicationContext(), "An Error has occured", Toast.LENGTH_LONG)
.show();
}
});
}
protected FetchResults doInBackground(String... params) {
Tracks tracks = null;
String artistID = params[0];
int rowsInserted = 0;
FetchResults results = new FetchResults();
results.numRecords = 0;
results.message = "Tracks not found";
try {
SpotifyApi api = new SpotifyApi();
SpotifyService spotifyService = api.getService();
// Get the market country code
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(getActivity());
String market_code =
prefs.getString(
getString(R.string.pref_country_code_key),
getString(R.string.pref_country_code_default));
Map<String, Object> options = new HashMap<>();
options.put(SpotifyService.COUNTRY, market_code);
// This only returns 10 tracks for artists.
tracks = spotifyService.getArtistTopTrack(artistID, options);
} catch (RetrofitError error) {
SpotifyError spotifyError = SpotifyError.fromRetrofitError(error);
Log.d(LOG_TAG, spotifyError.toString());
results.message = spotifyError.getErrorDetails().message;
}
if (tracks != null) {
// API returns at most 10 tracks
Vector<ContentValues> cVVector = new Vector<>(10);
for (Track track : tracks.tracks) {
String imageLargeURL = null;
String imageSmallURL = null;
if (track.album.images.size() > 0) {
Image imageLarge = track.album.images.get(0);
Image imageSmall = imageLarge;
for (int index = 1; index < track.album.images.size(); index++) {
Image image = track.album.images.get(index);
// Check for small
if (Math.abs(imageSmall.height - 200) > (Math.abs(image.height - 200))) {
imageSmall = image;
}
// Check for large
if (Math.abs(imageLarge.height - 640) > (Math.abs(image.height - 640))) {
imageLarge = image;
}
}
imageLargeURL = imageLarge.url;
imageSmallURL = imageSmall.url;
}
// Insert trackinfo into the database
// Save the information to put into the database
ContentValues tracksValues = new ContentValues();
tracksValues.put(SpotifyContract.TracksEntry.COLUMN_TRACK_NAME, track.name);
tracksValues.put(SpotifyContract.TracksEntry.COLUMN_ALBUM_NAME, track.album.name);
tracksValues.put(SpotifyContract.TracksEntry.COLUMN_ARTIST_SPOTIFY_ID, artistID);
tracksValues.put(SpotifyContract.TracksEntry.COLUMN_THUMBNAL_SMALL_URL, imageSmallURL);
tracksValues.put(SpotifyContract.TracksEntry.COLUMN_THUMBNAL_LARGE_URL, imageLargeURL);
tracksValues.put(SpotifyContract.TracksEntry.COLUMN_PREVIEW_URL, track.preview_url);
tracksValues.put(SpotifyContract.TracksEntry.COLUMN_DURATION, track.duration_ms);
tracksValues.put(SpotifyContract.TracksEntry.COLUMN_ARTIST_NAME, mArtistName);
cVVector.add(tracksValues);
}
// table should always be empty as it is deleted before the fetch task is called
// in the onCreateView method
// add to database
if (cVVector.size() > 0) {
// call bulkInsert to add the new tracks to the database here
rowsInserted =
mContext
.getContentResolver()
.bulkInsert(
SpotifyContract.TracksEntry.CONTENT_URI,
cVVector.toArray(new ContentValues[cVVector.size()]));
if (rowsInserted != cVVector.size()) {
Log.e(
LOG_TAG,
"Inserted "
+ String.valueOf(rowsInserted)
+ " and expected "
+ String.valueOf(cVVector.size()));
}
}
}
if (rowsInserted > 0) {
results.message = null;
results.numRecords = rowsInserted;
}
return results;
}