@jellybrick/mpris-service 2.1.3

package/src/interfaces/player.js

@@ -0,0 +1,201 @@
+const dbus = require('dbus-next');
+const MprisInterface = require('./mpris-interface');
+const Variant = dbus.Variant;
+const constants = require('../constants');
+
+let {
+  property, method, signal, DBusError,
+  ACCESS_READ, ACCESS_WRITE, ACCESS_READWRITE
+} = dbus.interface;
+
+class PlayerInterface extends MprisInterface {
+  constructor(player) {
+    super('org.mpris.MediaPlayer2.Player', player);
+  }
+
+  _CanControl = true;
+  _CanPause = true;
+  _CanPlay = true;
+  _CanSeek = true;
+  _CanGoNext = true;
+  _CanGoPrevious = true;
+  _Metadata = {};
+  _MaximumRate = 1;
+  _MinimumRate = 1;
+  _Rate = 1;
+  _Shuffle = false;
+  _Volume = 0;
+  _LoopStatus = constants.LOOP_STATUS_NONE;
+  _PlaybackStatus = constants.PLAYBACK_STATUS_STOPPED;
+
+  @property({signature: 'b', access: ACCESS_READ})
+  get CanControl() {
+    return this._CanControl;
+  }
+
+  @property({signature: 'b', access: ACCESS_READ})
+  get CanPause() {
+    return this._CanPause;
+  }
+
+  @property({signature: 'b', access: ACCESS_READ})
+  get CanPlay() {
+    return this._CanPlay;
+  }
+
+  @property({signature: 'b', access: ACCESS_READ})
+  get CanSeek() {
+    return this._CanSeek;
+  }
+
+  @property({signature: 'b', access: ACCESS_READ})
+  get CanGoNext() {
+    return this._CanGoNext;
+  }
+
+  @property({signature: 'b', access: ACCESS_READ})
+  get CanGoPrevious() {
+    return this._CanGoPrevious;
+  }
+
+  @property({signature: 'a{sv}', access: ACCESS_READ})
+  get Metadata() {
+    return this._Metadata;
+  }
+
+  @property({signature: 'd', access: ACCESS_READ})
+  get MaximumRate() {
+    return this._MaximumRate;
+  }
+
+  @property({signature: 'd', access: ACCESS_READ})
+  get MinimumRate() {
+    return this._MinimumRate;
+  }
+
+  @property({signature: 'd'})
+  get Rate() {
+    return this._Rate;
+  }
+  set Rate(value) {
+    this._setPropertyInternal('Rate', value);
+  }
+
+  @property({signature: 'b'})
+  get Shuffle() {
+    return this._Shuffle;
+  }
+  set Shuffle(value) {
+    this._setPropertyInternal('Shuffle', value);
+  }
+
+  @property({signature: 'd'})
+  get Volume() {
+    return this._Volume;
+  }
+  set Volume(value) {
+    this._setPropertyInternal('Volume', value);
+  }
+
+  @property({signature: 'x', access: ACCESS_READ})
+  get Position() {
+    let playerPosition = this.player.getPosition();
+    let position = Math.floor(playerPosition || 0);
+    if (isNaN(position)) {
+      const err = 'github.mpris_service.InvalidPositionError';
+      const message = `The player has set an invalid position: ${playerPosition}`;
+      throw new DBusError(err, message);
+    }
+    return position;
+  }
+
+  @property({signature: 's'})
+  get LoopStatus() {
+    if (!constants.isLoopStatusValid(this._LoopStatus)) {
+      const err = 'github.mpris_service.InvalidLoopStatusError';
+      const message = `The player has set an invalid loop status: ${this._LoopStatus}`;
+      throw new DBusError(err, message);
+    }
+
+    return this._LoopStatus;
+  }
+  set LoopStatus(value) {
+    if (!constants.isLoopStatusValid(value)) {
+      const err = 'github.mpris_service.InvalidLoopStatusError';
+      const message = `Tried to set loop status to an invalid value: ${value}`;
+      throw new DBusError(err, message);
+    }
+    this._setPropertyInternal('LoopStatus', value);
+  }
+
+  @property({signature: 's', access: ACCESS_READ})
+  get PlaybackStatus() {
+    if (!constants.isPlaybackStatusValid(this._PlaybackStatus)) {
+      const err = 'github.mpris_service.InvalidPlaybackStatusError';
+      const message = `The player has set an invalid playback status: ${this._PlaybackStatus}`;
+      throw new DBusError(err, message);
+    }
+
+    return this._PlaybackStatus;
+  }
+
+  @method({})
+  Next() {
+    this.player.emit('next');
+  }
+
+  @method({})
+  Previous() {
+    this.player.emit('previous');
+  }
+
+  @method({})
+  Pause() {
+    this.player.emit('pause');
+  }
+
+  @method({})
+  PlayPause() {
+    this.player.emit('playpause');
+  }
+
+  @method({})
+  Stop() {
+    this.player.emit('stop');
+  }
+
+  @method({})
+  Play() {
+    this.player.emit('play');
+  }
+
+  @method({inSignature: 'x'})
+  Seek(offset) {
+    // XXX overflow
+    offset = Number(offset);
+    this.player.emit('seek', offset);
+  }
+
+  @method({inSignature: 'ox'})
+  SetPosition(trackId, position) {
+    let e = {
+      trackId: trackId,
+      // XXX overflow
+      position: Number(position)
+    };
+    this.player.emit('position', e);
+  }
+
+  @method({inSignature: 's'})
+  OpenUri(uri) {
+    let e = { uri };
+    this.player.emit('open', e);
+  }
+
+  @signal({signature: 'x'})
+  Seeked(position) {
+    return position;
+  }
+}
+
+module.exports = PlayerInterface;

