Class: MPD

Inherits:
Object
  • Object
show all
Defined in:
lib/librmpd.rb

Overview

librmpd.rb

librmpd.rb is another Ruby MPD Library with a goal of greater ease of use, more functionality, and thread safety

Author

Andrew Rader (bitwise_mcgee AT yahoo.com | nymb.us)

Copyright

Copyright © 2006 Andrew Rader

License

Distributed under the GNU GPL v2 (See COPYING file)

This was written with MPD version 0.11.5 (www.musicpd.org)

The main class is the MPD class. This provides the functionality for talking to the server as well as setting up callbacks for when events occur (such as song changes, state changes, etc). The use of callbacks is optional, if they are used a seperate thread will continuously poll the server on its status, when something is changed, your program will be notified via any callbacks you have set. Most methods are the same as specified in the MPD Server Protocol, however some have been modified or renamed. Most notable is the list* and lsinfo functions have been replace with more sane methods (such as ‘files` for all files)

Usage

First create an MPD object

require 'rubygems'
require 'librmpd'

mpd = MPD.new 'localhost', 6600

and connect it to the server

mpd.connect

You can now issue any of the commands. Each command is documented below.

Callbacks

Callbacks are a way to easily setup your client as event based, rather than polling based. This means rather than having to check for changes in the server, you setup a few methods that will be called when those changes occur. For example, you could have a ‘state_changed’ method that will be called whenever the server changes state. You could then have this method change a label to reflect to the new state.

To use callbacks in your program, first setup your callback methods. For example, say you have the class MyClient. Simply define whatever callbacks you want inside your class. See the documentation on the callback type constants in the MPD class for details on how each callback is called

Once you have your callback methods defined, use the register_callback methods to inform librmpd about them. You can have multiple callbacks for each type of callback without problems. Simply use object.method(‘method_name’) to get a reference to a Method object. Pass this object to the register_callback (along with the proper type value), and you’re set.

An Example:

class MyClient
 ...
 def state_callback( newstate )
  puts "MPD Changed State: #{newstate}"
 end
 ...
end

client = MyClient.new
mpd = MPD.new
mpd.register_callback(client.method('state_callback'), MPD::STATE_CALLBACK)

# Connect and Enable Callbacks
mpd.connect( true )

In order for the callback to be used, you must enable callbacks when you connect by passing true to the connect method. Now, whenever the state changes on the server, myclientobj’s state_callback method will be called (and passed the new state as an argument)

Defined Under Namespace

Classes: Song

Constant Summary collapse

STATE_CALLBACK =

STATE_CALLBACK: This is used to listen for changes in the server state

The callback will always be called with a single string argument which may an empty string.

0
CURRENT_SONG_CALLBACK =

song being played by the server.

The callback will always be called with a single argument, an MPD::Song object, or, if there were problems, nil

1
PLAYLIST_CALLBACK =

PLAYLIST_CALLBACK: This is used to listen for when changes in the playlist are made.

The callback will always be called with a single argument, an integer value for the current playlist or 0 if there were problems

2
TIME_CALLBACK =

TIME_CALLBACK: This is used to listen for when the playback time changes

The callback will always be called with two arguments. The first is the integer number of seconds elapsed (or 0 if errors), the second is the total number of seconds in the song (or 0 if errors)

3
VOLUME_CALLBACK =

VOLUME_CALLBACK: This is used to listen for when the volume changes

The callback will always be called with a single argument, an integer value of the volume (or 0 on errors)

4
REPEAT_CALLBACK =

REPEAT_CALLBACK: This is used to listen for changes to the repeat flag

The callback will always be called with a single argument, a boolean true or false depending on if the repeat flag is set / unset

5
RANDOM_CALLBACK =

RANDOM_CALLBACK: This is used to listen for changed to the random flag

The callback will always be called with a single argument, a boolean true or false depending on if the random flag is set / unset

6
PLAYLIST_LENGTH_CALLBACK =

PLAYLIST_LENGTH_CALLBACK: This is used to listen for changes to the playlist length

The callback will always be called with a single argument, an integer value of the current playlist’s length (or 0 on errors)

7
CROSSFADE_CALLBACK =

CROSSFADE_CALLBACK: This is used to listen for changes in the crossfade setting

The callback will always be called with a single argument, an integer value of the number of seconds the crossfade is set to (or 0 on errsors)

8
CURRENT_SONGID_CALLBACK =

CURRENT_SONGID_CALLBACK: This is used to listen for changes in the current song’s songid

The callback will always be called with a single argument, an integer value of the id of the current song (or 0 on errors)

9
BITRATE_CALLBACK =

BITRATE_CALLBACK: This is used to listen for changes in the playback bitrate

The callback will always be called with a single argument, an integer value of the bitrate of the playback (or 0 on errors)

10
AUDIO_CALLBACK =

AUDIO_CALLBACK: This is used to listen for changes in the audio quality data (sample rate etc)

The callback will always be called with three arguments, first, an integer holding the sample rate (or 0 on errors), next an integer holding the number of bits (or 0 on errors), finally an integer holding the number of channels (or 0 on errors)

11
CONNECTION_CALLBACK =

CONNECTION_CALLBACK: This is used to listen for changes in the connection to the server

The callback will always be called with a single argument, a boolean true if the client is now connected to the server, and a boolean false if it has been disconnected

12

Instance Method Summary collapse

Constructor Details

#initialize(hostname = 'localhost', port = 6600) ⇒ MPD

Initialize an MPD object with the specified hostname and port When called without arguments, ‘localhost’ and 6600 are used



247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
 
# File 'lib/librmpd.rb', line 247

def initialize( hostname = 'localhost', port = 6600 )
	@hostname = hostname
	@port = port
	@socket = nil
	@stop_cb_thread = false
	@mutex = Mutex.new
	@cb_thread = nil
	@callbacks = []
	@callbacks[STATE_CALLBACK] = []
	@callbacks[CURRENT_SONG_CALLBACK] = []
	@callbacks[PLAYLIST_CALLBACK] = []
	@callbacks[TIME_CALLBACK] = []
	@callbacks[VOLUME_CALLBACK] = []
	@callbacks[REPEAT_CALLBACK] = []
	@callbacks[RANDOM_CALLBACK] = []
	@callbacks[PLAYLIST_LENGTH_CALLBACK] = []
	@callbacks[CROSSFADE_CALLBACK] = []
	@callbacks[CURRENT_SONGID_CALLBACK] = []
	@callbacks[BITRATE_CALLBACK] = []
	@callbacks[AUDIO_CALLBACK] = []
	@callbacks[CONNECTION_CALLBACK] = []
end

Instance Method Details

#add(path) ⇒ Object

Add the file path to the playlist. If path is a directory, it will be added recursively.

Returns true if this was successful, Raises a RuntimeError if the command failed



467
468
469
 
# File 'lib/librmpd.rb', line 467

def add( path )
	send_command "add \"#{path}\""
end

#albums(artist = nil) ⇒ Object

Lists all of the albums in the database The optional argument is for specifying an artist to list the albums for

Returns an Array of Album names (Strings), Raises a RuntimeError if the command failed



563
564
565
 
# File 'lib/librmpd.rb', line 563

def albums( artist = nil )
	list 'album', artist
end

#artists ⇒ Object

Lists all of the artists in the database

Returns an Array of Artist names (Strings), Raises a RuntimeError if the command failed



572
573
574
 
# File 'lib/librmpd.rb', line 572

def artists
	list 'artist'
end

#clear ⇒ Object

Clears the current playlist

Returns true if this was successful, Raises a RuntimeError if the command failed



476
477
478
 
# File 'lib/librmpd.rb', line 476

def clear
	send_command 'clear'
end

#clearerror ⇒ Object

Clears the current error message reported in status ( This is also accomplished by any command that starts playback )

Returns true if this was successful, Raises a RuntimeError if the command failed



486
487
488
 
# File 'lib/librmpd.rb', line 486

def clearerror
	send_command 'clearerror'
end

#connect(callbacks = false) ⇒ Object

If connect is called on an already connected instance, a RuntimeError is raised



288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
 
# File 'lib/librmpd.rb', line 288

def connect( callbacks = false )
	if self.connected?
		raise 'MPD Error: Already Connected'
	end

	@socket = TCPSocket::new @hostname, @port
	ret = @socket.gets # Read the version

	if callbacks and (@cb_thread.nil? or !@cb_thread.alive?)
		@stop_cb_thread = false
		@cb_thread = Thread.new( self ) { |mpd|
			old_status = {}
			song = ''
			connected = ''
			while !@stop_cb_thread
				begin
					status = mpd.status
				rescue
					status = {}
				end

				begin
					c = mpd.connected?
				rescue
					c = false
				end

				if connected != c
					connected = c
					for cb in @callbacks[CONNECTION_CALLBACK]
						cb.call connected
					end
				end

				if old_status['time'] != status['time']
					if old_status['time'].nil? or old_status['time'].empty?
						old_status['time'] = '0:0'
					end
					t = old_status['time'].split ':'
					elapsed = t[0].to_i
					total = t[1].to_i
					for cb in @callbacks[TIME_CALLBACK]
						cb.call elapsed, total
					end
				end

				if old_status['volume'] != status['volume']
					for cb in @callbacks[VOLUME_CALLBACK]
						cb.call status['volume'].to_i
					end
				end

				if old_status['repeat'] != status['repeat']
					for cb in @callbacks[REPEAT_CALLBACK]
						cb.call(status['repeat'] == '1')
					end
				end

				if old_status['random'] != status['random']
					for cb in @callbacks[RANDOM_CALLBACK]
						cb.call(status['random'] == '1')
					end
				end

				if old_status['playlist'] != status['playlist']
					for cb in @callbacks[PLAYLIST_CALLBACK]
						cb.call status['playlist'].to_i
					end
				end

				if old_status['playlistlength'] != status['playlistlength']
					for cb in @callbacks[PLAYLIST_LENGTH_CALLBACK]
						cb.call status['playlistlength'].to_i
					end
				end

				if old_status['xfade'] != status['xfade']
					for cb in @callbacks[CROSSFADE_CALLBACK]
						cb.call status['xfade'].to_i
					end
				end

				if old_status['state'] != status['state']
					state = (status['state'].nil? ? '' : status['state'])
					for cb in @callbacks[STATE_CALLBACK]
						cb.call state
					end
				end

				begin
					s = mpd.current_song
				rescue
					s = nil
				end

				if song != s
					song = s
					for cb in @callbacks[CURRENT_SONG_CALLBACK]
						cb.call song
					end
				end

				if old_status['songid'] != status['songid']
					for cb in @callbacks[CURRENT_SONGID_CALLBACK]
						cb.call status['songid'].to_i
					end
				end

				if old_status['bitrate'] != status['bitrate']
					for cb in @callbacks[BITRATE_CALLBACK]
						cb.call status['bitrate'].to_i
					end
				end

				if old_status['audio'] != status['audio']
					audio = (status['audio'].nil? ? '0:0:0' : status['audio'])
					a = audio.split ':'
					samp = a[0].to_i
					bits = a[1].to_i
					chans = a[2].to_i
					for cb in @callbacks[AUDIO_CALLBACK]
						cb.call samp, bits, chans
					end
				end
				
				old_status = status
				sleep 0.1

				if !connected
					sleep 2
					begin
						mpd.connect unless @stop_cb_thread
					rescue
					end
				end
			end
		}
	end

	return ret
end

#connected? ⇒ Boolean

Check if the client is connected

This will return true only if the server responds otherwise false is returned

Returns:

  • (Boolean) 


435
436
437
438
439
440
441
442
443
444
 
# File 'lib/librmpd.rb', line 435

def connected?
	return false if @socket.nil?
	begin
		ret = send_command 'ping'
	rescue
		ret = false
	end

	return ret
end

#crossfade ⇒ Object

Read the crossfade between songs in seconds, Raises a RuntimeError if the command failed



501
502
503
504
505
 
# File 'lib/librmpd.rb', line 501

def crossfade
	status = self.status
	return if status.nil?
	return status['xfade'].to_i
end

#crossfade=(seconds) ⇒ Object

Set the crossfade between songs in seconds

Raises a RuntimeError if the command failed



494
495
496
 
# File 'lib/librmpd.rb', line 494

def crossfade=( seconds )
	send_command "crossfade #{seconds}"
end

#current_song ⇒ Object

Read the current song in seconds

Returns a Song object with the current song’s data, Raises a RuntimeError if the command failed



512
513
514
 
# File 'lib/librmpd.rb', line 512

def current_song
	build_song( send_command('currentsong') )
end

#delete(pos) ⇒ Object

Delete the song from the playlist, where pos is the song’s position in the playlist

Returns true if successful, Raises a RuntimeError if the command failed



522
523
524
 
# File 'lib/librmpd.rb', line 522

def delete( pos )
	send_command "delete #{pos}"
end

#deleteid(songid) ⇒ Object

Delete the song with the songid from the playlist

Returns true if successful, Raises a RuntimeError if the command failed



531
532
533
 
# File 'lib/librmpd.rb', line 531

def deleteid( songid )
	send_command "deleteid #{songid}"
end

#directories(path = nil) ⇒ Object

List all of the directories in the database, starting at path. If path isn’t specified, the root of the database is used

Returns an Array of directory names (Strings), Raises a RuntimeError if the command failed



608
609
610
611
612
613
614
615
616
 
# File 'lib/librmpd.rb', line 608

def directories( path = nil )
	if not path.nil?
		response = send_command "listall \"#{path}\""
	else
		response = send_command 'listall'
	end

	filter_response response, /\Adirectory: /i
end

#disconnect ⇒ Object

Disconnect from the server. This has no effect if the client is not connected. Reconnect using the connect method. This will also stop the callback thread, thus disabling callbacks



451
452
453
454
455
456
457
458
459
 
# File 'lib/librmpd.rb', line 451

def disconnect
	@stop_cb_thread = true

	return if @socket.nil?

	@socket.puts 'close'
	@socket.close
	@socket = nil
end

#files(path = nil) ⇒ Object

List all of the files in the database, starting at path. If path isn’t specified, the root of the database is used

Returns an Array of file names (Strings). Raises a RuntimeError if the command failed



624
625
626
627
628
629
630
631
632
 
# File 'lib/librmpd.rb', line 624

def files( path = nil )
	if not path.nil?
		response = send_command "listall \"#{path}\""
	else
		response = send_command 'listall'
	end

	filter_response response, /\Afile: /i
end

#find(type, what) ⇒ Object

Finds songs in the database that are EXACTLY matched by the what argument. type should be ‘album’, ‘artist’, or ‘title’

This returns an Array of MPD::Songs, Raises a RuntimeError if the command failed



542
543
544
545
 
# File 'lib/librmpd.rb', line 542

def find( type, what )
	response = send_command "find \"#{type}\" \"#{what}\""
	build_songs_list response
end

#kill ⇒ Object

Kills MPD

Returns true if successful. Raises a RuntimeError if the command failed



552
553
554
 
# File 'lib/librmpd.rb', line 552

def kill
	send_command 'kill'
end

#list(type, arg = nil) ⇒ Object

This is used by the albums and artists methods type should be ‘album’ or ‘artist’. If type is ‘album’ then arg can be a specific artist to list the albums for

Returns an Array of Strings, Raises a RuntimeError if the command failed



583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
 
# File 'lib/librmpd.rb', line 583

def list( type, arg = nil )
	if not arg.nil?
		response = send_command "list #{type} \"#{arg}\""
	else
		response = send_command "list #{type}"
	end

	list = []
	if not response.nil? and response.kind_of? String
		lines = response.split "\n"
		re = Regexp.new "\\A#{type}: ", 'i'
		for line in lines
			list << line.gsub( re, '' )
		end
	end

	return list
end

#load(name) ⇒ Object

Loads the playlist name.m3u (do not pass the m3u extension when calling) from the playlist directory. Use ‘playlists` to what playlists are available

Returns true if successful, Raises a RuntimeError if the command failed



684
685
686
 
# File 'lib/librmpd.rb', line 684

def load( name )
	send_command "load \"#{name}\""
end

#move(from, to) ⇒ Object

Move the song at ‘from` to `to` in the playlist

Returns true if successful, Raises a RuntimeError if the command failed



693
694
695
 
# File 'lib/librmpd.rb', line 693

def move( from, to )
	send_command "move #{from} #{to}"
end

#moveid(songid, to) ⇒ Object

Move the song with the ‘songid` to `to` in the playlist

Returns true if successful, Raises a RuntimeError if the command failed



702
703
704
 
# File 'lib/librmpd.rb', line 702

def moveid( songid, to )
	send_command "moveid #{songid} #{to}"
end

#next ⇒ Object

Plays the next song in the playlist

Returns true if successful, Raises a RuntimeError if the command failed



711
712
713
 
# File 'lib/librmpd.rb', line 711

def next
	send_command 'next'
end

#password(pass) ⇒ Object

This is used for authentication with the server ‘pass` is simply the plaintext password

Raises a RuntimeError if the command failed



738
739
740
 
# File 'lib/librmpd.rb', line 738

def password( pass )
	send_command "password \"#{pass}\""
end

#pause=(toggle) ⇒ Object

Set / Unset paused playback

Returns true if successful, Raises a RuntimeError if the command failed



720
721
722
 
# File 'lib/librmpd.rb', line 720

def pause=( toggle )
	send_command 'pause ' + (toggle ? '1' : '0')
end

#paused? ⇒ Boolean

Returns true if MPD is paused, Raises a RuntimeError if the command failed

Returns:

  • (Boolean) 


727
728
729
730
731
 
# File 'lib/librmpd.rb', line 727

def paused?
	status = self.status
	return false if status.nil?
	return status['state'] == 'pause'
end

#ping ⇒ Object

Ping the server

Returns true if successful, Raises a RuntimeError if the command failed



747
748
749
 
# File 'lib/librmpd.rb', line 747

def ping
	send_command 'ping'
end

#play(pos = nil) ⇒ Object

Begin playing the playist. Optionally specify the pos to start on

Returns true if successful, Raises a RuntimeError if the command failed



757
758
759
760
761
762
763
 
# File 'lib/librmpd.rb', line 757

def play( pos = nil )
	if pos.nil?
		return send_command('play')
	else
		return send_command("play #{pos}")
	end
end

#playid(songid = nil) ⇒ Object

Begin playing the playlist. Optionally specify the songid to start on

Returns true if successful, Raises a RuntimeError if the command failed



779
780
781
782
783
784
785
 
# File 'lib/librmpd.rb', line 779

def playid( songid = nil )
	if not songid.nil?
	 return(send_command("playid #{songid}"))
	else
		return(send_command('playid'))
	end
end

#playing? ⇒ Boolean

Returns true if the server’s state is set to ‘play’, Raises a RuntimeError if the command failed

Returns:

  • (Boolean) 


768
769
770
771
 
# File 'lib/librmpd.rb', line 768

def playing?
	state = self.status['state']
	return state == 'play'
end

#playlist ⇒ Object

List the current playlist This is the same as playlistinfo w/o args

Returns an Array of MPD::Songs, Raises a RuntimeError if the command failed



800
801
802
803
 
# File 'lib/librmpd.rb', line 800

def playlist
	response = send_command 'playlistinfo'
	build_songs_list response
end

#playlist_changes(version) ⇒ Object

List the changes since the specified version in the playlist

Returns an Array of MPD::Songs, Raises a RuntimeError if the command failed



824
825
826
827
 
# File 'lib/librmpd.rb', line 824

def playlist_changes( version )
	response = send_command "plchanges #{version}"
	build_songs_list response
end

#playlist_version ⇒ Object

Returns the current playlist version number, Raises a RuntimeError if the command failed



790
791
792
 
# File 'lib/librmpd.rb', line 790

def playlist_version
	self.status['playlist'].to_i
end

#playlists ⇒ Object

List all of the playlists in the database

Returns an Array of playlist names (Strings)



638
639
640
641
642
 
# File 'lib/librmpd.rb', line 638

def playlists
		response = send_command 'lsinfo'

		filter_response response, /\Aplaylist: /i
end

#previous ⇒ Object

Plays the previous song in the playlist

Returns true if successful, Raises a RuntimeError if the command failed



834
835
836
 
# File 'lib/librmpd.rb', line 834

def previous
	send_command 'previous'
end

#random=(toggle) ⇒ Object

Enable / Disable random playback, Raises a RuntimeError if the command failed



841
842
843
 
# File 'lib/librmpd.rb', line 841

def random=( toggle )
	send_command 'random ' + (toggle ? '1' : '0')
end

#random? ⇒ Boolean

Returns true if random playback is currently enabled, Raises a RuntimeError if the command failed

Returns:

  • (Boolean) 


848
849
850
851
 
# File 'lib/librmpd.rb', line 848

def random?
	rand = self.status['random']
	return rand == '1'
end

#register_callback(method, type) ⇒ Object 



270
271
272
 
# File 'lib/librmpd.rb', line 270

def register_callback( method, type )
	@callbacks[type].push method
end

#remove_playlist(playlist) ⇒ Object

An Alias for rm



880
881
882
 
# File 'lib/librmpd.rb', line 880

def remove_playlist( playlist )
	rm playlist
end

#repeat=(toggle) ⇒ Object

Enable / Disable repeat, Raises a RuntimeError if the command failed



856
857
858
 
# File 'lib/librmpd.rb', line 856

def repeat=( toggle )
	send_command 'repeat ' + (toggle ? '1' : '0')
end

#repeat? ⇒ Boolean

Returns true if repeat is enabled, Raises a RuntimeError if the command failed

Returns:

  • (Boolean) 


863
864
865
866
 
# File 'lib/librmpd.rb', line 863

def repeat?
	repeat = self.status['repeat']
	return repeat == '1'
end

#rm(playlist) ⇒ Object

Removes (PERMANENTLY!) the playlist ‘playlist.m3u` from the playlist directory

Returns true if successful, Raises a RuntimeError if the command failed



874
875
876
 
# File 'lib/librmpd.rb', line 874

def rm( playlist )
	send_command "rm \"#{playlist}\""
end

#save(playlist) ⇒ Object

Saves the current playlist to ‘playlist`.m3u in the playlist directory

Returns true if successful, Raises a RuntimeError if the command failed



890
891
892
 
# File 'lib/librmpd.rb', line 890

def save( playlist )
	send_command "save \"#{playlist}\""
end

#search(type, what) ⇒ Object

Searches for any song that contains ‘what` in the `type` field `type` can be ’title’, ‘artist’, ‘album’ or ‘filename’ Searches are NOT case sensitive

Returns an Array of MPD::Songs, Raises a RuntimeError if the command failed



901
902
903
 
# File 'lib/librmpd.rb', line 901

def search( type, what )
	build_songs_list( send_command("search #{type} \"#{what}\"") )
end

#seek(pos, time) ⇒ Object

Seeks to the position ‘time` (in seconds) of the song at `pos` in the playlist

Returns true if successful, Raises a RuntimeError if the command failed



911
912
913
 
# File 'lib/librmpd.rb', line 911

def seek( pos, time )
	send_command "seek #{pos} #{time}"
end

#seekid(songid, time) ⇒ Object

Seeks to the position ‘time` (in seconds) of the song with the id `songid`

Returns true if successful, Raises a RuntimeError if the command failed



921
922
923
 
# File 'lib/librmpd.rb', line 921

def seekid( songid, time )
	send_command "seekid #{songid} #{time}"
end

#shuffle ⇒ Object

Shuffles the playlist, Raises a RuntimeError if the command failed



946
947
948
 
# File 'lib/librmpd.rb', line 946

def shuffle
	send_command 'shuffle' 
end

#song_at_pos(pos) ⇒ Object

Returns the MPD::Song at the position ‘pos` in the playlist, Raises a RuntimeError if the command failed



808
809
810
 
# File 'lib/librmpd.rb', line 808

def song_at_pos( pos )
	build_song( send_command("playlistinfo #{pos}") )
end

#song_with_id(songid) ⇒ Object

Returns the MPD::Song with the ‘songid` in the playlist, Raises a RuntimeError if the command failed



815
816
817
 
# File 'lib/librmpd.rb', line 815

def song_with_id( songid )
	build_song( send_command("playlistid #{songid}") )
end

#songs(path = nil) ⇒ Object

List all of the songs in the database starting at path. If path isn’t specified, the root of the database is used

Returns an Array of MPD::Songs, Raises a RuntimeError if the command failed



650
651
652
653
654
655
656
657
658
 
# File 'lib/librmpd.rb', line 650

def songs( path = nil )
	if not path.nil?
		response = send_command "listallinfo \"#{path}\""
	else
		response = send_command 'listallinfo'
	end

	build_songs_list response
end

#songs_by_artist(artist) ⇒ Object

List all of the songs by an artist

Returns an Array of MPD::Songs by the artist ‘artist`, Raises a RuntimeError if the command failed



665
666
667
668
669
670
671
672
673
674
675
 
# File 'lib/librmpd.rb', line 665

def songs_by_artist( artist )
	all_songs = self.songs
	artist_songs = []
	all_songs.each do |song|
		if song.artist == artist
			artist_songs << song
		end
	end

	return artist_songs
end

#stats ⇒ Object

Returns a Hash of MPD’s stats, Raises a RuntimeError if the command failed



953
954
955
956
 
# File 'lib/librmpd.rb', line 953

def stats
	response = send_command 'stats'
	build_hash response
end

#status ⇒ Object

Returns a Hash of the current status, Raises a RuntimeError if the command failed



961
962
963
964
 
# File 'lib/librmpd.rb', line 961

def status
	response = send_command 'status'
	build_hash response
end

#stop ⇒ Object

Stop playing

Returns true if successful, Raises a RuntimeError if the command failed



971
972
973
 
# File 'lib/librmpd.rb', line 971

def stop
	send_command 'stop'
end

#stopped? ⇒ Boolean

Returns true if the server’s state is ‘stop’, Raises a RuntimeError if the command failed

Returns:

  • (Boolean) 


978
979
980
981
982
 
# File 'lib/librmpd.rb', line 978

def stopped?
	status = self.status
	return false if status.nil?
	return status['state'] == 'stop'
end

#swap(posA, posB) ⇒ Object

Swaps the song at position ‘posA` with the song as position `posB` in the playlist

Returns true if successful, Raises a RuntimeError if the command failed



990
991
992
 
# File 'lib/librmpd.rb', line 990

def swap( posA, posB )
	send_command "swap #{posA} #{posB}"
end

#swapid(songidA, songidB) ⇒ Object

Swaps the song with the id ‘songidA` with the song with the id `songidB`

Returns true if successful, Raises a RuntimeError if the command failed



1000
1001
1002
 
# File 'lib/librmpd.rb', line 1000

def swapid( songidA, songidB )
	send_command "swapid #{songidA} #{songidB}"
end

#update(path = nil) ⇒ Object

Tell the server to update the database. Optionally, specify the path to update



1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
 
# File 'lib/librmpd.rb', line 1007

def update( path = nil )
	ret = ''
	if not path.nil?
		ret = send_command("update \"#{path}\"")
	else
		ret = send_command('update')
	end

	return(ret.gsub('updating_db: ', '').to_i)
end

#volume ⇒ Object

Returns the volume, Raises a RuntimeError if the command failed



937
938
939
940
941
 
# File 'lib/librmpd.rb', line 937

def volume
	status = self.status
	return if status.nil?
	return status['volume'].to_i
end

#volume=(vol) ⇒ Object

Set the volume The argument ‘vol` will automatically be bounded to 0 - 100

Raises a RuntimeError if the command failed



930
931
932
 
# File 'lib/librmpd.rb', line 930

def volume=( vol )
	send_command "setvol #{vol}"
end