improve open spotify api, version 1.1.8

Author: LabyStudio

README.md

@@ -23,7 +23,7 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.github.LabyStudio:java-spotify-api:1.1.7:all'
+    implementation 'com.github.LabyStudio:java-spotify-api:1.1.8:all'
 }
 ```
 

build.gradle

@@ -4,7 +4,7 @@ plugins {
 }
 
 group 'de.labystudio'
-version '1.1.7'
+version '1.1.8'
 
 compileJava {
     sourceCompatibility = '1.8'

src/main/java/de/labystudio/spotifyapi/open/Cache.java

@@ -0,0 +1,84 @@
+package de.labystudio.spotifyapi.open;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * A cache for the open spotify api.
+ *
+ * @param <T> The type of the cached object
+ * @author LabyStudio
+ */
+public class Cache<T> {
+
+    private final Map<String, T> cache = new ConcurrentHashMap<>();
+    private final List<String> cacheQueue = new ArrayList<>();
+    private int cacheSize;
+
+    /**
+     * Create a new cache with a specific size
+     *
+     * @param cacheSize The size of the cache. The cache will remove the oldest entry if the size is reached.
+     */
+    public Cache(int cacheSize) {
+        this.cacheSize = cacheSize;
+    }
+
+    /**
+     * Set the maximal amount of entries to cache.
+     *
+     * @param cacheSize The maximal amount of entries to cache
+     */
+    public void setCacheSize(int cacheSize) {
+        this.cacheSize = cacheSize;
+    }
+
+    /**
+     * Store an entry in the cache
+     * If the max cache size is reached, the oldest entry will be removed.
+     *
+     * @param key The key of the entry
+     */
+    public void push(String key, T value) {
+        // Remove entry from cache if cache is full
+        if (this.cacheQueue.size() > this.cacheSize) {
+            String urlToRemove = this.cacheQueue.remove(0);
+            this.cache.remove(urlToRemove);
+        }
+
+        // Add new entry to cache
+        this.cache.put(key, value);
+        this.cacheQueue.add(key);
+    }
+
+    /**
+     * Check if the cache contains the given key.
+     *
+     * @param key The key to check
+     * @return True if the cache contains the key
+     */
+    public boolean has(String key) {
+        return this.cache.containsKey(key);
+    }
+
+    /**
+     * Get the cached entry by the given key.
+     *
+     * @param key The key of the entry
+     * @return The cached entry or null if it doesn't exist
+     */
+    public T get(String key) {
+        return this.cache.get(key);
+    }
+
+    /**
+     * Clear the cache.
+     */
+    public void clear() {
+        this.cache.clear();
+        this.cacheQueue.clear();
+    }
+
+}

src/main/java/de/labystudio/spotifyapi/open/OpenSpotifyAPI.java

@@ -12,10 +12,6 @@
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.net.URL;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 import java.util.function.Consumer;
@@ -35,10 +31,8 @@ public class OpenSpotifyAPI {
 
     private final Executor executor = Executors.newSingleThreadExecutor();
 
-    private final Map<Track, String> urlCache = new ConcurrentHashMap<>();
-    private final Map<String, BufferedImage> imageCache = new ConcurrentHashMap<>();
-    private final List<String> cacheQueue = new ArrayList<>();
-    private int cacheSize = 10;
+    private final Cache<BufferedImage> imageCache = new Cache<>(10);
+    private final Cache<OpenTrack> openTrackCache = new Cache<>(100);
 
     private AccessTokenResponse accessTokenResponse;
 
@@ -115,6 +109,26 @@ public void requestImageUrlAsync(Track track, Consumer<String> callback) {
         });
     }
 
+    /**
+     * Request the track information of the given track asynchronously.
+     * If the open track is already in the cache, it will be returned.
+     *
+     * @param track The track to lookup
+     * @param callback Response with the open track. It won't be called on an error.
+     */
+    public void requestOpenTrackAsync(Track track, Consumer<OpenTrack> callback) {
+        this.executor.execute(() -> {
+            try {
+                OpenTrack openTrack = this.requestOpenTrack(track);
+                if (openTrack != null) {
+                    callback.accept(openTrack);
+                }
+            } catch (Exception error) {
+                error.printStackTrace();
+            }
+        });
+    }
+
     /**
      * Request the cover image of the given track synchronously.
      * If the track is already in the cache, it will be returned.
@@ -124,33 +138,26 @@ public void requestImageUrlAsync(Track track, Consumer<String> callback) {
      * @throws IOException if the request failed
      */
     public BufferedImage requestImage(Track track) throws IOException {
+        // Try to get image from cache by track id
+        BufferedImage cachedImage = this.imageCache.get(track.getId());
+        if (cachedImage != null) {
+            return cachedImage;
+        }
+
+        // Request the image url
         String url = this.requestImageUrl(track);
         if (url == null) {
             return null;
         }
 
-        // Try to get image from cache by url
-        BufferedImage cachedImage = this.imageCache.get(url);
-        if (cachedImage != null) {
-            return cachedImage;
-        }
-
         // Download the image
         BufferedImage image = ImageIO.read(new URL(url));
         if (image == null) {
             throw new IOException("Could not load image: " + url);
         }
 
-        // Remove image from cache if cache is full
-        if (this.cacheQueue.size() > this.cacheSize) {
-            String urlToRemove = this.cacheQueue.remove(0);
-            this.imageCache.remove(urlToRemove);
-        }
-
-        // Add new image to cache
-        this.imageCache.put(url, image);
-        this.cacheQueue.add(url);
-
+        // Cache the image and return it
+        this.imageCache.push(track.getId(), image);
         return image;
     }
 
@@ -162,28 +169,51 @@ public BufferedImage requestImage(Track track) throws IOException {
      * @return The url of the track or null if it failed
      * @throws IOException if the request failed
      */
-    public String requestImageUrl(Track track) throws IOException {
-        return this.requestImageUrl(track, true);
+    private String requestImageUrl(Track track) throws IOException {
+        // Request track information
+        OpenTrack openTrack = this.requestOpenTrack(track);
+        if (openTrack == null) {
+            return null;
+        }
+
+        // Get largest image url
+        return openTrack.album.images.get(0).url;
     }
 
     /**
-     * Request the cover image url of the given track.
-     * If the track is already in the cache, it will be returned.
+     * Request the track information of the given track.
+     * If the open track is already in the cache, it will be returned.
      *
-     * @param track                     The track to lookup
-     * @param canGenerateNewAccessToken It will try again once if it fails
-     * @return The url of the track or null if it failed
+     * @param track The track to lookup
      * @throws IOException if the request failed
      */
-    private String requestImageUrl(Track track, boolean canGenerateNewAccessToken) throws IOException {
-        String cachedUrl = this.urlCache.get(track);
-        if (cachedUrl != null) {
-            return cachedUrl;
+    public OpenTrack requestOpenTrack(Track track) throws IOException {
+        OpenTrack cachedOpenTrack = this.openTrackCache.get(track.getId());
+        if (cachedOpenTrack != null) {
+            return cachedOpenTrack;
         }
 
         // Create REST API url
         String url = String.format(URL_API_TRACKS, track.getId());
+        OpenTrack openTrack = this.request(url, OpenTrack.class, true);
+
+        // Cache the open track and return it
+        this.openTrackCache.push(track.getId(), openTrack);
+        return openTrack;
+    }
 
+    /**
+     * Request the open spotify api with the given url
+     * It will try again once if it fails
+     *
+     * @param url                       The url to request
+     * @param clazz                     The class to parse the response to
+     * @param canGenerateNewAccessToken It will try again once if it fails
+     * @param <T>                       The type of the response
+     * @return The parsed response
+     * @throws IOException if the request failed
+     */
+    public <T> T request(String url, Class<?> clazz, boolean canGenerateNewAccessToken) throws IOException {
         // Connect
         HttpsURLConnection connection = (HttpsURLConnection) new URL(url).openConnection();
         connection.addRequestProperty("User-Agent", USER_AGENT);
@@ -203,7 +233,7 @@ private String requestImageUrl(Track track, boolean canGenerateNewAccessToken) t
                 this.accessTokenResponse = this.generateAccessToken();
 
                 // Try again
-                return this.requestImageUrl(track, false);
+                return this.request(url, clazz, false);
             } else {
                 // Request failed twice
                 return null;
@@ -212,35 +242,14 @@ private String requestImageUrl(Track track, boolean canGenerateNewAccessToken) t
 
         // Read response
         JsonReader reader = new JsonReader(new InputStreamReader(connection.getInputStream()));
-        OpenTrack openTrack = new Gson().fromJson(reader, OpenTrack.class);
-
-        // Get largest image url
-        String imageUrl = openTrack.album.images.get(0).url;
-
-        // Cache url and return it
-        if (imageUrl != null) {
-            this.urlCache.put(track, imageUrl);
-            return imageUrl;
-        }
-
-        return null;
+        return new Gson().fromJson(reader, clazz);
     }
 
-    /**
-     * Set the maximal amount of images to cache.
-     * Default is 10.
-     *
-     * @param cacheSize The maximal amount of images to cache
-     */
-    public void setCacheSize(int cacheSize) {
-        this.cacheSize = cacheSize;
+    public Cache<BufferedImage> getImageCache() {
+        return this.imageCache;
     }
 
-    /**
-     * Clear the cache of images.
-     */
-    public void clearCache() {
-        this.imageCache.clear();
-        this.cacheQueue.clear();
+    public Cache<OpenTrack> getOpenTrackCache() {
+        return this.openTrackCache;
     }
 }