package/src/interfaces/playlists.js

@@ -0,0 +1,82 @@
+// TODO proper import
+let MprisInterface = require('./mpris-interface');
+let dbus = require('dbus-next');
+let Variant = dbus.Variant;
+let types = require('./types');
+
+let {
+  property, method, signal, DBusError,
+  ACCESS_READ, ACCESS_WRITE, ACCESS_READWRITE
+} = dbus.interface;
+
+class PlaylistsInterface extends MprisInterface {
+  constructor(player) {
+    super('org.mpris.MediaPlayer2.Playlists', player);
+  }
+
+  _ActivePlaylist = [ false, types.emptyPlaylist ];
+  _PlaylistCount = 0;
+
+  @property({signature: 'u', access: ACCESS_READ})
+  get PlaylistCount() {
+    return this._PlaylistCount;
+  }
+
+  @property({signature: 'as', access: ACCESS_READ})
+  get Orderings() {
+    return ['Alphabetical', 'UserDefined'];
+  }
+
+  @property({signature: '(b(oss))', access: ACCESS_READ})
+  get ActivePlaylist() {
+    return this._ActivePlaylist;
+  }
+
+  setActivePlaylistId(playlistId) {
+    let i = this.player.getPlaylistIndex(playlistId);
+
+    this.setProperty('ActivePlaylist', this.player.playlists[i] || null);
+  }
+
+  @method({inSignature: 'o'})
+  ActivatePlaylist(playlistId) {
+    this.player.emit('activatePlaylist', playlistId);
+  }
+
+  @method({inSignature: 'uusb', outSignature: 'a(oss)'})
+  GetPlaylists(index, maxCount, order, reverseOrder) {
+    if (!this.player.playlists) {
+      return [];
+    }
+
+    let result = this.player.playlists.sort(function(a, b) {
+        let ret = 1;
+        switch (order) {
+          case 'Alphabetical':
+            ret = (a.Name > b.Name) ? 1 : -1;
+            break;
+            //case 'CreationDate':
+            //case 'ModifiedDate':
+            //case 'LastPlayDate':
+          case 'UserDefined':
+            break;
+        }
+        return ret;
+      })
+      .slice(index, maxCount + index)
+      .map(types.playlistToDbus);
+
+    if (reverseOrder) {
+      result.reverse();
+    }
+
+    return result;
+  }
+
+  @signal({signature: '(oss)'})
+  PlaylistChanged(playlist) {
+    return types.playlistToDbus(playlist);
+  }
+}
+
+module.exports = PlaylistsInterface;

