stagelinq 1.0.0 → 1.0.4

package/Databases/Databases.ts

@@ -1,10 +1,10 @@
+import { ConnectionInfo, Source } from '../types';
 import { EventEmitter } from 'stream';
 import { FileTransfer } from '../services';
 import { getTempFilePath } from '../albumArt';
+import { Logger } from '../LogEmitter';
 import { NetworkDevice } from '../network';
 import * as fs from 'fs';
-import { Logger } from '../LogEmitter';
-import { ConnectionInfo, Source } from '../types';
 
 export declare interface Databases {
   on(event: 'dbDownloaded', listener: (sourceName: string, dbPath: string) => void): this;
@@ -25,7 +25,10 @@ export class Databases extends EventEmitter {
     const sources = await service.getSources();
     const output: string[] = [];
     for (const source of sources) {
-      const dbConnectionName = `${connectionInfo.address}_${connectionInfo.port}_${source.name}`;
+      const deviceId = /(\w{8})(\w{4})(\w{4})(\w{4})(\w{12})/i
+        .exec(Buffer.from(connectionInfo.token).toString('hex')).splice(1).join('-');
+      const dbConnectionName = `net://${deviceId}/${source.name}`;
+      Logger.debug(`DB network path: ${dbConnectionName}`);
       if (this.sources.has(dbConnectionName)) {
         Logger.debug(`Already seen ${source} on ${connectionInfo.address}:${connectionInfo.port}`);
       } else {
@@ -60,9 +63,23 @@ export class Databases extends EventEmitter {
     this.emit('dbDownloaded', sourceId, dbPath);
   }
 
-  getDbPath(dbSourceName: string) {
-    if (!this.sources.has(dbSourceName))
-      throw new Error(`Database name ${dbSourceName} does not exist`);
+  getDbPath(dbSourceName?: string) {
+    if (!dbSourceName || !this.sources.has(dbSourceName)) {
+
+      // Hack: Denon will save metadata on streaming files but only on an
+      // internal database. So if the source is "(Unknown)streaming://"
+      // return the first internal database we find.
+      for (const entry of Array.from(this.sources.entries())) {
+        if (/\(Internal\)/.test(entry[0])) {
+          Logger.debug(`Returning copy of internal database`);
+          return this.sources.get(entry[0]);
+        }
+      }
+
+      // Else, throw an exception.
+      throw new Error(`Data source "${dbSourceName}" doesn't exist.`);
+    }
+
     return this.sources.get(dbSourceName);
   }
 

package/Databases/DbConnection.ts

@@ -20,7 +20,7 @@ export class DbConnection {
    * @returns
    */
   querySource<T>(query: string, ...params: any[]): T[] {
-    console.debug(`Querying ${this.dbPath}: `);
+    console.debug(`Querying ${this.dbPath}: ${query} (${params.join(', ')})`);
     const result = this.db.prepare(query);
     return result.all(params);
   }
@@ -32,11 +32,16 @@ export class DbConnection {
    * @returns
    */
   getTrackInfo(trackPath: string) {
-    return this.querySource(`SELECT * FROM Track WHERE path = '${trackPath}'`);
+    if (/streaming:\/\//.test(trackPath)) {
+      return this.querySource('SELECT * FROM Track WHERE uri = (?)', trackPath);
+    } else {
+      return this.querySource('SELECT * FROM Track WHERE path = (?)', trackPath);
+    }
   }
 
   close() {
     console.debug(`Closing ${this.dbPath}`);
     this.db.close();
   }
+
 }

package/StageLinq/index.ts

@@ -19,7 +19,7 @@ export class StageLinq extends EventEmitter {
   logger: Logger = Logger.instance;
   options: StageLinqOptions;
 
-  private listener: StageLinqListener = new StageLinqListener();
+  private listener: StageLinqListener;
 
   constructor(options?: StageLinqOptions) {
     super();
@@ -31,6 +31,7 @@ export class StageLinq extends EventEmitter {
    * Connect to the StageLinq network.
    */
   async connect() {
+    this.listener = new StageLinqListener();
     const msg = createDiscoveryMessage(Action.Login, this.options.actingAs);
     await announce(msg);
     this.listener.listenForDevices(async (connectionInfo) => {

package/cli/index.ts

@@ -2,11 +2,14 @@ import { ActingAsDevice } from '../types';
 import { DbConnection } from "../Databases";
 import { sleep } from '../utils/sleep';
 import { StageLinq } from '../StageLinq';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
 require('console-stamp')(console, {
   format: ':date(HH:MM:ss) :label',
 });
 
-
 (async () => {
 
   console.log('Starting CLI');
@@ -69,9 +72,9 @@ require('console-stamp')(console, {
     });
   });
 
-  // Fires when StageLinq has successfully connect to at least one device and is ready to use.
-  stageLinq.devices.on('ready', (connectionInfo) => {
-    console.log(`Device ${connectionInfo.software.name} is ready!`);
+  // Fires when StageLinq and all devices are ready to use.
+  stageLinq.devices.on('ready', () => {
+    console.log(`StageLinq is ready!`);
   });
 
   // Fires when a new track is loaded on to a player.
@@ -79,9 +82,10 @@ require('console-stamp')(console, {
 
     // Example of how to connect to the database using this library's
     // implementation of BetterSqlite3 to get additional information.
-    if (stageLinq.options.downloadDbSources && status.dbSourceName) {
+    if (stageLinq.options.downloadDbSources) {
       try {
-        const connection = new DbConnection(stageLinq.databases.getDbPath(status.dbSourceName));
+        const dbPath = stageLinq.databases.getDbPath(status.dbSourceName)
+        const connection = new DbConnection(dbPath);
         const result = connection.getTrackInfo(status.trackPath);
         connection.close();
         console.log('Database entry:', result);
@@ -89,6 +93,19 @@ require('console-stamp')(console, {
         console.error(e);
       }
     }
+
+    // Example of how to download the actual track from the media.
+    try {
+      const tempfile = path.resolve(os.tmpdir(), 'media');
+      const data = await stageLinq.devices.downloadFile(status.deviceId, status.trackPathAbsolute);
+      if (data) {
+        fs.writeFileSync(tempfile, Buffer.from(data));
+        console.log(`Downloaded ${status.trackPathAbsolute} to ${tempfile}`);
+      }
+    } catch(e) {
+      console.error(`Could not download ${status.trackPathAbsolute}`);
+    }
+
     console.log('New track loaded:', status);
   });
 

package/devices/Player.ts

@@ -15,11 +15,13 @@ interface PlayerOptions {
   stateMap: StateMap;
   address: string,
   port: number;
+  deviceId: string;
 }
 
 interface SourceAndTrackPath {
   source: string;
   trackPath: string;
+  trackPathAbsolute: string;
 }
 
 /**
@@ -47,6 +49,7 @@ export class Player extends EventEmitter {
   private masterStatus: boolean;    // If this device has the matser tempo
   private decks: Map<string, PlayerLayerState> = new Map();
   private queue: {[layer: string]: PlayerMessageQueue} = {};
+  private deviceId: string;
 
   /**
    * Initialize a player device.
@@ -59,6 +62,7 @@ export class Player extends EventEmitter {
     options.stateMap.on('message', this.messageHandler.bind(this));
     this.address = options.address;
     this.port = options.port;
+    this.deviceId = options.deviceId;
     this.queue = {
       A: new PlayerMessageQueue('A').onDataReady(this.handleUpdate.bind(this)),
       B: new PlayerMessageQueue('B').onDataReady(this.handleUpdate.bind(this)),
@@ -104,7 +108,8 @@ export class Player extends EventEmitter {
       : (/Track\/TrackNetworkPath$/.test(name)) ? {
           trackNetworkPath: json.string,
           source: this.getSourceAndTrackPath(json.string).source,
-          trackPath: this.getSourceAndTrackPath(json.string).trackPath
+          trackPath: this.getSourceAndTrackPath(json.string).trackPath,
+          trackPathAbsolute: this.getSourceAndTrackPath(json.string).trackPathAbsolute
         }
       : (/Track\/SongLoaded$/.test(name)) ? { songLoaded: json.state }
       : (/Track\/SongName$/.test(name)) ? { title: json.string }
@@ -148,14 +153,32 @@ export class Player extends EventEmitter {
       port: this.port,
       masterTempo: this.masterTempo,
       masterStatus: this.masterStatus,
+      deviceId: `net://${this.deviceId}`,
       ...result
     };
 
-    // We're casting it because we originally built it up piecemeal.
+    // We're casting here because we originally built it up piecemeal.
     const currentState = output as PlayerStatus;
-    currentState.dbSourceName = currentState.source ? `${this.address}_${this.port}_${currentState.source}` : '';
-    if (songLoadedSignalPresent && currentState.trackNetworkPath) this.emit('trackLoaded', currentState);
+
+    if (currentState.trackNetworkPath && currentState.trackNetworkPath.startsWith('net:')) {
+      const pathParts = currentState.trackNetworkPath.split('net://')[1].split('/', 2);
+      currentState.dbSourceName = `net://${pathParts[0]}/${pathParts[1]}`;
+      currentState.deviceId = `net://${pathParts[0]}`;
+    } else if (!currentState.source || /Unknown/.test(currentState.source)) {
+      // Tracks from streaming sources won't be in the database.
+      currentState.dbSourceName = '';
+    } else {
+      currentState.dbSourceName = `net://${this.deviceId}/${currentState.source}`;
+    }
+
+    // If a song is loaded and we have a location emit the trackLoaded event.
+    if (currentState.trackNetworkPath)
+      this.emit('trackLoaded', currentState);
+
+    // If the song is actually playing emit the nowPlaying event.
     if (result.playState) this.emit('nowPlaying', currentState);
+
+    // Emit that the state has changed.
     this.emit('stateChanged', currentState);
   }
 
@@ -165,17 +188,29 @@ export class Player extends EventEmitter {
   }
 
   private getSourceAndTrackPath(p_path: string): SourceAndTrackPath {
-    if (!p_path || p_path.length === 0) return { source: '', trackPath: '' };
+    if (!p_path || p_path.length === 0) return { source: '', trackPath: '', trackPathAbsolute: '' };
     const parts = p_path.split('/');
     const source = parts[3];
     let trackPath = parts.slice(5).join('/');
+
+    // Handle streaming tracks.
+    if (/\(Unknown\)/.test(source)) {
+      return {
+        source: source.replace(':', ''),
+        trackPath: `streaming://${trackPath}`,
+        trackPathAbsolute: `streaming://${trackPath}`
+      }
+    }
+
     if (parts[4] !== 'Engine Library') {
       // This probably occurs with RekordBox conversions; tracks are outside Engine Library folder
       trackPath = `../${parts[4]}/${trackPath}`;
     }
+
     return {
       source: source,
       trackPath: trackPath,
+      trackPathAbsolute: `/${source}/Engine Library/${trackPath}`
     };
   }
 

package/network/StageLinqDevices.ts

@@ -14,13 +14,17 @@ interface StageLinqDevice {
   fileTransferService: FileTransfer;
 };
 
+// This time needs to be just long enough for discovery messages from all to
+// come through.
+const WAIT_FOR_DEVICES_TIMEOUT_MS = 3000;
+
 export declare interface StageLinqDevices {
   on(event: 'trackLoaded', listener: (status: PlayerStatus) => void): this;
   on(event: 'stateChanged', listener: (status: PlayerStatus) => void): this;
   on(event: 'nowPlaying', listener: (status: PlayerStatus) => void): this;
   on(event: 'connected', listener: (connectionInfo: ConnectionInfo) => void): this;
   on(event: 'message', listener: (connectionInfo: ConnectionInfo, message: ServiceMessage<StateData>) => void): this;
-  on(event: 'ready', listener: (connectionInfo: ConnectionInfo) => void): this;
+  on(event: 'ready', listener: () => void): this;
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -38,44 +42,97 @@ export class StageLinqDevices extends EventEmitter {
   private discoveryStatus: Map<string, ConnectionStatus> = new Map();
   private options: StageLinqOptions;
 
+  private deviceWatchTimeout: NodeJS.Timeout | null = null;
+  private stateMapCallback: { connectionInfo: ConnectionInfo, networkDevice: NetworkDevice }[] = [];
+
   constructor(options: StageLinqOptions) {
     super();
     this.options = options;
     this._databases = new Databases();
+    this.waitForAllDevices = this.waitForAllDevices.bind(this);
+    this.waitForAllDevices();
   }
 
   /**
-   * Attempt to connect to the player.
+   * Handle incoming discovery messages from the StageLinq network
    *
-   * @param connectionInfo Device discovered
-   * @returns Retries to connect 3 times. If successful return void if not throw exception.
+   * @param connectionInfo Connection info.
    */
   async handleDevice(connectionInfo: ConnectionInfo) {
     Logger.silly(this.showDiscoveryStatus(connectionInfo));
 
-    // Ignore this discovery message if connected, connecting, failed, or
-    // if it's blacklisted.
+    // Ignore this discovery message if we've already connected to it,
+    // are still connecting, if it has failed, or if it's blacklisted.
     if (this.isConnected(connectionInfo)
       || this.isConnecting(connectionInfo)
       || this.isFailed(connectionInfo)
       || this.isIgnored(connectionInfo)) return;
 
-    this.discoveryStatus.set(this.deviceId(connectionInfo), ConnectionStatus.CONNECTING);
+    this.connectToDevice(connectionInfo);
+  }
 
-    // Retrying appears to be necessary because it seems the Denon hardware
-    // sometimes doesn't connect. Retrying after a little wait seems to
-    // solve the issue.
+  /**
+   * Disconnect from all connected devices
+   */
+  disconnectAll() {
+    for (const device of this.devices.values()) {
+      device.networkDevice.disconnect();
+    }
+  }
 
-    let attempt = 1;
+  get databases() {
+    return this._databases;
+  }
 
+  async downloadFile(deviceId: string, path: string) {
+    const device = this.devices.get(deviceId);
+    const file = await device.fileTransferService.getFile(path);
+    return file;
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+
+  /**
+   * Waits for all devices to be connected with databases downloaded
+   * then connects to the StateMap.
+   */
+  private waitForAllDevices() {
+    Logger.log('Start watching for devices ...');
+    this.deviceWatchTimeout = setInterval(async () => {
+      // Check if any devices are still connecting.
+      const values = Array.from(this.discoveryStatus.values());
+      const foundDevices = values.length > 1;
+      const allConnected = !values.includes(ConnectionStatus.CONNECTING);
+
+      if (foundDevices && allConnected) {
+        Logger.log('All devices found!');
+        clearInterval(this.deviceWatchTimeout);
+        for (const cb of this.stateMapCallback) {
+          this.setupStateMap(cb.connectionInfo, cb.networkDevice);
+        }
+        this.emit('ready');
+      } else {
+        Logger.log(`Waiting for devices ...`);
+      }
+    }, WAIT_FOR_DEVICES_TIMEOUT_MS);
+  }
+
+  /**
+   * Attempt to connect to a device. Retry if necessary.
+   *
+   * @param connectionInfo Connection info
+   * @returns
+   */
+  private async connectToDevice(connectionInfo: ConnectionInfo) {
+    this.discoveryStatus.set(this.deviceId(connectionInfo), ConnectionStatus.CONNECTING);
+    let attempt = 1;
     while (attempt < this.options.maxRetries) {
       try {
         Logger.info(`Connecting to ${this.deviceId(connectionInfo)}. ` +
           `Attempt ${attempt}/${this.options.maxRetries}`);
-        // If this fails, catch it, and maybe retry if necessary.
-        await this.connectToPlayer(connectionInfo);
+        await this.downloadDatabase(connectionInfo);
         this.discoveryStatus.set(this.deviceId(connectionInfo), ConnectionStatus.CONNECTED);
-        this.emit('ready', connectionInfo);
+        this.emit('connected', connectionInfo);
         return; // Don't forget to return!
       } catch(e) {
 
@@ -84,49 +141,28 @@ export class StageLinqDevices extends EventEmitter {
           `(${attempt}/${this.options.maxRetries}): ${e}`);
         attempt += 1;
         sleep(500);
-
       }
     }
-
     // We failed 3 times. Throw exception.
     this.discoveryStatus.set(this.deviceId(connectionInfo), ConnectionStatus.FAILED);
     throw new Error(`Could not connect to ${this.deviceId(connectionInfo)}`);
   }
 
   /**
-   * Disconnect from all connected devices
-   */
-  disconnectAll() {
-    for (const device of this.devices.values()) {
-      device.networkDevice.disconnect();
-    }
-  }
-
-  get databases() {
-    return this._databases;
-  }
-
-  async downloadFile(ipAddress: string, path: string) {
-    const device = this.devices.get(ipAddress);
-    const file = await device.fileTransferService.getFile(path);
-    return file;
-  }
-
-  ////////////////////////////////////////////////////////////////////////////
-
-  /**
-   * Connect to the player.
-   * @param connectionInfo Device to connect to.
+   * Download databases from the device.
+   *
+   * @param connectionInfo Connection info
    * @returns
    */
-  private async connectToPlayer(connectionInfo: ConnectionInfo) {
+  private async downloadDatabase(connectionInfo: ConnectionInfo) {
     const networkDevice = new NetworkDevice(connectionInfo);
     await networkDevice.connect();
 
+    const sourceId = this.sourceId(connectionInfo);
     Logger.info(`Successfully connected to ${this.deviceId(connectionInfo)}`);
     const fileTransfer = await networkDevice.connectToService(FileTransfer);
 
-    this.devices.set(connectionInfo.address, {
+    this.devices.set(`net://${sourceId}`, {
       networkDevice: networkDevice,
       fileTransferService: fileTransfer
     });
@@ -136,7 +172,24 @@ export class StageLinqDevices extends EventEmitter {
       Logger.debug(`Database sources: ${sources.join(', ')}`);
     }
 
+    // Append to the list of states we need to setup later.
+    this.stateMapCallback.push({ connectionInfo, networkDevice });
+  }
+
+  private sourceId(connectionInfo: ConnectionInfo) {
+    return /(\w{8})(\w{4})(\w{4})(\w{4})(\w{12})/i
+      .exec(Buffer.from(connectionInfo.token).toString('hex')).splice(1).join('-');
+  }
+
+  /**
+   * Setup stateMap.
+   * @param connectionInfo Connection info
+   * @param networkDevice Network device
+   */
+  private async setupStateMap(connectionInfo: ConnectionInfo, networkDevice: NetworkDevice) {
     // Setup StateMap
+    Logger.debug(`Setting up stateMap for ${connectionInfo.address}`);
+
     const stateMap = await networkDevice.connectToService(StateMap);
     stateMap.on('message', (data) => {
       this.emit('message', connectionInfo, data)
@@ -146,7 +199,8 @@ export class StageLinqDevices extends EventEmitter {
     const player = new Player({
       stateMap: stateMap,
       address: connectionInfo.address,
-      port: connectionInfo.port
+      port: connectionInfo.port,
+      deviceId: this.sourceId(connectionInfo)
     });
 
     player.on('trackLoaded', (status) => {
@@ -160,9 +214,6 @@ export class StageLinqDevices extends EventEmitter {
     player.on('nowPlaying', (status) => {
       this.emit('nowPlaying', status);
     });
-
-    this.emit('connected', connectionInfo);
-
   }
 
   private deviceId(device: ConnectionInfo) {

package/network-path-prototype.patch

@@ -0,0 +1,181 @@
+diff --git a/Databases/Databases.ts b/Databases/Databases.ts
+index 10e0cba..4248e1e 100644
+--- a/Databases/Databases.ts
++++ b/Databases/Databases.ts
+@@ -25,7 +25,11 @@ export class Databases extends EventEmitter {
+     const sources = await service.getSources();
+     const output: string[] = [];
+     for (const source of sources) {
+-      const dbConnectionName = `${connectionInfo.address}_${connectionInfo.port}_${source.name}`;
++      const deviceId = /(\w{8})(\w{4})(\w{4})(\w{4})(\w{12})/i
++        .exec(Buffer.from(connectionInfo.token).toString('hex')).splice(1).join('-');
++
++      const dbConnectionName = `net://${deviceId}/${source.name}`;
++      Logger.debug(`DB network path: net://${deviceId}/${source.name}`)
+       if (this.sources.has(dbConnectionName)) {
+         Logger.debug(`Already seen ${source} on ${connectionInfo.address}:${connectionInfo.port}`);
+       } else {
+diff --git a/Databases/DbConnection.ts b/Databases/DbConnection.ts
+index 24ebd3a..6294024 100644
+--- a/Databases/DbConnection.ts
++++ b/Databases/DbConnection.ts
+@@ -20,7 +20,7 @@ export class DbConnection {
+    * @returns
+    */
+   querySource<T>(query: string, ...params: any[]): T[] {
+-    console.debug(`Querying ${this.dbPath}: `);
++    console.debug(`Querying ${this.dbPath}: ${query}`);
+     const result = this.db.prepare(query);
+     return result.all(params);
+   }
+@@ -32,7 +32,7 @@ export class DbConnection {
+    * @returns
+    */
+   getTrackInfo(trackPath: string) {
+-    return this.querySource(`SELECT * FROM Track WHERE path = '${trackPath}'`);
++    return this.querySource(`SELECT * FROM Track WHERE path = ?`, trackPath);
+   }
+ 
+   close() {
+diff --git a/cli/index.ts b/cli/index.ts
+index 8f532ca..5649037 100644
+--- a/cli/index.ts
++++ b/cli/index.ts
+@@ -96,7 +96,7 @@ require('console-stamp')(console, {
+     // Example of how to download the actual track from the media.
+     try {
+       const tempfile = path.resolve(os.tmpdir(), 'media');
+-      const data = await stageLinq.devices.downloadFile(status.address, status.trackPathAbsolute);
++      const data = await stageLinq.devices.downloadFile(status.deviceId, status.trackPathAbsolute);
+       if (data) {
+         fs.writeFileSync(tempfile, Buffer.from(data));
+         console.log(`Downloaded ${status.trackPathAbsolute} to ${tempfile}`);
+diff --git a/devices/Player.ts b/devices/Player.ts
+index 64f0db0..c6193ca 100644
+--- a/devices/Player.ts
++++ b/devices/Player.ts
+@@ -13,8 +13,9 @@ export declare interface Player {
+ 
+ interface PlayerOptions {
+   stateMap: StateMap;
+-  address: string,
++  address: string;
+   port: number;
++  deviceId: string;
+ }
+ 
+ interface SourceAndTrackPath {
+@@ -48,6 +49,7 @@ export class Player extends EventEmitter {
+   private masterStatus: boolean;    // If this device has the matser tempo
+   private decks: Map<string, PlayerLayerState> = new Map();
+   private queue: {[layer: string]: PlayerMessageQueue} = {};
++  private deviceId: string;
+ 
+   /**
+    * Initialize a player device.
+@@ -60,6 +62,8 @@ export class Player extends EventEmitter {
+     options.stateMap.on('message', this.messageHandler.bind(this));
+     this.address = options.address;
+     this.port = options.port;
++    this.deviceId = options.deviceId;
++
+     this.queue = {
+       A: new PlayerMessageQueue('A').onDataReady(this.handleUpdate.bind(this)),
+       B: new PlayerMessageQueue('B').onDataReady(this.handleUpdate.bind(this)),
+@@ -150,22 +154,27 @@ export class Player extends EventEmitter {
+       port: this.port,
+       masterTempo: this.masterTempo,
+       masterStatus: this.masterStatus,
++      deviceId: `net://${this.deviceId}`,
+       ...result
+     };
+ 
+     // We're casting here because we originally built it up piecemeal.
+     const currentState = output as PlayerStatus;
+ 
+-    if (/Unknown/.test(currentState.source)) {
++    if (currentState.trackNetworkPath && currentState.trackNetworkPath.startsWith('net:')) {
++      const pathParts = currentState.trackNetworkPath.split('net://')[1].split('/', 2)
++      currentState.dbSourceName = `net://${pathParts[0]}/${pathParts[1]}`;
++      currentState.deviceId = `net://${pathParts[0]}`;
++    } else if (!currentState.source || /Unknown/.test(currentState.source)) {
+       // Tracks from streaming sources won't be in the database.
+       currentState.dbSourceName = '';
+     } else {
+-      currentState.dbSourceName = currentState.source
+-        ? `${this.address}_${this.port}_${currentState.source}` : '';
++      currentState.dbSourceName = `net://${this.deviceId}/${currentState.source}`;
+     }
+ 
+     // If a song is loaded and we have a location emit the trackLoaded event.
+-    if (songLoadedSignalPresent && currentState.trackNetworkPath)
++    // 
++    if (/* songLoadedSignalPresent && */ currentState.trackNetworkPath)
+       this.emit('trackLoaded', currentState);
+ 
+     // If the song is actually playing emit the nowPlaying event.
+diff --git a/network/StageLinqDevices.ts b/network/StageLinqDevices.ts
+index 949619a..6bdce8b 100644
+--- a/network/StageLinqDevices.ts
++++ b/network/StageLinqDevices.ts
+@@ -106,8 +106,8 @@ export class StageLinqDevices extends EventEmitter {
+     return this._databases;
+   }
+ 
+-  async downloadFile(ipAddress: string, path: string) {
+-    const device = this.devices.get(ipAddress);
++  async downloadFile(deviceId: string, path: string) {
++    const device = this.devices.get(deviceId);
+     const file = await device.fileTransferService.getFile(path);
+     return file;
+   }
+@@ -123,10 +123,12 @@ export class StageLinqDevices extends EventEmitter {
+     const networkDevice = new NetworkDevice(connectionInfo);
+     await networkDevice.connect();
+ 
++    const deviceId = /(\w{8})(\w{4})(\w{4})(\w{4})(\w{12})/i
++      .exec(Buffer.from(connectionInfo.token).toString('hex')).splice(1).join('-');
+     Logger.info(`Successfully connected to ${this.deviceId(connectionInfo)}`);
+     const fileTransfer = await networkDevice.connectToService(FileTransfer);
+ 
+-    this.devices.set(connectionInfo.address, {
++    this.devices.set(`net://${deviceId}`, {
+       networkDevice: networkDevice,
+       fileTransferService: fileTransfer
+     });
+@@ -146,7 +148,8 @@ export class StageLinqDevices extends EventEmitter {
+     const player = new Player({
+       stateMap: stateMap,
+       address: connectionInfo.address,
+-      port: connectionInfo.port
++      port: connectionInfo.port,
++      deviceId
+     });
+ 
+     player.on('trackLoaded', (status) => {
+diff --git a/types/player.ts b/types/player.ts
+index f672c6d..188d36e 100644
+--- a/types/player.ts
++++ b/types/player.ts
+@@ -1,6 +1,7 @@
+ 
+ export interface PlayerStatus {
+   address: string;
++  deviceId: string;
+   artist: string;
+   currentBpm: number
+   deck: string;
+diff --git a/utils/getTempFilePath.ts b/utils/getTempFilePath.ts
+index c0d8bca..d737fe5 100644
+--- a/utils/getTempFilePath.ts
++++ b/utils/getTempFilePath.ts
+@@ -9,7 +9,8 @@ import * as path from 'path';
+  * @returns Absolute path
+  */
+ export function getTempFilePath(p_path: string) {
+-	const tmpPath = `/${os.tmpdir()}/localdb/${p_path}`;
++	const tmpPath = `/${os.tmpdir()}/localdb/${p_path}`
++		.replace('net://', '');
+ 	let paths = tmpPath.split(/[/\\]/).filter((e) => e.length > 0);
+ 	const isFolder = p_path.endsWith('/') || p_path.endsWith('\\');
+ 	let filename = '';

package/package.json

@@ -1,7 +1,8 @@
 {
 	"name": "stagelinq",
-	"version": "1.0.0",
+	"version": "1.0.4",
 	"description": "Typescript library to connect to Denon StageLinq devices",
+	"homepage": "https://github.com/chrisle/StageLinq",
 	"scripts": {
 		"test": "echo \"Error: no test specified\" && exit 1",
 		"start": "node dist/cli/index.js",

package/services/FileTransfer.ts

@@ -169,6 +169,12 @@ export class FileTransfer extends Service<FileTransferData> {
       this.receivedFile = new WriteContext({ size: txinfo.size });
 
       const totalChunks = Math.ceil(txinfo.size / CHUNK_SIZE);
+      const total = parseInt(txinfo.size);
+
+      if (total === 0) {
+        Logger.warn(`${p_location} doesn't exist or is a streaming file`);
+        return;
+      }
 
       await this.requestChunkRange(txinfo.txid, 0, totalChunks - 1);
 
@@ -179,7 +185,6 @@ export class FileTransfer extends Service<FileTransferData> {
           }, DOWNLOAD_TIMEOUT);
 
           while (this.receivedFile.isEOF() === false) {
-            const total = parseInt(txinfo.size);
             const bytesDownloaded = total - this.receivedFile.sizeLeft();
             const percentComplete = (bytesDownloaded / total) * 100;
             this.emit('fileTransferProgress', {

package/types/player.ts

@@ -4,6 +4,7 @@ export interface PlayerStatus {
   artist: string;
   currentBpm: number
   deck: string;
+  deviceId: string;
   externalMixerVolume: number;
   fileLocation: string;
   hasTrackData: boolean;
@@ -22,6 +23,7 @@ export interface PlayerStatus {
   source: string;
   dbSourceName: string;
   trackPath: string;
+  trackPathAbsolute: string;
 }
 
 export interface PlayerLayerState {

package/utils/getTempFilePath.ts

@@ -9,7 +9,7 @@ import * as path from 'path';
  * @returns Absolute path
  */
 export function getTempFilePath(p_path: string) {
-	const tmpPath = `/${os.tmpdir()}/localdb/${p_path}`;
+	const tmpPath = `/${os.tmpdir()}/localdb/${p_path}`.replace('net://', '');
 	let paths = tmpPath.split(/[/\\]/).filter((e) => e.length > 0);
 	const isFolder = p_path.endsWith('/') || p_path.endsWith('\\');
 	let filename = '';