A Way to Query a Running Instance of Musikcube for Now Playing Info

[A-Neal]

I would attempt this myself and submit it, but my C++ knowledge only extends as far as Arduino and the Arduino libraries. I'd like to be able to grab this info using a shell command so I could put it in my status bar (i3 Blocks). It could be as simple as writing the info to some file in /var that can then be read with built-in shell commands. Much like how the Linux kernel puts all kinds of system info into files that can be read like any text file.

[PythonTryHard]

Afaik, musikcube comes with a server for streaming and metadata, and you can query for now playing using this API endpoint.

Though, I suspect the websocket way might be a better deal since it's the server pushing updates, rather than polling rapidly

[A-Neal]

Oh, and this can be used to retrieve information from a local instance of Musikcube without using it as a fully fledged music server? If it uses standard HTTP like it says, I could do this easily. I just thought that to use the web API, you had to be running it as a complete streaming server. I'll look through it and see if I can do it.

So I looked through it, and I can do just what I asked if I can figure out how to write a simple websocket listener that updates a file in the RAM (/tmp directory) upon every message received that includes song metadata tags. Guess I got RTM'd, but you can't blame me for thinking the web API was for remote streaming only. Thanks for pointing me in the right direction.

[clangen]

Yeah, you should be able to connect to any running musikcube instance via websocket with any (language/runtime you want) to query metadata (and also control playback, if you want). It's relatively straight-forward -- you connect, send an authentication message, then you can issue database queries per the docs. The provided functionality is relatively rich and is what is used by the Android client (and also used by the "remote library" functionality in the TUI app).

As a side note, the original, very old version of musikcube used to have an option to write the currently playing metadata to a text file at the location of your choosing... some people would just do that, then setup some sort of script to poll the file every few seconds to pick up changes. I wonder if that'd be a useful feature for future versions?

[clangen]

I just remembered that a while back I was working on a little Javascript WebSocket demo that never saw the light of day. Here's an example websocket client written with node with just a few dependencies:

import _ from 'lodash';
import ReconnectingWebSocket from 'reconnecting-websocket';
import WebSocket from 'ws';
import { EventEmitter } from 'node:events';

const DEFAULT_TIMEOUT_MS = 7500;

let socket;
let messageId = 0;
const deviceId = String(Math.random());
let reconnect = false;
const pending = {};

export const events = new EventEmitter();

export const eventType = {
  connect: 'connect',
  disconnect: 'disconnect',
  message: 'message',
  error: 'error',
};

export const messageType = {
  request: 'request',
  response: 'response',
  broadcast: 'broadcast',
  timeout: 'timeout',
};

const connected = () => socket && socket.readyState === socket.OPEN;

const disconnected = () =>
  socket &&
  (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING);

const onConnected = () => {
  events.emit(eventType.connect);
};

const onDisconnected = (event) => {
  if (!reconnect && socket) {
    const oldSocket = socket;
    _.defer(() => close(oldSocket));
  }

  if (socket) {
    reconnect = false;
    events.emit(eventType.disconnect, event);
  }

  socket = null;
};

const onError = (event) => {
  events.emit(eventType.error, event);
};

const onMessageReceived = (event) => {
  const message = Object.freeze(JSON.parse(event.data));
  const context = pending[message.id];

  if (
    message.type === messageType.response &&
    message.name === 'authenticate'
  ) {
    reconnect = true;
    onConnected();
  } else {
    if (message.type === messageType.broadcast) {
      notify(message);
    } else if (message.type === messageType.response) {
      const callback = context && context.callback;
      notify(message, callback);
    }
  }

  if (context) {
    forget(context);
  }
};

const onTimeout = (messageId) => {
  const context = pending[messageId];
  if (context) {
    fail(context);
    forget(context);
  }
};

const notify = (message, callback) => {
  callback && callback(message);
  events.emit(eventType.message, message);
};

const fail = (context, errorType) => {
  const message = _.cloneDeep(context.message);
  message.type = errorType || messageType.timeout;
  notify(Object.freeze(message), context.callback);
};

const forget = (context) => {
  clearTimeout(context.timeoutId);
  delete pending[context.message.id];
};

const close = (instance) => {
  instance = instance || socket;
  if (socket) {
    instance.close(1000, '', { keepClosed: true });
  }
};

const connect = (host, port, password) => {
  disconnect();

  socket = new ReconnectingWebSocket(`ws://${host}:${port}`, [], { WebSocket });

  socket.onopen = () => {
    request('authenticate', { password });
  };

  socket.onclose = onDisconnected;
  socket.onmessage = onMessageReceived;
  socket.onerror = onError;
};

const disconnect = () => {
  close(socket);
  socket = null;
};

const request = (name, options, callback, timeout) => {
  if (connected()) {
    if (_.isFunction(options)) {
      /* if no options are specified, shift arguments left one */
      timeout = callback;
      callback = options;
      options = {};
    }

    const id = `musikcube-react-${messageId++}`;

    const message = Object.freeze({
      name,
      type: messageType.request,
      id,
      device_id: deviceId,
      options: options || {},
    });

    const context = { callback, message };
    pending[id] = context;

    timeout = _.isNumber(timeout) ? timeout : DEFAULT_TIMEOUT_MS;

    if (timeout > 0) {
      context.timeoutId = setTimeout(() => {
        onTimeout(id);
      }, timeout);
    }

    socket.send(JSON.stringify(message));

    return id;
  }
};

