implement fallback playback accessor

Author: LabyStudio

README.md

@@ -99,7 +99,7 @@ api.initialize();
 
 Fetch an image of the current playing track:
 ```java
-// Create an instance of the Open Spotify API
+// Create an instance of the Open Spotify API (Or use SpotifyAPI#getOpenAPI)
 OpenSpotifyAPI openSpotifyAPI = new OpenSpotifyAPI();
 
 // Download the cover art of the current song

build.gradle

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

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

@@ -3,6 +3,7 @@
 import de.labystudio.spotifyapi.config.SpotifyConfiguration;
 import de.labystudio.spotifyapi.model.MediaKey;
 import de.labystudio.spotifyapi.model.Track;
+import de.labystudio.spotifyapi.open.OpenSpotifyAPI;
 
 import java.util.concurrent.CompletableFuture;
 
@@ -147,6 +148,8 @@ default boolean hasTrack() {
      */
     SpotifyConfiguration getConfiguration();
 
+    OpenSpotifyAPI getOpenAPI();
+
     /**
      * Disconnect from the Spotify application and stop all background tasks.
      */

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

@@ -39,10 +39,6 @@ public class OpenSpotifyAPI {
 
     private AccessTokenResponse accessTokenResponse;
 
-    public OpenSpotifyAPI() {
-        this.generateAccessTokenAsync(accessTokenResponse -> this.accessTokenResponse = accessTokenResponse);
-    }
-
     /**
      * Generate an access token asynchronously for the open spotify api
      */
@@ -262,13 +258,19 @@ public OpenTrack requestOpenTrack(String trackId) throws IOException {
      * @throws IOException if the request failed
      */
     public <T> T request(String url, Class<?> clazz, boolean canGenerateNewAccessToken) throws IOException {
+        // Generate access token if not present
+        if (this.accessTokenResponse == null) {
+            this.accessTokenResponse = this.generateAccessToken();
+        }
+
         // Connect
         HttpsURLConnection connection = (HttpsURLConnection) new URL(url).openConnection();
         connection.addRequestProperty("User-Agent", USER_AGENT);
         connection.addRequestProperty("referer", "https://open.spotify.com/");
         connection.addRequestProperty("app-platform", "WebPlayer");
         connection.addRequestProperty("origin", "https://open.spotify.com");
 
+        // Add access token
         if (this.accessTokenResponse != null) {
             connection.addRequestProperty("authorization", "Bearer " + this.accessTokenResponse.accessToken);
         }
@@ -290,8 +292,8 @@ public <T> T request(String url, Class<?> clazz, boolean canGenerateNewAccessTok
 
         // Read response
         JsonReader reader = new JsonReader(new InputStreamReader(
-            connection.getInputStream(),
-            StandardCharsets.UTF_8
+                connection.getInputStream(),
+                StandardCharsets.UTF_8
         ));
 
         return GSON.fromJson(reader, clazz);

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

@@ -3,6 +3,7 @@
 import de.labystudio.spotifyapi.SpotifyAPI;
 import de.labystudio.spotifyapi.SpotifyListener;
 import de.labystudio.spotifyapi.config.SpotifyConfiguration;
+import de.labystudio.spotifyapi.open.OpenSpotifyAPI;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -22,6 +23,8 @@ public abstract class AbstractTickSpotifyAPI implements SpotifyAPI {
      */
     protected final List<SpotifyListener> listeners = new ArrayList<>();
 
+    private OpenSpotifyAPI openAPI;
+
     private SpotifyConfiguration configuration;
 
     private ScheduledFuture<?> task;
@@ -100,6 +103,14 @@ public SpotifyConfiguration getConfiguration() {
         return this.configuration;
     }
 
+    @Override
+    public final OpenSpotifyAPI getOpenAPI() {
+        if (this.openAPI == null) {
+            this.openAPI = new OpenSpotifyAPI();
+        }
+        return this.openAPI;
+    }
+
     @Override
     public void stop() {
         synchronized (this) {

src/main/java/de/labystudio/spotifyapi/platform/windows/WinSpotifyAPI.java

@@ -3,6 +3,7 @@
 import de.labystudio.spotifyapi.SpotifyListener;
 import de.labystudio.spotifyapi.model.MediaKey;
 import de.labystudio.spotifyapi.model.Track;
+import de.labystudio.spotifyapi.open.model.track.OpenTrack;
 import de.labystudio.spotifyapi.platform.AbstractTickSpotifyAPI;
 import de.labystudio.spotifyapi.platform.windows.api.WinApi;
 import de.labystudio.spotifyapi.platform.windows.api.playback.PlaybackAccessor;
@@ -31,7 +32,6 @@ public class WinSpotifyAPI extends AbstractTickSpotifyAPI {
     private long lastAccessorPosition = -1;
     private long lastTimeSynced;
 
-
     /**
      * Updates the current track, position and playback state.
      * If the process is not connected, it will try to connect to the Spotify process.
@@ -49,7 +49,7 @@ protected void onTick() throws Exception {
         String trackId = this.process.getTrackId();
 
         // Update playback status and check if it is valid
-        if (!playback.update() || !this.process.isTrackIdValid(trackId)) {
+        if (!this.process.isTrackIdValid(trackId) || !playback.update()) {
             this.positionKnown = false;
             this.currentPosition = -1;
             throw new IllegalStateException("Could not update playback");
@@ -69,6 +69,18 @@ protected void onTick() throws Exception {
                 int trackLength = playback.getLength();
                 boolean isFirstTrack = !this.hasTrack();
 
+                // Request track length from open API if not available
+                if (!playback.hasTrackLength()) {
+                    try {
+                        OpenTrack openTrack = this.getOpenAPI().requestOpenTrack(trackId);
+                        if (openTrack != null) {
+                            trackLength = openTrack.durationMs;
+                        }
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                }
+
                 Track track = new Track(trackId, title.getTrackName(), title.getTrackArtist(), trackLength);
                 this.currentTrack = track;
 
@@ -87,13 +99,19 @@ protected void onTick() throws Exception {
         if (isPlaying != this.isPlaying) {
             this.isPlaying = isPlaying;
 
+            // Forget position if the song is paused and the position is unknown
+            if (!playback.hasTrackPosition()) {
+                this.positionKnown = false;
+                this.currentPosition = -1;
+            }
+
             // Fire on play back changed
             this.listeners.forEach(listener -> listener.onPlayBackChanged(isPlaying));
         }
 
         // Handle position changes
         int position = playback.getPosition();
-        if (position != this.lastAccessorPosition) {
+        if (playback.hasTrackPosition() && position != this.lastAccessorPosition) {
             this.lastAccessorPosition = position;
             this.updatePosition(position, false);
         }

src/main/java/de/labystudio/spotifyapi/platform/windows/api/WinProcess.java

@@ -308,6 +308,26 @@ public long findAddressOfText(long start, long end, String text, SearchCondition
         return this.findInMemory(start, end, text.getBytes(), condition);
     }
 
+    /**
+     * Find the address of multiple text strings inside the memory.
+     * If there are multiple matches of the text, the given index will be used to select the correct one.
+     *
+     * @param start     The address to start searching from.
+     * @param end       The address to stop searching at.
+     * @param condition The condition function to call for each matching address.
+     * @param texts     The texts to search for.
+     * @return The address of the text at the given index
+     */
+    public long findAddressOfTexts(long start, long end, SearchCondition condition, String... texts) {
+        for (String text : texts) {
+            long address = this.findAddressOfText(start, end, text, condition);
+            if (address != -1) {
+                return address;
+            }
+        }
+        return -1;
+    }
+
     /**
      * Find multiple strings inside the memory.
      * It will start searching with the first string and continue with the next at the position where the previous was found.

src/main/java/de/labystudio/spotifyapi/platform/windows/api/playback/PlaybackAccessor.java

@@ -1,86 +1,21 @@
 package de.labystudio.spotifyapi.platform.windows.api.playback;
 
-import de.labystudio.spotifyapi.platform.windows.api.WinProcess;
+public interface PlaybackAccessor {
+    boolean update();
 
-/**
- * Accessor to read the duration, position and playing state from the Spotify process.
- *
- * @author LabyStudio
- */
-public class PlaybackAccessor {
+    boolean isValid();
 
-    private static final long MIN_TRACK_DURATION = 1000; // 1 second
-    private static final long MAX_TRACK_DURATION = 1000 * 60 * 10; // 10 minutes
+    int getLength();
 
-    private final WinProcess process;
-    private final PointerRegistry pointerRegistry;
+    int getPosition();
 
-    private int length;
-    private int position;
-    private boolean isPlaying;
+    boolean isPlaying();
 
-    /**
-     * Creates a new instance of the PlaybackAccessor.
-     *
-     * @param process The Spotify process to read from.
-     * @param address The reference address of the playback section
-     */
-    public PlaybackAccessor(WinProcess process, long address) {
-        this.process = process;
-
-        // Create pointer registry to calculate the absolute addresses using the relative offsets
-        this.pointerRegistry = new PointerRegistry(0x0CFF4498, address);
-        this.pointerRegistry.register("position", 0x0CFF4810);
-        this.pointerRegistry.register("length", 0x0CFF4820);
-        this.pointerRegistry.register("is_playing", 0x0CFF4850); // 1=true, 0=false
-
-        this.update();
-    }
-
-    /**
-     * Read the current length, position and playing state from the Spotify process.
-     *
-     * @return true if the new values are valid, false otherwise
-     */
-    public boolean update() {
-        this.position = this.process.readInteger(this.pointerRegistry.getAddress("position"));
-        this.length = this.process.readInteger(this.pointerRegistry.getAddress("length"));
-        this.isPlaying = this.process.readBoolean(this.pointerRegistry.getAddress("is_playing"));
-        return this.isValid();
-    }
-
-    /**
-     * Checks if the current values are valid.
-     * <p>
-     * To make sure that we have correct values from the memory address,
-     * we have to set some rules what kind of duration is correct.
-     * <p>
-     * The values are correct if:<br>
-     * - position {@literal <}= length<br>
-     * - length {@literal >} 0<br>
-     * - length {@literal <}= 10 minutes<br>
-     * - position {@literal >}= 1 second<br>
-     * - the parity bits are correct<br>
-     *
-     * @return true if the current values are valid, false otherwise
-     */
-    public boolean isValid() {
-        return this.position <= this.length
-                && this.position >= 0
-                && this.length <= MAX_TRACK_DURATION
-                && this.length >= MIN_TRACK_DURATION;
+    default boolean hasTrackLength() {
+        return this.getLength() > 0;
     }
 
-    public int getLength() {
-        return this.length;
+    default boolean hasTrackPosition() {
+        return this.getPosition() >= 0 && (!this.hasTrackLength() || this.getPosition() <= this.getLength());
     }
-
-    public int getPosition() {
-        return this.position;
-    }
-
-    public boolean isPlaying() {
-        return this.isPlaying;
-    }
-
 }

src/main/java/de/labystudio/spotifyapi/platform/windows/api/playback/PseudoPlaybackAccessor.java

@@ -0,0 +1,39 @@
+package de.labystudio.spotifyapi.platform.windows.api.playback;
+
+import de.labystudio.spotifyapi.platform.windows.api.spotify.SpotifyProcess;
+
+public class PseudoPlaybackAccessor implements PlaybackAccessor {
+
+    private final SpotifyProcess spotifyProcess;
+    private boolean playing;
+
+    public PseudoPlaybackAccessor(SpotifyProcess spotifyProcess) {
+        this.spotifyProcess = spotifyProcess;
+    }
+
+    @Override
+    public boolean update() {
+        this.playing = this.spotifyProcess.isPlayingUsingTitle();
+        return true;
+    }
+
+    @Override
+    public boolean isValid() {
+        return true;
+    }
+
+    @Override
+    public int getLength() {
+        return -1;
+    }
+
+    @Override
+    public int getPosition() {
+        return -1;
+    }
+
+    @Override
+    public boolean isPlaying() {
+        return this.playing;
+    }
+}