implement isInitialized method, improve address search, version 1.0.4

Author: LabyStudio

README.md

@@ -14,7 +14,7 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.github.LabyStudio:java-spotify-api:1.0.4:all'
+    implementation 'com.github.LabyStudio:java-spotify-api:1.0.5:all'
 }
 ```
 

build.gradle

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

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

@@ -78,6 +78,14 @@ default boolean hasTrack() {
      */
     boolean isConnected();
 
+
+    /**
+     * Returns true if the background process is running.
+     *
+     * @return true if the background process is running
+     */
+    boolean isInitialized();
+
     /**
      * Registers a listener to be notified about changes.
      *

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

@@ -20,6 +20,11 @@ public SpotifyAPI initialize() {
         return this;
     }
 
+    @Override
+    public boolean isInitialized() {
+        return false;
+    }
+
     @Override
     public Track getTrack() {
         return null; // TODO Implement OSX SpotifyAPI

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

@@ -40,7 +40,7 @@ public class WinSpotifyAPI extends AbstractSpotifyAPI {
      * @throws IllegalStateException if the API is already initialized
      */
     public SpotifyAPI initialize() {
-        if (this.task != null) {
+        if (this.isInitialized()) {
             throw new IllegalStateException("The SpotifyAPI is already initialized");
         }
 
@@ -158,6 +158,11 @@ public boolean isConnected() {
         return this.process != null && this.process.isOpen();
     }
 
+    @Override
+    public boolean isInitialized() {
+        return this.task != null;
+    }
+
     @Override
     public void stop() {
         if (this.task != null) {

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

@@ -17,9 +17,11 @@
  */
 public class WinProcess implements WinApi {
 
-    private final int processId;
-    private final WinNT.HANDLE handle;
-    private final WinDef.HWND window;
+    protected final int processId;
+    protected final WinNT.HANDLE handle;
+    protected final WinDef.HWND window;
+
+    protected final long maxContentAddress;
 
     /**
      * Creates a new instance of the {@link WinProcess} class.
@@ -42,6 +44,8 @@ public WinProcess(String executableName) {
         if (this.getWindowTitle().isEmpty()) {
             throw new IllegalStateException("Window for process " + this.processId + " not found");
         }
+
+        this.maxContentAddress = this.getModuleAddress("wow64cpu.dll");
     }
 
     /**
@@ -105,15 +109,15 @@ public byte[] readBytes(long address, int length) {
      * <p>
      * It will return -1 if no address was found.
      *
-     * @param address     The address to start searching from.
-     * @param size        The maximum amount of bytes to search.
+     * @param minAddress  The minimum address to start searching from.
+     * @param maxAddress  The maximum address to stop searching at.
      * @param searchBytes The bytes to search for.
      * @return The address of the first matching bytes.
      */
-    public long findInMemory(long address, long size, byte[] searchBytes) {
+    public long findInMemory(long minAddress, long maxAddress, byte[] searchBytes) {
         int chunkSize = 1024 * 64;
 
-        for (long cursor = address; cursor < (address + size); cursor += chunkSize) {
+        for (long cursor = minAddress; cursor < maxAddress; cursor += chunkSize) {
             byte[] chunk = this.readBytes(cursor, chunkSize + searchBytes.length);
 
             for (int i = 0; i < chunk.length - searchBytes.length; i++) {
@@ -139,15 +143,14 @@ public long findInMemory(long address, long size, byte[] searchBytes) {
      * <p>
      * It will return -1 if no address was found.
      *
-     * @param address     The address to start searching from.
-     * @param size        The maximum amount of bytes to search.
+     * @param minAddress  The address to start searching from.
+     * @param maxAddress  The address to stop searching at.
      * @param searchBytes The bytes to search for.
      * @param condition   The condition function to call for each matching address.
      * @return The address of the first matching bytes.
      */
-    public long findInMemory(long address, long size, byte[] searchBytes, SearchCondition condition) {
-        long cursor = address;
-        long maxAddress = size - address;
+    public long findInMemory(long minAddress, long maxAddress, byte[] searchBytes, SearchCondition condition) {
+        long cursor = minAddress;
         int index = 0;
         while (cursor < maxAddress) {
             long target = this.findInMemory(cursor, maxAddress, searchBytes);
@@ -160,6 +163,23 @@ public long findInMemory(long address, long size, byte[] searchBytes, SearchCond
         return -1;
     }
 
+    /**
+     * Check if the given bytes are at the given address.
+     *
+     * @param address The address to check.
+     * @param bytes   The bytes to check.
+     * @return True if the bytes are at the given address.
+     */
+    public boolean hasBytes(long address, int... bytes) {
+        byte[] chunk = this.readBytes(address, bytes.length);
+        for (int i = 0; i < chunk.length; i++) {
+            if (chunk[i] != (byte) bytes[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     /**
      * Find the address of a text inside the memory.
      * If there are multiple matches of the text, the given index will be used to select the correct one.
@@ -170,8 +190,20 @@ public long findInMemory(long address, long size, byte[] searchBytes, SearchCond
      * @return The address of the text at the given index
      */
     public long findAddressOfText(long start, String text, int index) {
-        long maxAddress = this.getMaxProcessAddress();
-        return this.findInMemory(start, maxAddress, text.getBytes(), (address, matchIndex) -> matchIndex == index);
+        return this.findAddressOfText(start, text, (address, matchIndex) -> matchIndex == index);
+    }
+
+    /**
+     * Find the address of a text 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 text      The text to search for.
+     * @param condition The condition function to call for each matching address.
+     * @return The address of the text at the given index
+     */
+    public long findAddressOfText(long start, String text, SearchCondition condition) {
+        return this.findInMemory(start, this.maxContentAddress, text.getBytes(), condition);
     }
 
     /**
@@ -192,6 +224,43 @@ public long findAddressUsingPath(String... path) {
         return cursor;
     }
 
+    /**
+     * Find an address by matching multiple rules inside the memory.
+     * It will start searching for the first rule and continues the next at the position where the previous match was found.
+     *
+     * @param rules The list of rules to search for.
+     * @return The final addresses after all rules were matched.
+     */
+    public long findAddressUsingRules(SearchRule... rules) {
+        long cursor = -1;
+        for (SearchRule rule : rules) {
+            cursor = this.findAddressOfText(cursor + 1, rule.getText(), rule.getCondition());
+            if (cursor == -1) {
+                return -1;
+            }
+        }
+        return cursor;
+    }
+
+    /**
+     * Find the base address of the given module name.
+     *
+     * @param moduleName The name of the module.
+     * @return The base address of the module.
+     */
+    public long getModuleAddress(String moduleName) {
+        return this.getModuleAddress(this.processId, moduleName);
+    }
+
+    /**
+     * Collect all module addresses and their size of the given process.
+     *
+     * @return A list of module addresses and their size.
+     */
+    public Map<Long, Long> getModules() {
+        return this.getModules(this.processId);
+    }
+
     /**
      * Find the first address of the modules.
      *
@@ -262,6 +331,15 @@ public void close() {
         Kernel32.INSTANCE.CloseHandle(this.handle);
     }
 
+    /**
+     * Get the highest memory address with relevant content.
+     *
+     * @return The highest memory address with relevant content.
+     */
+    public long getMaxContentAddress() {
+        return this.maxContentAddress;
+    }
+
     /**
      * Search condition function to check if the address matches additional criteria.
      */
@@ -277,4 +355,23 @@ public interface SearchCondition {
         boolean matches(long address, int index);
     }
 
+    public static class SearchRule {
+
+        private final String text;
+        private final SearchCondition condition;
+
+        public SearchRule(String text, SearchCondition condition) {
+            this.text = text;
+            this.condition = condition;
+        }
+
+        public String getText() {
+            return this.text;
+        }
+
+        public SearchCondition getCondition() {
+            return this.condition;
+        }
+    }
+
 }

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

@@ -1,6 +1,6 @@
 package de.labystudio.spotifyapi.platform.windows.api.playback;
 
-import de.labystudio.spotifyapi.platform.windows.api.spotify.SpotifyProcess;
+import de.labystudio.spotifyapi.platform.windows.api.WinProcess;
 
 /**
  * Accessor to read the duration, position and playing state from the Spotify process.
@@ -12,7 +12,7 @@ public class PlaybackAccessor {
     private static final long MIN_TRACK_DURATION = 1000; // 1 second
     private static final long MAX_TRACK_DURATION = 1000 * 60 * 10; // 10 minutes
 
-    private final SpotifyProcess process;
+    private final WinProcess process;
     private final PointerRegistry pointerRegistry;
 
     private int length;
@@ -25,7 +25,7 @@ public class PlaybackAccessor {
      * @param process            The Spotify process to read from.
      * @param contextBaseAddress The base address of the context.
      */
-    public PlaybackAccessor(SpotifyProcess process, long contextBaseAddress) {
+    public PlaybackAccessor(WinProcess process, long contextBaseAddress) {
         this.process = process;
 
         // Create pointer registry to calculate the absolute addresses using the relative offsets

src/main/java/de/labystudio/spotifyapi/platform/windows/api/spotify/SpotifyProcess.java

@@ -10,6 +10,7 @@
  */
 public class SpotifyProcess extends WinProcess {
 
+    private static final boolean DEBUG = false;
     private static final byte[] PREFIX_CONTEXT = new byte[]{0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74};
 
     private final long addressTrackId;
@@ -28,27 +29,32 @@ public class SpotifyProcess extends WinProcess {
     public SpotifyProcess() {
         super("Spotify.exe");
 
-        // Get the highest addresses of the modules
-        long highestAddress = this.getMaxProcessAddress();
+        if (DEBUG) {
+            System.out.println("Spotify process loaded! Searching for addresses...");
+        }
+
+        long timeScanStart = System.currentTimeMillis();
 
         // Find addresses of playback states (Located in the chrome_elf.dll module)
-        this.addressTrackId = this.findAddressUsingPath(
-                "This program cannot be run in DOS mode",
-                "This program cannot be run in DOS mode",
-                "chrome_elf.dll",
-                "spotify:track:"
+        this.addressTrackId = this.findAddressOfText(
+                this.maxContentAddress / 2,
+                "spotify:track:",
+                (address, index) -> this.hasBytes(address + 1028, 0xDC, 0xA1)
         );
         if (this.addressTrackId == -1 || !this.isTrackIdValid(this.getTrackId())) {
             throw new IllegalStateException("Could not find track id in memory");
         }
+        if (DEBUG) {
+            System.out.println("Found track id address: " + Long.toHexString(this.addressTrackId));
+        }
 
         // Check if the song is currently playing using the title bar
         boolean isPlaying = this.isPlayingUsingTitle();
 
-        // Find addresses of track id
+        // Find addresses of track id;
         this.addressPlayBack = this.findInMemory(
                 0,
-                highestAddress,
+                this.addressTrackId,
                 PREFIX_CONTEXT,
                 (address, index) -> {
                     PlaybackAccessor accessor = new PlaybackAccessor(this, address);
@@ -58,6 +64,10 @@ public SpotifyProcess() {
         if (this.addressPlayBack == -1) {
             throw new IllegalStateException("Could not find playback in memory");
         }
+        if (DEBUG) {
+            System.out.println("Found playback address at: " + Long.toHexString(this.addressPlayBack));
+            System.out.println("Scanning took " + (System.currentTimeMillis() - timeScanStart) + "ms");
+        }
 
         // Create the playback accessor with the found address
         this.playbackAccessor = new PlaybackAccessor(this, this.addressPlayBack);

src/test/java/SpotifyProcessTest.java

@@ -0,0 +1,31 @@
+import de.labystudio.spotifyapi.platform.windows.api.WinProcess;
+import de.labystudio.spotifyapi.platform.windows.api.playback.PlaybackAccessor;
+
+public class SpotifyProcessTest {
+
+    private static final byte[] PREFIX_CONTEXT = new byte[]{0x63, 0x6F, 0x6E, 0x74, 0x65, 0x78, 0x74};
+
+    public static void main(String[] args) {
+        WinProcess process = new WinProcess("Spotify.exe");
+
+        long addressTrackId = process.findAddressOfText(
+                process.getMaxContentAddress() / 2,
+                "spotify:track:",
+                (address, index) -> process.hasBytes(address + 1028, 0xDC, 0xA1)
+        );
+        System.out.println("Track Id Address: " + Long.toHexString(addressTrackId));
+
+        long addressPlayBack = process.findInMemory(
+                0,
+                addressTrackId,
+                PREFIX_CONTEXT,
+                (address, index) -> {
+                    PlaybackAccessor accessor = new PlaybackAccessor(process, address);
+                    return accessor.isValid();
+                }
+        );
+        System.out.println("Playback Address: " + Long.toHexString(addressPlayBack));
+
+    }
+
+}