implement macOS support, version 1.1.0

Author: LabyStudio

README.md

@@ -14,6 +14,7 @@ because the API reads the information directly from the application itself.
 
 #### Supported operating systems:
 - Windows
+- macOS
 
 ## Gradle Setup
 ```groovy
@@ -22,7 +23,7 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.github.LabyStudio:java-spotify-api:1.0.9:all'
+    implementation 'com.github.LabyStudio:java-spotify-api:1.1.0:all'
 }
 ```
 

build.gradle

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

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

@@ -0,0 +1,72 @@
+package de.labystudio.spotifyapi.platform;
+
+import de.labystudio.spotifyapi.SpotifyAPI;
+import de.labystudio.spotifyapi.SpotifyListener;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledFuture;
+
+/**
+ * Abstract tick class for SpotifyAPI implementations.
+ *
+ * @author LabyStudio
+ */
+public abstract class AbstractTickSpotifyAPI implements SpotifyAPI {
+
+    /**
+     * The list of all Spotify listeners.
+     */
+    protected final List<SpotifyListener> listeners = new ArrayList<>();
+
+    private ScheduledFuture<?> task;
+
+    /**
+     * Initialize the SpotifyAPI abstract tick implementation.
+     * It will create a task that will update the current track and position every second.
+     *
+     * @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");
+        }
+
+        // Initial tick
+        this.onTick();
+
+        // Start task to update every second
+        this.task = Executors.newScheduledThreadPool(1).scheduleWithFixedDelay(
+                this::onTick, 1, 1, java.util.concurrent.TimeUnit.SECONDS
+        );
+
+        return this;
+    }
+
+    protected abstract void onTick();
+
+    @Override
+    public void registerListener(SpotifyListener listener) {
+        this.listeners.add(listener);
+    }
+
+    @Override
+    public void unregisterListener(SpotifyListener listener) {
+        this.listeners.remove(listener);
+    }
+
+    @Override
+    public boolean isInitialized() {
+        return this.task != null;
+    }
+
+    @Override
+    public void stop() {
+        if (this.task != null) {
+            this.task.cancel(true);
+            this.task = null;
+        }
+    }
+}

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

@@ -1,64 +1,151 @@
 package de.labystudio.spotifyapi.platform.osx;
 
-import de.labystudio.spotifyapi.SpotifyAPI;
+import de.labystudio.spotifyapi.SpotifyListener;
 import de.labystudio.spotifyapi.model.MediaKey;
 import de.labystudio.spotifyapi.model.Track;
-import de.labystudio.spotifyapi.platform.AbstractSpotifyAPI;
+import de.labystudio.spotifyapi.platform.AbstractTickSpotifyAPI;
+import de.labystudio.spotifyapi.platform.osx.api.spotify.SpotifyAppleScript;
+
+import java.util.Objects;
 
 /**
  * OSX implementation of the SpotifyAPI.
+ * It uses the AppleScript API to access the Spotify application.
  *
  * @author LabyStudio
  */
-public class OSXSpotifyApi extends AbstractSpotifyAPI {
+public class OSXSpotifyApi extends AbstractTickSpotifyAPI {
 
-    public OSXSpotifyApi() {
-        super();
-    }
+    private final SpotifyAppleScript appleScript = new SpotifyAppleScript();
+
+    private boolean connected = false;
+
+    private Track currentTrack;
+    private int currentPosition = -1;
+    private boolean isPlaying;
+
+    private long lastTimePositionUpdated;
 
     @Override
-    public SpotifyAPI initialize() {
-        return this;
+    protected void onTick() {
+        try {
+            String trackId = this.appleScript.getTrackId();
+
+            // Handle on connect
+            if (!this.connected && !trackId.isEmpty()) {
+                this.connected = true;
+                this.listeners.forEach(SpotifyListener::onConnect);
+            }
+
+            // Handle track changes
+            if (!Objects.equals(trackId, this.currentTrack == null ? null : this.currentTrack.getId())) {
+                String trackName = this.appleScript.getTrackName();
+                String trackArtist = this.appleScript.getTrackArtist();
+                int trackLength = this.appleScript.getTrackLength();
+
+                boolean isFirstTrack = !this.hasTrack();
+
+                Track track = new Track(trackId, trackName, trackArtist, trackLength);
+                this.currentTrack = track;
+
+                // Fire on track changed
+                this.listeners.forEach(listener -> listener.onTrackChanged(track));
+
+                // Reset position on song change
+                if (!isFirstTrack) {
+                    this.updatePosition(0);
+                }
+            }
+
+            // Handle is playing changes
+            boolean isPlaying = this.appleScript.getPlayerState();
+            if (isPlaying != this.isPlaying) {
+                this.isPlaying = isPlaying;
+
+                // Fire on play back changed
+                this.listeners.forEach(listener -> listener.onPlayBackChanged(isPlaying));
+            }
+
+            // Handle position changes
+            int position = this.appleScript.getPlayerPosition();
+            if (!this.hasPosition() || Math.abs(position - this.getPosition()) > 1000) {
+                this.updatePosition(position);
+            }
+
+            // Fire keep alive
+            this.listeners.forEach(SpotifyListener::onSync);
+        } catch (Exception e) {
+            this.listeners.forEach(listener -> listener.onDisconnect(e));
+            this.connected = false;
+        }
     }
 
-    @Override
-    public boolean isInitialized() {
-        return false;
+    private void updatePosition(int position) {
+        if (position == this.currentPosition) {
+            return;
+        }
+
+        // Update position known state
+        this.currentPosition = position;
+        this.lastTimePositionUpdated = System.currentTimeMillis();
+
+        // Fire on position changed
+        this.listeners.forEach(listener -> listener.onPositionChanged(position));
     }
 
     @Override
-    public Track getTrack() {
-        return null; // TODO Implement OSX SpotifyAPI
+    public void pressMediaKey(MediaKey mediaKey) {
+        try {
+            switch (mediaKey) {
+                case PLAY_PAUSE:
+                    this.appleScript.playPause();
+                    break;
+                case NEXT:
+                    this.appleScript.nextTrack();
+                    break;
+                case PREV:
+                    this.appleScript.previousTrack();
+                    break;
+            }
+        } catch (Exception e) {
+            this.listeners.forEach(listener -> listener.onDisconnect(e));
+            this.connected = false;
+        }
     }
 
     @Override
     public int getPosition() {
-        return 0; // TODO Implement OSX SpotifyAPI
-    }
+        if (!this.hasPosition()) {
+            throw new IllegalStateException("Position is not known yet");
+        }
 
-    @Override
-    public boolean hasPosition() {
-        return false; // TODO Implement OSX SpotifyAPI
+        if (this.isPlaying) {
+            // Interpolate position
+            long timePassed = System.currentTimeMillis() - this.lastTimePositionUpdated;
+            return this.currentPosition + (int) timePassed;
+        } else {
+            return this.currentPosition;
+        }
     }
 
     @Override
-    public void pressMediaKey(MediaKey mediaKey) {
-
+    public Track getTrack() {
+        return this.currentTrack;
     }
 
     @Override
     public boolean isPlaying() {
-        return false; // TODO Implement OSX SpotifyAPI
+        return this.isPlaying;
     }
 
     @Override
     public boolean isConnected() {
-        return false; // TODO Implement OSX SpotifyAPI
+        return this.connected;
     }
 
     @Override
-    public void stop() {
-
+    public boolean hasPosition() {
+        return this.currentPosition != -1;
     }
 
 }

src/main/java/de/labystudio/spotifyapi/platform/osx/OSXSpotifyApi.java

@@ -0,0 +1,46 @@
+package de.labystudio.spotifyapi.platform.osx.api;
+
+
+/**
+ * Wrapper for the AppleScript parameters.
+ *
+ * @author LabyStudio
+ */
+public class Action {
+
+    public static final Action GET = new Action("get", "the");
+    public static final Action OF = new Action("of");
+
+    private final String action;
+
+    public Action(String... args) {
+        this.action = String.join(" ", args);
+    }
+
+    public Action(String argument) {
+        this.action = argument;
+    }
+
+    public Action(Action... actions) {
+        this.action = toString(actions);
+    }
+
+    @Override
+    public String toString() {
+        return this.action;
+    }
+
+    /**
+     * Convert an array of actions to a string.
+     *
+     * @param actions The actions to convert
+     * @return The string representation of the actions
+     */
+    public static String toString(Action... actions) {
+        String[] args = new String[actions.length];
+        for (int i = 0; i < actions.length; i++) {
+            args[i] = actions[i].toString();
+        }
+        return String.join(" ", args);
+    }
+}