implement configuration to adjust reconnect delay and autoreconnect

Author: LabyStudio

README.md

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

build.gradle

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

src/main/java/de/labystudio/spotifyapi/SpotifyAPI.java

@@ -1,5 +1,6 @@
 package de.labystudio.spotifyapi;
 
+import de.labystudio.spotifyapi.config.SpotifyConfiguration;
 import de.labystudio.spotifyapi.model.MediaKey;
 import de.labystudio.spotifyapi.model.Track;
 
@@ -17,14 +18,39 @@ public interface SpotifyAPI {
     /**
      * Initialize the SpotifyAPI and connect to the Spotify process.
      * Initializing the api will block the current thread until the connection is established.
+     * It will use a default configuration.
      *
      * @return the initialized SpotifyAPI
      */
-    SpotifyAPI initialize();
+    default SpotifyAPI initialize() {
+        return this.initialize(new SpotifyConfiguration.Builder().build());
+    }
+
+    /**
+     * Initialize the SpotifyAPI and connect to the Spotify process.
+     * Initializing the api will block the current thread until the connection is established.
+     *
+     * @param configuration the configuration for the api
+     * @return the initialized SpotifyAPI
+     */
+    SpotifyAPI initialize(SpotifyConfiguration configuration);
+
 
     /**
      * Initialize the SpotifyAPI and connect to the Spotify process asynchronously.
      *
+     * @param configuration the configuration for the api
+     * @return a future that will contain the initialized SpotifyAPI
+     */
+    default CompletableFuture<SpotifyAPI> initializeAsync(SpotifyConfiguration configuration) {
+        return CompletableFuture.supplyAsync(() -> this.initialize(configuration));
+    }
+
+
+    /**
+     * Initialize the SpotifyAPI and connect to the Spotify process asynchronously.
+     * It will use a default configuration.
+     *
      * @return a future that will contain the initialized SpotifyAPI
      */
     default CompletableFuture<SpotifyAPI> initializeAsync() {
@@ -114,6 +140,13 @@ default boolean hasTrack() {
      */
     void unregisterListener(SpotifyListener listener);
 
+    /**
+     * Returns the current set configuration of the api.
+     *
+     * @return the current set configuration of the api
+     */
+    SpotifyConfiguration getConfiguration();
+
     /**
      * Disconnect from the Spotify application and stop all background tasks.
      */

src/main/java/de/labystudio/spotifyapi/SpotifyAPIFactory.java

@@ -1,12 +1,11 @@
 package de.labystudio.spotifyapi;
 
-import de.labystudio.spotifyapi.platform.windows.WinSpotifyAPI;
+import de.labystudio.spotifyapi.config.SpotifyConfiguration;
 import de.labystudio.spotifyapi.platform.osx.OSXSpotifyApi;
+import de.labystudio.spotifyapi.platform.windows.WinSpotifyAPI;
 
 import java.util.Locale;
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
 
 /**
  * Factory class for creating SpotifyAPI instances.
@@ -38,13 +37,25 @@ public static SpotifyAPI create() {
     /**
      * Create an initialized SpotifyAPI instance.
      * Initializing will block the current thread until the SpotifyAPI instance is ready.
+     * It will use a default configuration.
      *
      * @return A new SpotifyAPI instance.
      */
     public static SpotifyAPI createInitialized() {
         return create().initialize();
     }
 
+    /**
+     * Create an initialized SpotifyAPI instance.
+     * Initializing will block the current thread until the SpotifyAPI instance is ready.
+     *
+     * @param configuration The configuration for the SpotifyAPI instance.
+     * @return A new SpotifyAPI instance.
+     */
+    public static SpotifyAPI createInitialized(SpotifyConfiguration configuration) {
+        return create().initialize(configuration);
+    }
+
     /**
      * Creates a new SpotifyAPI instance for the current platform asynchronously.
      * Currently, only Windows and OSX are supported.
@@ -55,4 +66,15 @@ public static CompletableFuture<SpotifyAPI> createInitializedAsync() {
         return CompletableFuture.supplyAsync(SpotifyAPIFactory::createInitialized);
     }
 
+    /**
+     * Creates a new SpotifyAPI instance for the current platform asynchronously.
+     * Currently, only Windows and OSX are supported.
+     * It will use a default configuration.
+     *
+     * @param configuration The configuration for the SpotifyAPI instance.
+     * @return A future that will contain the SpotifyAPI instance.
+     */
+    public static CompletableFuture<SpotifyAPI> createInitializedAsync(SpotifyConfiguration configuration) {
+        return CompletableFuture.supplyAsync(() -> createInitialized(configuration));
+    }
 }

src/main/java/de/labystudio/spotifyapi/config/SpotifyConfiguration.java

@@ -0,0 +1,74 @@
+package de.labystudio.spotifyapi.config;
+
+/**
+ * A configuration for the spotify api
+ *
+ * @author LabyStudio
+ */
+public class SpotifyConfiguration {
+
+    private long exceptionReconnectDelay;
+    private boolean autoReconnect;
+
+    private SpotifyConfiguration(
+            long exceptionReconnectDelay,
+            boolean autoReconnect
+    ) {
+        this.exceptionReconnectDelay = exceptionReconnectDelay;
+        this.autoReconnect = autoReconnect;
+    }
+
+    public void setExceptionReconnectDelay(long exceptionReconnectDelay) {
+        this.exceptionReconnectDelay = exceptionReconnectDelay;
+    }
+
+    public void setAutoReconnect(boolean autoReconnect) {
+        this.autoReconnect = autoReconnect;
+    }
+
+    public long getExceptionReconnectDelay() {
+        return this.exceptionReconnectDelay;
+    }
+
+    public boolean isAutoReconnect() {
+        return this.autoReconnect;
+    }
+
+    /**
+     * Builder to create a new spotify configuration
+     */
+    public static class Builder {
+
+        private long exceptionReconnectDelay = 1000 * 10L;
+        private boolean autoReconnect = true;
+
+        /**
+         * Set the delay between reconnects when an exception occurs
+         *
+         * @param exceptionReconnectDelay The delay in milliseconds
+         * @return The builder instance
+         */
+        public Builder exceptionReconnectDelay(long exceptionReconnectDelay) {
+            this.exceptionReconnectDelay = exceptionReconnectDelay;
+            return this;
+        }
+
+        /**
+         * Set if the api should automatically reconnect when an exception occurs
+         *
+         * @param autoReconnect The auto reconnect state
+         * @return The builder instance
+         */
+        public Builder autoReconnect(boolean autoReconnect) {
+            this.autoReconnect = autoReconnect;
+            return this;
+        }
+
+        public SpotifyConfiguration build() {
+            return new SpotifyConfiguration(
+                    this.exceptionReconnectDelay,
+                    this.autoReconnect
+            );
+        }
+    }
+}

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

@@ -68,7 +68,7 @@ private AccessTokenResponse generateAccessToken() throws IOException {
 
         // Read response
         JsonReader reader = new JsonReader(new InputStreamReader(connection.getInputStream()));
-        return new Gson().fromJson(reader, AccessTokenResponse.class);
+        return GSON.fromJson(reader, AccessTokenResponse.class);
     }
 
     /**

src/main/java/de/labystudio/spotifyapi/platform/AbstractTickSpotifyAPI.java

@@ -2,11 +2,13 @@
 
 import de.labystudio.spotifyapi.SpotifyAPI;
 import de.labystudio.spotifyapi.SpotifyListener;
+import de.labystudio.spotifyapi.config.SpotifyConfiguration;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
 
 /**
  * Abstract tick class for SpotifyAPI implementations.
@@ -20,7 +22,10 @@ public abstract class AbstractTickSpotifyAPI implements SpotifyAPI {
      */
     protected final List<SpotifyListener> listeners = new ArrayList<>();
 
+    private SpotifyConfiguration configuration;
+
     private ScheduledFuture<?> task;
+    private long timeLastException = -1;
 
     /**
      * Initialize the SpotifyAPI abstract tick implementation.
@@ -29,20 +34,48 @@ public abstract class AbstractTickSpotifyAPI implements SpotifyAPI {
      * @return the initialized SpotifyAPI
      * @throws IllegalStateException if the API is already initialized
      */
-    public SpotifyAPI initialize() {
-        if (this.isInitialized()) {
-            throw new IllegalStateException("The SpotifyAPI is already initialized");
+    @Override
+    public SpotifyAPI initialize(SpotifyConfiguration configuration) {
+        synchronized (this) {
+            this.configuration = configuration;
+
+            if (this.isInitialized()) {
+                throw new IllegalStateException("The SpotifyAPI is already initialized");
+            }
+
+            // Start task to update every second
+            this.task = Executors.newScheduledThreadPool(1)
+                    .scheduleWithFixedDelay(
+                            this::onInternalTick,
+                            0,
+                            1,
+                            TimeUnit.SECONDS
+                    );
         }
+        return this;
+    }
 
-        // Initial tick
-        this.onTick();
+    private void onInternalTick() {
+        try {
+            // Check if we passed the exception timeout
+            long timeSinceLastException = System.currentTimeMillis() - this.timeLastException;
+            if (timeSinceLastException < this.configuration.getExceptionReconnectDelay()) {
+                return;
+            }
 
-        // Start task to update every second
-        this.task = Executors.newScheduledThreadPool(1).scheduleWithFixedDelay(
-                this::onTick, 1, 1, java.util.concurrent.TimeUnit.SECONDS
-        );
+            this.onTick();
+        } catch (Exception e) {
+            this.timeLastException = System.currentTimeMillis();
+            this.stop();
 
-        return this;
+            // Fire on disconnect
+            this.listeners.forEach(listener -> listener.onDisconnect(e));
+
+            // Restart the process
+            if (this.configuration.isAutoReconnect()) {
+                this.initialize(this.configuration);
+            }
+        }
     }
 
     protected abstract void onTick();
@@ -62,11 +95,18 @@ public boolean isInitialized() {
         return this.task != null;
     }
 
+    @Override
+    public SpotifyConfiguration getConfiguration() {
+        return this.configuration;
+    }
+
     @Override
     public void stop() {
-        if (this.task != null) {
-            this.task.cancel(true);
-            this.task = null;
+        synchronized (this) {
+            if (this.task != null) {
+                this.task.cancel(true);
+                this.task = null;
+            }
         }
     }
 }