class

MPD::Client

Inherits Reference < Object

An MPD Client.

One-shot usage

require "crystal_mpd"

mpd = MPD::Client.new("localhost", 6600)
puts mpd.version
puts mpd.status
puts mpd.stats
mpd.disconnect

Constants

ERROR_PREFIX = "ACK "
HELLO_PREFIX = "OK MPD "
NEXT = "list_OK\n"
SUCCESS = "OK\n"

Constructors

new(host : String = "localhost", port : Int32 = 6600, *, with_callbacks : Bool = false, reconnect_policy : ReconnectPolicy = ReconnectPolicy::Never, password : String | Nil = nil)

Creates a new MPD client. Parses the host, port.

This constructor will raise an exception if could not connect to MPD

Source

Instance methods

add(uri : String, position : Int32 | String | Nil = nil)

Adds the file uri to the playlist (directories add recursively).

uri can also be a single file.

The position parameter is the same as in addid.

Source
addid(uri : String, position : Int32 | String | Nil = nil)

Adds a song to the playlist (non-recursive) and returns the song id. uri is always a single file or URL.

If the position is given, then the song is inserted at the specified position. If the parameter is string and starts with "+" or "-", then it is relative to the current song; e.g. "+0" inserts right after the current song and "-0" inserts right before the current song (i.e. zero songs between the current song and the newly added song).

Source
albumart(uri : String)

Locate album art for the given song

Source
callbacks_timeout
Source
callbacks_timeout=(callbacks_timeout : Time::Span)
Source
channels

Obtain a list of all channels.

Source
clear

Clears the current playlist.

Source
close

Closes the connection to MPD.

Source
command_list_end
Source
command_list_ok_begin

https://mpd.readthedocs.io/en/latest/protocol.html#command-lists

Source
commands

Shows which commands the current user has access to.

Source
config

Dumps configuration values that may be interesting for the client.

This command is only permitted to local clients (connected via UNIX domain socket).

The following response attributes are available:

  • music_directory: The absolute path of the music directory.
Source
connect

Connect to the MPD daemon unless conected.

Connect using the #reconnect method.

Source
connected?

Check if the client is connected.

Source
consume(state : Bool | String)

Sets consume state to state, state should be false, true or "oneshot".

When consume is activated, each song played is removed from playlist.

Source
count(filter : String | MPD::Filter, *, group : String | Nil = nil)

Count the number of songs and their total playtime in the database matching filter.

mpd.count("(genre == 'Rock')")
=> {"songs" => "11", "playtime" => "2496"}

The group keyword may be used to group the results by a tag. The first following example prints per-artist counts while the next prints the number of songs whose title matches "Echoes" grouped by artist:

mpd.count("(genre != 'Pop')", group: "artist")
=> [{"Artist" => "Artist 1", "songs" => "11", "playtime" => "2388"}, {"Artist" => "Artist 2", "songs" => "12", "playtime" => "2762"}]
Source
count(*, group : String | Nil = nil, & : MPD::Filter -> )

Count the number of songs and their total playtime in the database matching filter.

mpd.count("(genre == 'Rock')")
=> {"songs" => "11", "playtime" => "2496"}

The group keyword may be used to group the results by a tag. The first following example prints per-artist counts while the next prints the number of songs whose title matches "Echoes" grouped by artist:

mpd.count("(genre != 'Pop')", group: "artist")
=> [{"Artist" => "Artist 1", "songs" => "11", "playtime" => "2388"}, {"Artist" => "Artist 2", "songs" => "12", "playtime" => "2762"}]
Source
crop

Delete all playlist entries except the one currently playing

Source
currentsong