const broadcast = (name, options) => {
  if (connected()) {
    socket.send(
      JSON.stringify({
        type: messageType.broadcast,
        id: `musikcube-react-${messageId++}`,
        device_id: deviceId,
        options: options || {},
      })
    );
  }
};

const respond = (message, options) => {
  if (connected()) {
    const response = _.deepClone(message);
    response.options = options;
    socket.send(JSON.stringify(response));
  }
};

const cancel = (messageId) => {
  if (pending[messageId]) {
    forget(pending[messageId]);
  }
};

export default {
  connect,
  connected,
  disconnected,
  disconnect,
  request,
  cancel,
  respond,
  broadcast,
  events,
};

You can then use it as follows:

import mcws from './musikcube-websocket.js';

/* upon connecting, query current playback information */
mcws.events.addListener('connect', () => {
  mcws.request('get_playback_overview', {}, (overview) => {
    console.log(overview);
  });
});

/* as music plays and tracks and state changes, overview updated 
messages will be sent automatically to connected clients. you can
catch them all like this... */
mcws.events.addListener('message', (message) => {
  if (message.name === 'playback_overview_changed') {
    console.log(message);
  }
});

mcws.connect('192.168.1.221', 7905, 'yourpasswordhere');

Using the example above, upon connecting to the server you should see the following output:

~/s/musikcube-wsjs > node index.js
{
  id: 'musikcube-react-1',
  name: 'get_playback_overview',
  options: {
    muted: false,
    play_queue_position: 3,
    playing_current_time: 1,
    playing_duration: 235.885714,
    playing_track: {
      album: `"Let's Rock"`,
      album_artist: 'The Black Keys',
      album_artist_id: 17151,
      album_id: 2454450698,
      artist: 'The Black Keys',
      artist_id: 17151,
      external_id: 'local-917040129-850452493',
      genre: 'Alternative Rock',
      genre_id: 29,
      id: 76188,
      thumbnail_id: 800,
      title: 'Walk Across The Water',
      track: 4
    },
    repeat_mode: 'none',
    shuffled: false,
    state: 'paused',
    track_count: 12,
    volume: 1
  },
  type: 'response'
}

[A-Neal]

Cool, thanks for this! When I asked the question, I didn't know that Musikcube was set up to run a metadata server side-by-side with local playback. I will definitely reference your Node demo, as I'm already familiar with JS and Node.

Also, that feature that writes now-playing info to a file would be great to have back in new versions. Maybe it could be implemented as a plugin that uses the existing web socket API? Again, I'd like to be able to contribute, but my C++ knowledge is very limited.

[A-Neal]

I've just written this Node program, boiled down to what I need it to do and display and no more. It's designed to be ran at the same time as Musikcube, via an alias that runs it in the background (after a short delay) when Musikcube is called. It exits when the socket is closed. It's specifically designed for use with i3blocks. Sorry if there's no syntax highlighting; it wouldn't let me upload a file with a .js extension.

It depends only on the ws npm package.

It may be a useful starting point for anybody else looking to do a similar thing in as simple a way as possible.

#!/usr/bin/node

const cproc = require('child_process');
const fs = require('fs');
const ws = require('ws');

const tFilePath = "/tmp/musikcube_ws_listener";

const s = new ws.WebSocket('ws://127.0.0.1:7905');

s.on('error', function(error) {
        console.log(error.code);
        return 1;
});

s.on('close', function() {
        updateNotifier(null);
});
s.on('message', function(data) {
        updateNotifier(data);
});

function updateNotifier(inp) {
        if (!inp) {
                fs.writeFileSync(tFilePath, '');
                cproc.exec("pkill -SIGRTMIN+2 i3blocks");
                return;
        }
        let md = JSON.parse(inp.toString());
        if (!md.options) return;
        let state = md.options.state;
        let iState;
        let info = md.options.playing_track;
        let artist = info.artist;
        let aArtist = info.album_artist;
        let title = info.title;
        switch (state) {
                case "paused":
                        iState = "\u23f8";
                        break;
                case "playing":
                        iState = "\u23f5";
                        break;
                default:
                        iState = state;
        }
        let msg = `${iState} ${artist}: ${title}`;
        let out = {
                full_text: msg,
                short_text: msg,
                color: "#cccccc"
        };
        //console.log(out);
        fs.writeFileSync(tFilePath, JSON.stringify(out)+"\n");
        cproc.exec("pkill -SIGRTMIN+2 i3blocks", function(stdout) {
                //console.log(stdout);
        });
        return;
}

This is the i3blocks block config that is called when the Node program fires SIGRTMIN+2:

[i3musikcubeNP]
command=cat /tmp/musikcube_ws_listener
interval=0
format=json
signal=2

This is the alias I have set up in my .bashrc file to run the Node program; not sure if it's the best way to do it, but it works:

alias musikcube="(sleep .5; $HOME/.nodejs/musikcube_ws_listener/main.js > /dev/null) & musikcube"

[A-Neal]

@clangen Mentioned because I didn't know if you'd get a notification if I didn't directly reply to or mention you. Still new to using Github for more than simply downloading others' work.