package/src/interfaces/root.js

@@ -0,0 +1,98 @@
+let MprisInterface = require('./mpris-interface');
+let dbus = require('dbus-next');
+let Variant = dbus.Variant;
+
+let {
+  property, method, signal, DBusError,
+  ACCESS_READ, ACCESS_WRITE, ACCESS_READWRITE
+} = dbus.interface;
+
+class RootInterface extends MprisInterface {
+  constructor(player, opts={}) {
+    super('org.mpris.MediaPlayer2', player);
+
+    if (opts.hasOwnProperty('identity')) {
+      this._Identity = opts.identity;
+    }
+    if (opts.hasOwnProperty('supportedUriSchemes')) {
+      this._SupportedUriSchemes = opts.supportedUriSchemes;
+    }
+    if (opts.hasOwnProperty('supportedMimeTypes')) {
+      this._SupportedMimeTypes = opts.supportedMimeTypes;
+    }
+    if (opts.hasOwnProperty('desktopEntry')) {
+      this._DesktopEntry = opts.desktopEntry;
+    }
+  }
+
+  _CanQuit = true;
+  _Fullscreen = false;
+  _CanSetFullscreen = false;
+  _CanRaise = true;
+  _HasTrackList = false;
+  _Identity = '';
+  // TODO optional properties
+  _DesktopEntry = '';
+  _SupportedUriSchemes = [];
+  _SupportedMimeTypes = [];
+
+  @property({signature: 'b', access: ACCESS_READ})
+  get CanQuit() {
+    return this._CanQuit;
+  }
+
+  @property({signature: 'b'})
+  get Fullscreen() {
+    return this._Fullscreen;
+  }
+  set Fullscreen(value) {
+    this._setPropertyInternal('Fullscreen', value);
+  }
+
+  @property({signature: 'b', access: ACCESS_READ})
+  get CanSetFullscreen() {
+    return this._CanSetFullscreen;
+  }
+
+  @property({signature: 'b', access: ACCESS_READ})
+  get CanRaise() {
+    return this._CanRaise;
+  }
+
+  @property({signature: 'b', access: ACCESS_READ})
+  get HasTrackList() {
+    return this._HasTrackList;
+  }
+
+  @property({signature: 's', access: ACCESS_READ})
+  get Identity() {
+    return this._Identity;
+  }
+
+  @property({signature: 's', access: ACCESS_READ})
+  get DesktopEntry() {
+    return this._DesktopEntry;
+  }
+
+  @property({signature: 'as', access: ACCESS_READ})
+  get SupportedUriSchemes() {
+    return this._SupportedUriSchemes;
+  }
+
+  @property({signature: 'as', access: ACCESS_READ})
+  get SupportedMimeTypes() {
+    return this._SupportedMimeTypes;
+  }
+
+  @method({})
+  Raise() {
+    this.player.emit('raise');
+  }
+
+  @method({})
+  Quit() {
+    this.player.emit('quit');
+  }
+}
+
+module.exports = RootInterface;

package/src/interfaces/tracklist.js