Displays the song info of the current song (same song that is identified in #status).

Source
decoders

Print a list of decoder plugins, followed by their supported suffixes and MIME types.

Source
delete(songpos : Int32 | MPD::Range)

Deletes a song from the playlist.

Source
deleteid(songid : Int32)

Deletes the song singid from the playlist.

Source
disableoutput(outputid : Int32 | String)

Turns an output off.

Source
disconnect

Disconnect from the MPD daemon.

Source
enableoutput(outputid : Int32 | String)

Turns an output on.

Source
find(filter : String | MPD::Filter, *, sort : String | Nil = nil, window : MPD::Range | Nil = nil)

Search the database for songs matching filter.

sort sorts the result by the specified tag. The sort is descending if the tag is prefixed with a minus (-). Without sort, the order is undefined. Only the first tag value will be used, if multiple of the same type exist. To sort by "Artist", "Album" or "AlbumArtist", you should specify "ArtistSort", "AlbumSort" or "AlbumArtistSort" instead. These will automatically fall back to the former if "*Sort" doesn't exist. "AlbumArtist" falls back to just "Artist". The type "Last-Modified" can sort by file modification time.

window can be used to query only a portion of the real response. The parameter is two zero-based record numbers; a start number and an end number.

mpd.find("(genre != 'Pop')", sort: "-ArtistSort", window: (5..10))
mpd.find("(genre starts_with 'Indie')")
mpd.find("(genre starts_with_ci 'inDIE')")
mpd.find("(genre contains 'Rock')")
mpd.find("(genre contains_ci 'RocK')")
Source
find(*, sort : String | Nil = nil, window : MPD::Range | Nil = nil, & : MPD::Filter -> )

Search the database for songs matching filter.

sort sorts the result by the specified tag. The sort is descending if the tag is prefixed with a minus (-). Without sort, the order is undefined. Only the first tag value will be used, if multiple of the same type exist. To sort by "Artist", "Album" or "AlbumArtist", you should specify "ArtistSort", "AlbumSort" or "AlbumArtistSort" instead. These will automatically fall back to the former if "*Sort" doesn't exist. "AlbumArtist" falls back to just "Artist". The type "Last-Modified" can sort by file modification time.

window can be used to query only a portion of the real response. The parameter is two zero-based record numbers; a start number and an end number.

mpd.find("(genre != 'Pop')", sort: "-ArtistSort", window: (5..10))
mpd.find("(genre starts_with 'Indie')")
mpd.find("(genre starts_with_ci 'inDIE')")
mpd.find("(genre contains 'Rock')")
mpd.find("(genre contains_ci 'RocK')")
Source
findadd(filter : String | MPD::Filter, *, sort : String | Nil = nil, window : MPD::Range | Nil = nil, position : Int32 | String | Nil = nil)

Search the database for songs matching filter and add them to the queue.

Parameters have the same meaning as for #find and #searchadd.

mpd.findadd("(genre == 'Alternative Rock')")
Source
findadd(*, sort : String | Nil = nil, window : MPD::Range | Nil = nil, position : Int32 | String | Nil = nil, & : MPD::Filter -> )

Search the database for songs matching filter and add them to the queue.

Parameters have the same meaning as for #find and #searchadd.

mpd.findadd("(genre == 'Alternative Rock')")
Source
getvol

Read the volume. The result is a {"volume" => "100"} like in status.

Source
host
Source
idle(subsystems : Array(String) | Nil = nil)

Waits until there is a noteworthy change in one or more of MPD’s subsystems.

As soon as there is one, it lists all changed systems, where subsystem is one of the following:

  • database - the song database has been modified after update.
  • update - a database update has started or finished. If the database was modified during the update, the database event is also emitted.
  • stored_playlist - a stored playlist has been modified, renamed, created or deleted
  • playlist - the queue (i.e. the current playlist) has been modified
  • player - the player has been started, stopped or seeked or tags of the currently playing song have changed (e.g. received from stream)
  • mixer - the volume has changed
  • output - an audio output has been added, removed or modified (e.g. renamed, enabled or disabled)
  • options - options like repeat, random, crossfade, replay gain
  • partition - a partition was added, removed or changed
  • sticker - the sticker database has been modified
  • subscription - a client has subscribed or unsubscribed to a channel
  • message - a message was received on a channel this client is subscribed to; this event is only emitted when the client’s message queue is empty
  • neighbor - a neighbor was found or lost
  • mount - the mount list has changed

If the optional subsystems argument is used, MPD will only send notifications when something changed in one of the specified subsytems.

Source
list(type : String, filter : String | MPD::Filter | Nil = nil, *, group : String | Nil = nil, window : MPD::Range | Nil = nil)

Lists unique tags values of the specified type.

type can be any tag supported by MPD or file. window works like in find. In this command, it affects only the top-most tag type. group keyword may be used to group the results by tags.

mpd.list("Artist")

Additional arguments may specify a filter. The following example lists all file names by their respective artist and date:

mpd.list("Artist")
mpd.list("filename", "((artist == 'Linkin Park') AND (date == '2003'))")
Source
list(type : String, *, group : String | Nil = nil, window : MPD::Range | Nil = nil, & : MPD::Filter -> )

Lists unique tags values of the specified type.

type can be any tag supported by MPD or file. window works like in find. In this command, it affects only the top-most tag type. group keyword may be used to group the results by tags.

mpd.list("Artist")

Additional arguments may specify a filter. The following example lists all file names by their respective artist and date:

mpd.list("Artist")
mpd.list("filename", "((artist == 'Linkin Park') AND (date == '2003'))")
Source
listall(uri : String | Nil = nil)

Lists all songs and directories in uri.

Source
listallinfo(uri : String | Nil = nil)

Same as #listall, except it also returns metadata info in the same format as #lsinfo.

Source
listfiles(uri : String | Nil = nil)

Lists the contents of the directory URI, including files are not recognized by MPD.

uri can be a path relative to the music directory or an uri understood by one of the storage plugins. The response contains at least one line for each directory entry with the prefix file: or directory: , and may be followed by file attributes such as Last-Modified and size.

For example, smb://SERVER returns a list of all shares on the given SMB/CIFS server; nfs://servername/path obtains a directory listing from the NFS server.

Source
listplaylist(name : String, range : MPD::Range | Nil = nil)

Lists the songs in the playlist name.

Playlist plugins are supported. A range may be specified to list only a part of the playlist

Source
listplaylistinfo(name : String, range : MPD::Range | Nil = nil)

Lists the songs with metadata in the playlist.

Playlist plugins are supported. A range may be specified to list only a part of the playlist.

Source
listplaylists

Prints a list of the playlist directory.

After each playlist name the server sends its last modification time as attribute Last-Modified in ISO 8601 format. To avoid problems due to clock differences between clients and the server, clients should not compare this value with their local clock.

Source
load(name : String, songpos : Int32 | MPD::Range | Nil = nil, position : Int32 | String | Nil = nil)

Loads the playlist name into the current queue.

Playlist plugins are supported. A range songpos may be specified to load only a part of the playlist.

The position parameter specifies where the songs will be inserted into the queue; it can be relative as described in addid. (This requires specifying the range as well; the special value 0: can be used if the whole playlist shall be loaded at a certain queue position.)

Source
lsinfo(uri : String | Nil = nil)

Lists the contents of the directory uri.

When listing the root directory, this currently returns the list of stored playlists. This behavior is deprecated; use #listplaylists instead.

Clients that are connected via UNIX domain socket may use this command to read the tags of an arbitrary local file (uri beginning with file:///).

Source
move(from : Int32 | MPD::Range, to : Int32)

Moves the song at from or range of songs at from to to in the playlist.

Source
moveid(from : Int32, to : Int32 | String)

Moves the song with from (songid) to to (playlist index) in the playlist.

If to starts with "+" or "-", then it is relative to the current song; e.g. "+0" moves to right after the current song and "-0" moves to right before the current song (i.e. zero songs between the current song and the moved song).

Source
next

Plays next song in the playlist.

Source
nextsong

Show the currently queued (next) song.

Source
notcommands

Shows which commands the current user does not have access to.

Source
on(event : Event, &block : String -> _)

Register a callback for a specific event (e.g., :state, :song, etc.)

mpd.on :state do |state|
  puts "State was change to #{state}"
end
Source
on_callback

Register a global callback for any event. Useful for unified event handling.

Source
on_connection_error

Register a callback for connection failures raised by callback or idle fibers.

Source
on_disconnect

Register a callback for a lost connection detected by callback or idle fibers.

Source
on_idle(subsystems : Array(String) | Nil = nil, reconnect_policy : ReconnectPolicy = @reconnect_policy, &block : Array(String) -> _) : Fiber

Register a callback for MPD idle subsystem changes.

This starts a background fiber that repeatedly calls #idle and yields the changed subsystem names to the block.

MPD's idle command blocks the connection while it waits for changes, so use a dedicated client for idle listeners when the application also needs to send regular commands.

listener = MPD::Client.new

listener.on_idle(["player", "playlist"]) do |events|
  puts events
end
Source
on_reconnect

Register a callback for a successful reconnect after a connection failure.

Source
outputs

Shows information about all outputs.

Source
pause(state : Bool | Nil = nil)

Pause or resume playback. Pass state true to pause playback or false to resume playback. Without the parameter, the pause state is toggled.

Source
play(songpos : Int32 | Nil = nil)

Begins playing the playlist at song number songpos.

Source
playid(songnid : Int32 | Nil = nil)

Begins playing the playlist at song songid.

Source
playlistadd(name : String, uri : String, position : Int32 | String | Nil = nil)

Adds uri to the playlist name.m3u.

name.m3u will be created if it does not exist.

The position parameter specifies where the songs will be inserted into the playlist.

Source
playlistclear(name : String)

Clears the playlist name.m3u.

Source
playlistdelete(name : String, songpos : Int32 | MPD::Range)

Deletes songpos from the playlist name.m3u.

The songpos parameter can be a range.

Source
playlistfind(filter : String | MPD::Filter, *, sort : String | Nil = nil, window : MPD::Range | Nil = nil)

Search the queue for songs matching filter.

sort sorts the result by the specified tag. The sort is descending if the tag is prefixed with a minus ('-'). Only the first tag value will be used, if multiple of the same type exist. To sort by "Title", "Artist", "Album", "AlbumArtist" or "Composer", you should specify "TitleSort", "ArtistSort", "AlbumSort", "AlbumArtistSort" or "ComposerSort" instead. These will automatically fall back to the former if "*Sort" doesn’t exist. "AlbumArtist" falls back to just "Artist". The type "Last-Modified" can sort by file modification time, and "prio" sorts by queue priority.

window can be used to query only a portion of the real response.

Source
playlistfind(*, sort : String | Nil = nil, window : MPD::Range | Nil = nil, & : MPD::Filter -> )

:ditto

Source
playlistid(songid : Int32 | Nil = nil)

Displays a list of songs in the playlist.

songid is optional and specifies a single song to display info for.

Source
playlistinfo(songpos : Int32 | MPD::Range | Nil = nil)

Displays a list of all songs in the playlist,

or if the optional argument is given, displays information only for the song songpos or the range of songs START:END.

Range is done in by using MPD::Range.

Show info about the first three songs in the playlist:

mpd.playlistinfo
mpd.playlistinfo(1..3)
mpd.playlistinfo(..3)
mpd.playlistinfo(10..)

With negative range end MPD will assumes the biggest possible number then

mpd.playlistinfo(10..-1)
Source
playlistlength(name : String)

Count the number of songs and their total playtime (seconds) in the playlist.

Source
playlistmove(name : String, from : Int32 | MPD::Range, to : Int32)

Moves the song at position from in the playlist name.m3u to the position to.

Source
playlistsearch(filter : String | MPD::Filter, *, sort : String | Nil = nil, window : MPD::Range | Nil = nil)

Search the queue for songs matching filter. Parameters have the same meaning as for find, except that search is not case sensitive.

Source
playlistsearch(*, sort : String | Nil = nil, window : MPD::Range | Nil = nil, & : MPD::Filter -> )

Search the queue for songs matching filter. Parameters have the same meaning as for find, except that search is not case sensitive.

Source
port
Source
previous

Plays previous song in the playlist.

Source
prio(priority : Int32, range : MPD::Range)

Set the priority of the specified songs.

A higher priority means that it will be played first when “random” mode is enabled.

A priority is an integer between 0 and 255. The default priority of new songs is 0.

Source
prioid(priority : Int32, songid : Int32)

Same as prio, but address the songs with their id.

Source
protocol

Shows a list of enabled protocol features.

Available features:

"hide_playlists_in_root": disables the listing of stored playlists for the lsinfo.

Source
protocol_all

Enables all protocol features.

Source
protocol_available

Lists all available protocol features.

Source
protocol_clear

Disables all protocol features.

Source
protocol_disable(feature : String)

Disables a feature.

Source
protocol_enable(feature : String)

Enables a feature.

Source
random(state : Bool)

Sets random state to state, state should be false or true.

Source
readmessages

Reads messages for this client.

client.readmessages
[{"channel" => "notifications", "message" => "System update available"}]
Source
readpicture(uri : String)

Locate a picture for the given song

Source
reconnect

Attempts to reconnect to the MPD daemon.

Source
reconnect_interval
Source
reconnect_interval=(reconnect_interval : Time::Span)
Source
reconnect_policy
Source
reconnect_policy=(reconnect_policy : ReconnectPolicy)
Source
rename(name : String, new_name : String)

Renames the playlist name.m3u to new_name.m3u.

Source
repeat(state : Bool)

Sets repeat state to state, state should be false or true.

Source
replay_gain_mode(mode : String)

Sets the replay gain mode.

One of off, track, album, auto. Changing the mode during playback may take several seconds, because the new settings does not affect the buffered data. This command triggers the options idle event.

Source
replay_gain_status

Prints replay gain options.

Currently, only the variable replay_gain_mode is returned.

Source
rescan(uri : String | Nil = nil)

Same as #update, but also rescans unmodified files.

Source
rm(name : String)

Removes the playlist name.m3u from the playlist directory.

Source
save(name : String, mode : String | Nil = nil)

Saves the current playlist to name.m3u in the playlist directory.

mode is optional argument. One of "create", "append", or "replace".

  • "create": The default. Create a new playlist. Fail if a playlist with name name already exists.
  • "append", "replace": Append or replace an existing playlist. Fail if a playlist with name name doesn't already exist.
Source
search(filter : String | MPD::Filter, *, sort : String | Nil = nil, window : MPD::Range | Nil = nil)

Search the database for songs matching filter.

Parameters have the same meaning as for #find, except that search is not case sensitive.

mpd.search("(any =~ 'crystal')")
Source
search(*, sort : String | Nil = nil, window : MPD::Range | Nil = nil, & : MPD::Filter -> )

Search the database for songs matching filter.

Parameters have the same meaning as for #find, except that search is not case sensitive.

mpd.search("(any =~ 'crystal')")
Source
searchadd(filter : String | MPD::Filter, *, sort : String | Nil = nil, window : MPD::Range | Nil = nil, position : Int32 | String | Nil = nil)

Search the database for songs matching filter and add them to the queue.

Parameters have the same meaning as for #search.

The position parameter specifies where the songs will be inserted. It can be relative to the current song as in #addid.

Source
searchadd(*, sort : String | Nil = nil, window : MPD::Range | Nil = nil, position : Int32 | String | Nil = nil, & : MPD::Filter -> )

Search the database for songs matching filter and add them to the queue.

Parameters have the same meaning as for #search.

The position parameter specifies where the songs will be inserted. It can be relative to the current song as in #addid.

Source
searchaddpl(name : String, filter : String | MPD::Filter, *, sort : String | Nil = nil, window : MPD::Range | Nil = nil, position : Int32 | String | Nil = nil)

Search the database for songs matching filter and add them to the queue.

If a playlist by that name doesn't exist it is created.

Parameters have the same meaning as for search.

The position parameter specifies where the songs will be inserted. It can be relative to the current song as in addid.

Source
searchaddpl(name : String, *, sort : String | Nil = nil, window : MPD::Range | Nil = nil, position : Int32 | String | Nil = nil, & : MPD::Filter -> )

Search the database for songs matching filter and add them to the queue.

If a playlist by that name doesn't exist it is created.

Parameters have the same meaning as for search.

The position parameter specifies where the songs will be inserted. It can be relative to the current song as in addid.

Source
searchcount(filter : String | MPD::Filter, *, group : String | Nil = nil)

Count the number of songs and their total playtime in the database matching filter. Parameters have the same meaning as for count except the search is not case sensitive.

Source
searchcount(*, group : String | Nil = nil, & : MPD::Filter -> )

Count the number of songs and their total playtime in the database matching filter. Parameters have the same meaning as for count except the search is not case sensitive.

Source
searchplaylist(name : String, filter : String | MPD::Filter, *, window : MPD::Range | Nil = nil)

Search the playlist for songs matching filter. A range may be specified to list only a part of the playlist.

Source
searchplaylist(name : String, *, window : MPD::Range | Nil = nil, & : MPD::Filter -> )

Search the playlist for songs matching filter. A range may be specified to list only a part of the playlist.

Source
seek(songid : Int32, time : Int32)

Seeks to the position time (in seconds) of entry songpos in the playlist.

Source
seekcur(time : String | Int32)

Seeks to the position time within the current song.

If prefixed by + or -, then the time is relative to the current playing position.

Source
seekid(songid : Int32, time : String | Int32)

Seeks to the position time (in seconds) of song songid.

Source
sendmessage(channel : String, message : String)

Send a message to the specified channel.

Source
setvol(vol : Int)

Sets volume to vol, the range of volume is 0-100.

Source
shuffle(range : MPD::Range | Nil = nil)

Shuffles the current playlist. range is optional and specifies a range of songs.

Source
single(state : Bool | String)

Sets single state to state, state should be false, true or "oneshot".

When single is activated, playback is stopped after current song, or song is repeated if the repeat mode is enabled.

Source
stats

Displays statistics.

Response:

  • artists: number of artists
  • songs: number of albums
  • uptime: daemon uptime in seconds
  • db_playtime: sum of all song times in the db
  • db_update: last db update in UNIX time
  • playtime: time length of music played
Source
status

Reports the current status of the player and the volume level.

Response:

  • partition: the name of the current partition
  • volume: 0-100
  • repeat: 0 or 1
  • random: 0 or 1
  • single: 0 or 1
  • consume: 0 or 1
  • playlist: 31-bit unsigned integer, the playlist version number
  • playlistlength: integer, the length of the playlist
  • state: play, stop, or pause
  • song: playlist song number of the current song stopped on or playing
  • songid: playlist songid of the current song stopped on or playing
  • nextsong: playlist song number of the next song to be played
  • nextsongid: playlist songid of the next song to be played
  • time: total time elapsed (of current playing/paused song)
  • elapsed: Total time elapsed within the current song, but with higher resolution
  • duration: Duration of the current song in seconds
  • bitrate: instantaneous bitrate in kbps
  • xfade: crossfade in seconds
  • mixrampdb: mixramp threshold in dB
  • mixrampdelay: mixrampdelay in seconds
  • audio: sampleRate:bits:channels
  • samplerate:bits:channels
  • updating_db: job id
  • error: if there is an error, returns message here
  • lastloadedplaylist: last loaded stored playlist
Source
sticker_dec(type : String, uri : String, name : String, value : Int32)

Adds a sticker value to the specified object. If a sticker item with that name already exists, it is decremented by supplied value.

Source
sticker_delete(type : String, uri : String, name : String | Nil = nil)

Deletes a sticker value from the specified object.

If you do not specify a sticker name, all sticker values are deleted.

Source
sticker_find(type : String, uri : String, name : String, value : String, operator : String = "=", *, sort : String | Nil = nil, window : MPD::Range | Nil = nil)

Searches for stickers with the given value.

Other supported operators are: "<", ">", "contains", "starts_with" for strings and "eq", "lt", "gt" to cast the value to an integer.

Source
sticker_find(type : String, uri : String, name : String, *, sort : String | Nil = nil, window : MPD::Range | Nil = nil)

Searches the sticker database for stickers with the specified name, below the specified directory (uri). For each matching song, it prints the URI and that one sticker’s value.

sort sorts the result by "uri", "value" or "value_int" (casts the sticker value to an integer).

Returns:

client.sticker_find("song", "path/to/folder", "name1")
# => [{"file" => "path/to/folder/file1.ogg", "sticker" => "name1=value1"}, ...]
Source
sticker_get(type : String, uri : String, name : String) : String | Nil

Reads a sticker value for the specified object.

Source
sticker_inc(type : String, uri : String, name : String, value : Int32)

Adds a sticker value to the specified object. If a sticker item with that name already exists, it is incremented by supplied value.

Source
sticker_list(type : String, uri : String) : Hash(String, String) | Nil

Lists the stickers for the specified object.

Source
sticker_set(type : String, uri : String, name : String, value : String)

Adds a sticker value to the specified object. If a sticker item with that name already exists, it is replaced.

Source
stickernames

Gets a list of uniq sticker names.

Source
stickernamestypes(type : String)

Gets a list of uniq sticker names and their types.

Source
stickertypes

Shows a list of available sticker types.

Source
stop

Stops playing.

Source
subscribe(name : String)

Subscribe to a channel. The channel is created if it does not exist already. The name may consist of alphanumeric ASCII characters plus underscore, dash, dot and colon.

Source
supports?(command : String | Symbol) : Bool
Source
tagtypes

Shows a list of available tag types.

Source
toggleoutput(outputid : Int32 | String)

Toggles an output on or off.

Source
unsubscribe(name : String)

Unsubscribe from a channel.

Source
update(uri : String | Nil = nil)

Updates the music database: find new files, remove deleted files, update modified files.

uri is a particular directory or song/file to update. If you do not specify it, everything is updated.

Source
urlhandlers

Gets a list of available URL handlers.

Source
version
Source
volume(change : Int)

Changes volume by amount change.

Source
with_command_list
Source

Nested types