stagelinq 1.0.4 → 1.0.7

package/Databases/Databases.ts

@@ -1,7 +1,7 @@
 import { ConnectionInfo, Source } from '../types';
 import { EventEmitter } from 'stream';
 import { FileTransfer } from '../services';
-import { getTempFilePath } from '../albumArt';
+import { getTempFilePath } from '../utils';
 import { Logger } from '../LogEmitter';
 import { NetworkDevice } from '../network';
 import * as fs from 'fs';
@@ -64,6 +64,9 @@ export class Databases extends EventEmitter {
   }
 
   getDbPath(dbSourceName?: string) {
+    if (!this.sources.size)
+      throw new Error(`No data sources have been downloaded`);
+
     if (!dbSourceName || !this.sources.has(dbSourceName)) {
 
       // Hack: Denon will save metadata on streaming files but only on an

package/Databases/DbConnection.ts

@@ -1,4 +1,5 @@
 import Database = require('better-sqlite3');
+import { Track } from '../types';
 
 
 export class DbConnection {
@@ -31,12 +32,15 @@ export class DbConnection {
    * @param trackPath Path of track on the source's filesystem.
    * @returns
    */
-  getTrackInfo(trackPath: string) {
+  getTrackInfo(trackPath: string): Track {
+    let result: Track[];
     if (/streaming:\/\//.test(trackPath)) {
-      return this.querySource('SELECT * FROM Track WHERE uri = (?)', trackPath);
+      result = this.querySource('SELECT * FROM Track WHERE uri = (?) LIMIT 1', trackPath);
     } else {
-      return this.querySource('SELECT * FROM Track WHERE path = (?)', trackPath);
+      result = this.querySource('SELECT * FROM Track WHERE path = (?) LIMIT 1', trackPath);
     }
+    if (!result) throw new Error(`Could not find track: ${trackPath} in database.`);
+    return result[0];
   }
 
   close() {

package/cli/index.ts

@@ -1,4 +1,4 @@
-import { ActingAsDevice } from '../types';
+import { ActingAsDevice, PlayerStatus } from '../types';
 import { DbConnection } from "../Databases";
 import { sleep } from '../utils/sleep';
 import { StageLinq } from '../StageLinq';
@@ -10,7 +10,46 @@ require('console-stamp')(console, {
   format: ':date(HH:MM:ss) :label',
 });
 
-(async () => {
+/**
+ * Get track information for latest playing song.
+ *
+ * @param stageLinq Instance of StageLinq.
+ * @param status Player to get track info from.
+ * @returns Track info
+ */
+function getTrackInfo(stageLinq: StageLinq, status: PlayerStatus) {
+  try {
+    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);
+    return result;
+  } catch(e) {
+    console.error(e);
+  }
+}
+
+/**
+ * Download the currently playing song from the media.
+ *
+ * @param stageLinq Instance of StageLinq.
+ * @param status Player to download the current song from.
+ * @param dest Path to save file to.
+ */
+async function downloadFile(stageLinq: StageLinq, status: PlayerStatus, dest: string) {
+  try {
+    const data = await stageLinq.devices.downloadFile(status.deviceId, status.trackPathAbsolute);
+    if (data) {
+      fs.writeFileSync(dest, Buffer.from(data));
+      console.log(`Downloaded ${status.trackPathAbsolute} to ${dest}`);
+    }
+  } catch(e) {
+    console.error(`Could not download ${status.trackPathAbsolute}`);
+  }
+}
+
+async function main() {
 
   console.log('Starting CLI');
 
@@ -18,7 +57,7 @@ require('console-stamp')(console, {
 
     // If set to true, download the source DBs in a temporary location.
     // (default: true)
-    downloadDbSources: true,
+    downloadDbSources: false,
 
     // Max number of attempts to connect to a StageLinq device.
     // (default: 3)
@@ -56,20 +95,23 @@ require('console-stamp')(console, {
   stageLinq.devices.on('connected', async (connectionInfo) => {
     console.log(`Successfully connected to ${connectionInfo.software.name}`);
 
-    // Fires when the database source starts downloading.
-    stageLinq.databases.on('dbDownloading', (sourceName, dbPath) => {
-      console.log(`Downloading ${sourceName} to ${dbPath}`);
-    });
-
-    // Fires while the database source is being read
-    stageLinq.databases.on('dbProgress', (sourceName, total, bytes, percent) => {
-      console.debug(`Reading ${sourceName}: ${bytes}/${total} (${Math.ceil(percent)}%)`);
-    });
+    if (stageLinq.options.downloadDbSources) {
+      // Fires when the database source starts downloading.
+      stageLinq.databases.on('dbDownloading', (sourceName, dbPath) => {
+        console.log(`Downloading ${sourceName} to ${dbPath}`);
+      });
+
+      // Fires while the database source is being read
+      stageLinq.databases.on('dbProgress', (sourceName, total, bytes, percent) => {
+        console.debug(`Reading ${sourceName}: ${bytes}/${total} (${Math.ceil(percent)}%)`);
+      });
+
+      // Fires when the database source has been read and saved to a temporary path.
+      stageLinq.databases.on('dbDownloaded', (sourceName, dbPath) => {
+        console.log(`Database (${sourceName}) has been downloaded to ${dbPath}`);
+      });
+    }
 
-    // Fires when the database source has been read and saved to a temporary path.
-    stageLinq.databases.on('dbDownloaded', (sourceName, dbPath) => {
-      console.log(`Database (${sourceName}) has been downloaded to ${dbPath}`);
-    });
   });
 
   // Fires when StageLinq and all devices are ready to use.
@@ -83,30 +125,11 @@ 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) {
-      try {
-        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);
-      } catch(e) {
-        console.error(e);
-      }
+      getTrackInfo(stageLinq, status);
     }
 
     // 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);
+    await downloadFile(stageLinq, status, path.resolve(os.tmpdir(), 'media'));
   });
 
   // Fires when a track has started playing.
@@ -125,9 +148,12 @@ require('console-stamp')(console, {
 
   // Fires when the state of a device has changed.
   stageLinq.devices.on('stateChanged', (status) => {
-    console.log(`State changed on [${status.deck}]`, status)
+    console.log(`Updating state [${status.deck}]`, status)
   });
 
+  /////////////////////////////////////////////////////////////////////////
+  // CLI
+
   let returnCode = 0;
   try {
     process.on('SIGINT', async function () {
@@ -156,4 +182,6 @@ require('console-stamp')(console, {
 
   await stageLinq.disconnect();
   process.exit(returnCode);
-})();
+}
+
+main();

package/devices/Player.ts

@@ -2,6 +2,7 @@ import { EventEmitter } from 'events';
 import { PlayerLayerState, PlayerStatus, ServiceMessage } from '../types';
 import { PlayerMessageQueue } from './PlayerMessageQueue';
 import { StateData, StateMap } from '../services';
+import { Logger } from '../LogEmitter';
 
 export declare interface Player {
   on(event: 'trackLoaded', listener: (status: PlayerStatus) => void): this;
@@ -48,6 +49,7 @@ export class Player extends EventEmitter {
   private masterTempo: number;      // Current master tempo BPM
   private masterStatus: boolean;    // If this device has the matser tempo
   private decks: Map<string, PlayerLayerState> = new Map();
+  private lastTrackNetworkPath: Map<string, string> = new Map();
   private queue: {[layer: string]: PlayerMessageQueue} = {};
   private deviceId: string;
 
@@ -132,13 +134,30 @@ export class Player extends EventEmitter {
    * @param data
    */
   private handleUpdate(data: PlayerLayerState) {
+    Logger.debug(`data: ${JSON.stringify(data, null, 2)}`);
+
     const layer = data.layer;
-    const songLoadedSignalPresent = data.hasOwnProperty('songLoaded');
+
+    // A new song my be loading onto a layer but not yet fully downloaded.
+    // For example streaming a song from Beatport Link.
+    let isNewTrack = true;
+    const lastTrackNetworkPath = this.lastTrackNetworkPath.get(layer);
+    if (lastTrackNetworkPath && data.trackNetworkPath) {
+      if (data.trackNetworkPath === lastTrackNetworkPath) {
+        isNewTrack = false;
+      }
+    }
+    this.lastTrackNetworkPath.set(layer, data.trackNetworkPath);
+
+    // This will be true once a song has been fully downloaded / loaded.
+    const isSongLoaded = data.hasOwnProperty('songLoaded');
 
     // If a new song is loaded drop all the previous track data.
-    if (songLoadedSignalPresent) {
+    if (isNewTrack && isSongLoaded) {
+      Logger.debug(`Replacing state ${layer}`);
       this.decks.set(layer, data);
     } else {
+      Logger.debug(`Updating state ${layer}`);
       this.decks.set(layer, { ...this.decks.get(layer), ...data });
     }
 
@@ -172,7 +191,7 @@ export class Player extends EventEmitter {
     }
 
     // If a song is loaded and we have a location emit the trackLoaded event.
-    if (currentState.trackNetworkPath)
+    if (isSongLoaded && currentState.trackNetworkPath)
       this.emit('trackLoaded', currentState);
 
     // If the song is actually playing emit the nowPlaying event.

package/devices/PlayerMessageQueue.ts

@@ -1,7 +1,8 @@
 import { PlayerLayerState } from '../types';
 
 // How long to wait for all the messages to come in before firing the callback.
-export const UPDATE_RATE_MS = 500;
+// It seems that anything less than 1 second is too fast.
+export const UPDATE_RATE_MS = 1500;
 
 export type DataQueueCallback = (data: PlayerLayerState) => void;
 

package/network/NetworkDevice.ts

@@ -81,13 +81,18 @@ export class NetworkDevice {
     const ctx = new ReadContext(p_message.buffer, false);
     while (ctx.isEOF() === false) {
       const id = ctx.readUInt32();
-      // FIXME: Verify token
-      ctx.seek(16); // Skip token; present in all messages
+      // const deviceToken = ctx.read(16);
+      ctx.seek(16);
       switch (id) {
         case MessageId.TimeStamp:
-          ctx.seek(16); // Skip token; present in all messages
+          ctx.seek(16);
+          // const secondToken = ctx.read(16); // should be 00..
+          // we _shouldn't_ be receiving anything but blank tokens in the 2nd field
+          // assert(secondToken.every((x) => x === 0));
+
           // Time Alive is in nanoseconds; convert back to seconds
           this.timeAlive = Number(ctx.readUInt64() / (1000n * 1000n * 1000n));
+          // this.sendTimeStampMsg(deviceToken, Tokens.SoundSwitch);
           break;
         case MessageId.ServicesAnnouncement:
           const service = ctx.readNetworkStringUTF16();
@@ -99,7 +104,6 @@ export class NetworkDevice {
           break;
         default:
           assert.fail(`NetworkDevice Unhandled message id '${id}'`);
-          break;
       }
     }
   }
@@ -284,4 +288,15 @@ export class NetworkDevice {
       }
     });
   }
+
+  // private async sendTimeStampMsg(deviceToken: Uint8Array, userToken: Uint8Array, timeAlive?: bigint) {
+  //   const ctx = new WriteContext();
+  //   ctx.writeUInt32(MessageId.TimeStamp);
+  //   ctx.write(deviceToken);
+  //   ctx.write(userToken);
+  //   const timeAliveNumber:bigint = (!!timeAlive) ? timeAlive : 0n;
+  //   ctx.writeUInt64(timeAliveNumber);
+  //   const written = await this.connection.write(ctx.getBuffer());
+  //   assert(written === ctx.tell());
+  // }
 }

package/network/StageLinqDevices.ts

@@ -29,8 +29,6 @@ export declare interface StageLinqDevices {
 
 //////////////////////////////////////////////////////////////////////////////
 
-// TODO: Refactor device, listener, and player into something more nicer.
-
 /**
  * Handle connecting and disconnecting from discovered devices on the
  * StageLinq network.
@@ -95,17 +93,39 @@ export class StageLinqDevices extends EventEmitter {
   /**
    * Waits for all devices to be connected with databases downloaded
    * then connects to the StateMap.
+   *
+   * Explained:
+   *
+   * Why wait for all devices? Because a race condition exists when using the
+   * database methods.
+   *
+   * If there are two SC6000 players on the network both will be sending
+   * broadcast packets and so their StateMap can be initialized at any time
+   * in any order.
+   *
+   * Assume you have player 1 and player 2 linked. Player 2 has a track that
+   * is loaded from a USB drive plugged into player 1. Player 2 will be
+   * ready before Player 1 because Player 1 will still be downloading a large
+   * database. The race condition is if you try to read from the database on
+   * the track that is plugged into Player 1 that isn't ready yet.
+   *
+   * This method prevents that by waiting for both players to connect and
+   * have their databases loaded before initializing 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 foundDevices = values.length >= 1;
       const allConnected = !values.includes(ConnectionStatus.CONNECTING);
+      const entries = Array.from(this.discoveryStatus.entries());
+      Logger.debug(`Waiting devices: ${JSON.stringify(entries)}`);
 
       if (foundDevices && allConnected) {
         Logger.log('All devices found!');
+        Logger.debug(`Devices found: ${values.length} ${JSON.stringify(entries)}`);
         clearInterval(this.deviceWatchTimeout);
         for (const cb of this.stateMapCallback) {
           this.setupStateMap(cb.connectionInfo, cb.networkDevice);
@@ -124,15 +144,42 @@ export class StageLinqDevices extends EventEmitter {
    * @returns
    */
   private async connectToDevice(connectionInfo: ConnectionInfo) {
+
+    // Mark this device as connecting.
     this.discoveryStatus.set(this.deviceId(connectionInfo), ConnectionStatus.CONNECTING);
+
     let attempt = 1;
     while (attempt < this.options.maxRetries) {
       try {
+
+        // Connect to the device.
         Logger.info(`Connecting to ${this.deviceId(connectionInfo)}. ` +
           `Attempt ${attempt}/${this.options.maxRetries}`);
-        await this.downloadDatabase(connectionInfo);
+        const networkDevice = new NetworkDevice(connectionInfo);
+        await networkDevice.connect();
+
+        // Setup file transfer service
+        await this.setupFileTransferService(networkDevice, connectionInfo);
+
+        // Download the database
+        if (this.options.downloadDbSources) {
+          await this.downloadDatabase(networkDevice, connectionInfo);
+        }
+
+        // Setup other services that should be initialized before StateMap here.
+
+        // StateMap will be initialized after all devices have completed
+        // this method. In other words, StateMap will initialize
+        // after all entries in this.discoveryStatus return
+        // ConnectionStatus.CONNECTED
+
+        // Append to the list of states we need to setup later.
+        this.stateMapCallback.push({ connectionInfo, networkDevice });
+
+        // Mark this device as connected.
         this.discoveryStatus.set(this.deviceId(connectionInfo), ConnectionStatus.CONNECTED);
         this.emit('connected', connectionInfo);
+
         return; // Don't forget to return!
       } catch(e) {
 
@@ -148,32 +195,27 @@ export class StageLinqDevices extends EventEmitter {
     throw new Error(`Could not connect to ${this.deviceId(connectionInfo)}`);
   }
 
-  /**
-   * Download databases from the device.
-   *
-   * @param connectionInfo Connection info
-   * @returns
-   */
-  private async downloadDatabase(connectionInfo: ConnectionInfo) {
-    const networkDevice = new NetworkDevice(connectionInfo);
-    await networkDevice.connect();
-
+  private async setupFileTransferService(networkDevice: NetworkDevice, connectionInfo: ConnectionInfo) {
     const sourceId = this.sourceId(connectionInfo);
-    Logger.info(`Successfully connected to ${this.deviceId(connectionInfo)}`);
+    Logger.info(`Starting file transfer for ${this.deviceId(connectionInfo)}`);
     const fileTransfer = await networkDevice.connectToService(FileTransfer);
 
     this.devices.set(`net://${sourceId}`, {
       networkDevice: networkDevice,
       fileTransferService: fileTransfer
     });
+  }
 
-    if (this.options.downloadDbSources) {
-      const sources = await this.databases.downloadSourcesFromDevice(connectionInfo, networkDevice);
-      Logger.debug(`Database sources: ${sources.join(', ')}`);
-    }
-
-    // Append to the list of states we need to setup later.
-    this.stateMapCallback.push({ connectionInfo, networkDevice });
+  /**
+   * Download databases from the device.
+   *
+   * @param connectionInfo Connection info
+   * @returns
+   */
+  private async downloadDatabase(networkDevice: NetworkDevice, connectionInfo: ConnectionInfo) {
+    const sources = await this.databases.downloadSourcesFromDevice(connectionInfo, networkDevice);
+    Logger.debug(`Database sources: ${sources.join(', ')}`);
+    Logger.debug(`Database download complete for ${connectionInfo.source}`);
   }
 
   private sourceId(connectionInfo: ConnectionInfo) {
@@ -183,6 +225,7 @@ export class StageLinqDevices extends EventEmitter {
 
   /**
    * Setup stateMap.
+   *
    * @param connectionInfo Connection info
    * @param networkDevice Network device
    */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "stagelinq",
-	"version": "1.0.4",
+	"version": "1.0.7",
 	"description": "Typescript library to connect to Denon StageLinq devices",
 	"homepage": "https://github.com/chrisle/StageLinq",
 	"scripts": {

package/types/index.ts

@@ -1,9 +1,9 @@
 import { DiscoveryMessageOptions } from '../network';
 
 export * from './common';
-export * from './database';
 export * from './player';
 export * from './tokens';
+export * from './models';
 
 export interface DiscoveryMessage {
 	token: Uint8Array;

package/types/models/index.ts

@@ -0,0 +1 @@
+export * from './track';

package/utils/index.ts

@@ -1,4 +1,5 @@
 export * from './Context';
+export * from './getTempFilePath';
 export * from './hex';
 export * from './ReadContext';
 export * from './sleep';

package/albumArt/index.ts

@@ -1,2 +0,0 @@
-export * from '../utils/getTempFilePath';
-export * from './maybeDownloadFiles';

package/albumArt/maybeDownloadFiles.ts

@@ -1,34 +0,0 @@
-import { NetworkDevice } from '../network';
-import { FileTransfer } from '../services';
-import { getTempFilePath } from "../utils/getTempFilePath";
-import { strict as assert } from 'assert';
-import * as fs from 'fs';
-import minimist = require('minimist');
-import { Logger } from '../LogEmitter';
-
-export async function maybeDownloadFiles(controller: NetworkDevice) {
-	const args = minimist(process.argv.slice(2));
-	if (!args.disableFileTransfer) {
-		const ftx = await controller.connectToService(FileTransfer);
-		assert(ftx);
-		const sources = await ftx.getSources();
-		{
-			const sync = !args.skipsync;
-			for (const source of sources) {
-				const dbPath = getTempFilePath(source.database.location);
-				// FIXME: Move all this away from main
-				if (sync) {
-					const file = await ftx.getFile(source.database.location);
-					fs.writeFileSync(dbPath, file);
-					Logger.info(`downloaded: '${source.database.location}' and stored in '${dbPath}'`);
-				}
-				await controller.addSource(source.name, dbPath, getTempFilePath(`${source.name}/Album Art/`));
-
-				if (sync) {
-					await controller.dumpAlbumArt(source.name);
-				}
-			}
-			ftx.disconnect();
-		}
-	}
-}