@@ -0,0 +1,84 @@
+let MprisInterface = require('./mpris-interface');
+let dbus = require('dbus-next');
+let Variant = dbus.Variant;
+let types = require('./types');
+
+let {
+  property, method, signal, DBusError,
+  ACCESS_READ, ACCESS_WRITE, ACCESS_READWRITE
+} = dbus.interface;
+
+class TracklistInterface extends MprisInterface {
+  constructor(player) {
+    super('org.mpris.MediaPlayer2.TrackList', player);
+  }
+
+  _Tracks = [];
+  _CanEditTracks = false;
+
+  setTracks(tracksPlain) {
+    this.setProperty('Tracks', tracksPlain);
+  }
+
+  @property({signature: 'ao', access: ACCESS_READ})
+  get Tracks() {
+    return this._Tracks;
+  }
+
+  @property({signature: 'b', access: ACCESS_READ})
+  get CanEditTracks() {
+    return this._CanEditTracks;
+  }
+
+  @method({inSignature: 'ao', outSignature: 'aa{sv}'})
+  GetTracksMetadata(trackIds) {
+    return this.player.tracks.filter((t) => {
+      return trackIds.some((id) => id === t['mpris:trackid']);
+    }).map(types.metadataToDbus);
+  }
+
+  @method({inSignature: 'sob'})
+  AddTrack(uri, afterTrack, setAsCurrent) {
+    this.player.emit('addTrack', { uri, afterTrack, setAsCurrent });
+  }
+
+  @method({inSignature: 'o'})
+  RemoveTrack(trackId) {
+    this.player.emit('removeTrack', trackId);
+  }
+
+  @method({inSignature: 'o'})
+  GoTo(trackId) {
+    this.player.emit('goTo', trackId);
+  }
+
+  @signal({signature: 'aoo'})
+  TrackListReplaced(replacedPlain) {
+    this.setTracks(replacedPlain);
+    // TODO what's the active track?
+    return [
+      this._Tracks,
+      '/org/mpris/MediaPlayer2/TrackList/NoTrack'
+    ];
+  }
+
+  @signal({signature: 'a{sv}'})
+  TrackAdded(metadata) {
+    return types.metadataToDbus(metadata);
+  }
+
+  @signal({signature: 'o'})
+  TrackRemoved(path) {
+    return path;
+  }
+
+  @signal({signature: 'oa{sv}'})
+  TrackMetadataChanged(path, metadata){ 
+    return [
+      path,
+      types.metadataToDbus(metadata)
+    ];
+  }
+}
+
+module.exports = TracklistInterface;

package/src/interfaces/types.js

@@ -0,0 +1,75 @@
+let Variant = require('dbus-next').Variant;
+let logging = require('../logging');
+
+function guessMetadataSignature(key, value) {
+  if (key === 'mpris:trackid') {
+    return 'o';
+  } else if (key === 'mpris:length') {
+    return 'x';
+  } else if (typeof value === 'string') {
+    return 's';
+  } else if (typeof value === 'boolean') {
+    return 'b';
+  } else if (typeof value === 'number') {
+    return 'd';
+  } else if (Array.isArray(value) && value.every((v) => typeof v === 'string')) {
+    return 'as';
+  } else {
+    // type not supported yet
+    logging.warn(`could not determine metadata type for ${key}: ${value}`);
+    return null;
+  }
+}
+
+function metadataToPlain(metadataVariant) {
+  let metadataPlain = {};
+  for (let k of Object.keys(metadataVariant)) {
+    let value = metadataVariant[k];
+    if (value === undefined || value === null) {
+      logging.warn(`ignoring a null metadata value for key ${k}`);
+      continue;
+    }
+    if (value.constructor === Variant) {
+      metadataPlain[k] = value.value;
+    } else {
+      metadataPlain[k] = value;
+    }
+  }
+  return metadataPlain;
+}
+
+function metadataToDbus(metadataPlain) {
+  let metadataVariant = {};
+  for (let k of Object.keys(metadataPlain)) {
+    let value = metadataPlain[k];
+    let signature = guessMetadataSignature(k, value);
+    if (signature) {
+      metadataVariant[k] = new Variant(signature, value);
+    }
+  }
+  return metadataVariant;
+}
+
+let emptyPlaylist = ['/', '', ''];
+
+function playlistToDbus(playlist) {
+  if (!playlist) {
+    return emptyPlaylist;
+  }
+
+  let { Id, Name, Icon } = playlist;
+  return [ Id, Name, Icon ];
+}
+
+function playlistToPlain(wire) {
+  let [ Id, Name, Icon ] = wire;
+  return { Id, Name, Icon };
+}
+
+module.exports = {
+  metadataToPlain,
+  metadataToDbus,
+  playlistToPlain,
+  playlistToDbus,
+  emptyPlaylist
+};

package/src/logging.js

@@ -0,0 +1,13 @@
+let loggingEnabled = (process.env.MPRIS_SERVICE_DEBUG !== undefined && process.env.MPRIS_SERVICE_DEBUG !== '0');
+
+module.exports.debug = function(message) {
+  if (loggingEnabled) {
+    console.log(message);
+  }
+};
+
+module.exports.warn = function(message) {
+  if (loggingEnabled) {
+    console.warn(message);
+  }
+};