?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mpdclient: export mpdclient_finish_command
[ncmpc.git] / src / mpdclient.c
blobce1eed5972de92bda9ef4db76a0aa7682d60dc92
1 /* ncmpc (Ncurses MPD Client)
2 * (c) 2004-2010 The Music Player Daemon Project
3 * Project homepage: http://musicpd.org
4
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20 #include "mpdclient.h"
21 #include "filelist.h"
22 #include "screen_client.h"
23 #include "config.h"
24 #include "options.h"
25 #include "strfsong.h"
26 #include "utils.h"
27 #include "gidle.h"
28
29 #include <mpd/client.h>
30
31 #include <stdlib.h>
32 #include <unistd.h>
33 #include <time.h>
34 #include <string.h>
35
36 #define BUFSIZE 1024
37
38 /* sort by list-format */
39 gint
40 compare_filelistentry_format(gconstpointer filelist_entry1,
41 gconstpointer filelist_entry2)
42 {
43 const struct mpd_entity *e1, *e2;
44 char key1[BUFSIZE], key2[BUFSIZE];
45 int n = 0;
46
47 e1 = ((const struct filelist_entry *)filelist_entry1)->entity;
48 e2 = ((const struct filelist_entry *)filelist_entry2)->entity;
49
50 if (e1 && e2 &&
51 mpd_entity_get_type(e1) == MPD_ENTITY_TYPE_SONG &&
52 mpd_entity_get_type(e2) == MPD_ENTITY_TYPE_SONG) {
53 strfsong(key1, BUFSIZE, options.list_format, mpd_entity_get_song(e1));
54 strfsong(key2, BUFSIZE, options.list_format, mpd_entity_get_song(e2));
55 n = strcmp(key1,key2);
56 }
57
58 return n;
59 }
60
61
62 /****************************************************************************/
63 /*** mpdclient functions ****************************************************/
64 /****************************************************************************/
65
66 bool
67 mpdclient_handle_error(struct mpdclient *c)
68 {
69 enum mpd_error error = mpd_connection_get_error(c->connection);
70
71 assert(error != MPD_ERROR_SUCCESS);
72
73 if (error == MPD_ERROR_SERVER &&
74 mpd_connection_get_server_error(c->connection) == MPD_SERVER_ERROR_PERMISSION &&
75 screen_auth(c))
76 return true;
77
78 mpdclient_ui_error(mpd_connection_get_error_message(c->connection));
79
80 if (!mpd_connection_clear_error(c->connection))
81 mpdclient_disconnect(c);
82
83 return false;
84 }
85
86 struct mpdclient *
87 mpdclient_new(void)
88 {
89 struct mpdclient *c;
90
91 c = g_new0(struct mpdclient, 1);
92 playlist_init(&c->playlist);
93 c->volume = -1;
94 c->events = 0;
95
96 return c;
97 }
98
99 void
100 mpdclient_free(struct mpdclient *c)
101 {
102 mpdclient_disconnect(c);
103
104 mpdclient_playlist_free(&c->playlist);
105
106 g_free(c);
107 }
108
109 void
110 mpdclient_disconnect(struct mpdclient *c)
111 {
112 if (c->source != NULL) {
113 mpd_glib_free(c->source);
114 c->source = NULL;
115 c->idle = false;
116 }
117
118 if (c->connection)
119 mpd_connection_free(c->connection);
120 c->connection = NULL;
121
122 if (c->status)
123 mpd_status_free(c->status);
124 c->status = NULL;
125
126 playlist_clear(&c->playlist);
127
128 if (c->song)
129 c->song = NULL;
130
131 /* everything has changed after a disconnect */
132 c->events |= MPD_IDLE_ALL;
133 }
134
135 bool
136 mpdclient_connect(struct mpdclient *c,
137 const gchar *host,
138 gint port,
139 unsigned timeout_ms,
140 const gchar *password)
141 {
142 /* close any open connection */
143 if (c->connection)
144 mpdclient_disconnect(c);
145
146 /* connect to MPD */
147 c->connection = mpd_connection_new(host, port, timeout_ms);
148 if (c->connection == NULL)
149 g_error("Out of memory");
150
151 if (mpd_connection_get_error(c->connection) != MPD_ERROR_SUCCESS) {
152 mpdclient_handle_error(c);
153 mpdclient_disconnect(c);
154 return false;
155 }
156
157 /* send password */
158 if (password != NULL && !mpd_run_password(c->connection, password)) {
159 mpdclient_handle_error(c);
160 mpdclient_disconnect(c);
161 return false;
162 }
163
164 return true;
165 }
166
167 bool
168 mpdclient_update(struct mpdclient *c)
169 {
170 struct mpd_connection *connection = mpdclient_get_connection(c);
171
172 c->volume = -1;
173
174 if (connection == NULL)
175 return false;
176
177 /* always announce these options as long as we don't have
178 "idle" support */
179 if (c->source == NULL)
180 c->events |= MPD_IDLE_PLAYER|MPD_IDLE_OPTIONS;
181
182 /* free the old status */
183 if (c->status)
184 mpd_status_free(c->status);
185
186 /* retrieve new status */
187 c->status = mpd_run_status(connection);
188 if (c->status == NULL)
189 return mpdclient_handle_error(c);
190
191 if (c->source == NULL &&
192 c->update_id != mpd_status_get_update_id(c->status)) {
193 c->events |= MPD_IDLE_UPDATE;
194
195 if (c->update_id > 0)
196 c->events |= MPD_IDLE_DATABASE;
197 }
198
199 c->update_id = mpd_status_get_update_id(c->status);
200
201 if (c->source == NULL &&
202 c->volume != mpd_status_get_volume(c->status))
203 c->events |= MPD_IDLE_MIXER;
204
205 c->volume = mpd_status_get_volume(c->status);
206
207 /* check if the playlist needs an update */
208 if (c->playlist.version != mpd_status_get_queue_version(c->status)) {
209 bool retval;
210
211 if (c->source == NULL)
212 c->events |= MPD_IDLE_QUEUE;
213
214 if (!playlist_is_empty(&c->playlist))
215 retval = mpdclient_playlist_update_changes(c);
216 else
217 retval = mpdclient_playlist_update(c);
218 if (!retval)
219 return false;
220 }
221
222 /* update the current song */
223 if (!c->song || mpd_status_get_song_id(c->status) >= 0) {
224 c->song = playlist_get_song(&c->playlist,
225 mpd_status_get_song_pos(c->status));
226 }
227
228 return true;
229 }
230
231 struct mpd_connection *
232 mpdclient_get_connection(struct mpdclient *c)
233 {
234 if (c->source != NULL && c->idle) {
235 c->idle = false;
236 mpd_glib_leave(c->source);
237 }
238
239 return c->connection;
240 }
241
242 void
243 mpdclient_put_connection(struct mpdclient *c)
244 {
245 assert(c->source == NULL || c->connection != NULL);
246
247 if (c->source != NULL && !c->idle) {
248 c->idle = mpd_glib_enter(c->source);
249 }
250 }
251
252 static struct mpd_status *
253 mpdclient_recv_status(struct mpdclient *c)
254 {
255 struct mpd_status *status;
256
257 assert(c->connection != NULL);
258
259 status = mpd_recv_status(c->connection);
260 if (status == NULL) {
261 mpdclient_handle_error(c);
262 return NULL;
263 }
264
265 if (c->status != NULL)
266 mpd_status_free(c->status);
267 return c->status = status;
268 }
269
270 /****************************************************************************/
271 /*** MPD Commands **********************************************************/
272 /****************************************************************************/
273
274 bool
275 mpdclient_cmd_crop(struct mpdclient *c)
276 {
277 struct mpd_connection *connection;
278 int length, current;
279
280 if (!mpdclient_is_playing(c))
281 return false;
282
283 length = mpd_status_get_queue_length(c->status);
284 current = mpd_status_get_song_pos(c->status);
285 if (current < 0 || mpd_status_get_queue_length(c->status) < 2)
286 return true;
287
288 connection = mpdclient_get_connection(c);
289 if (connection == NULL)
290 return false;
291
292 mpd_command_list_begin(connection, false);
293
294 if (mpd_connection_cmp_server_version(connection, 0, 16, 0) >= 0) {
295 if (current < length - 1)
296 mpd_send_delete_range(connection, current + 1, length);
297 if (current > 0)
298 mpd_send_delete_range(connection, 0, current);
299 } else
300 while (--length >= 0)
301 if (length != current)
302 mpd_send_delete(connection, length);
303
304 mpd_command_list_end(connection);
305
306 return mpdclient_finish_command(c);
307 }
308
309 bool
310 mpdclient_cmd_clear(struct mpdclient *c)
311 {
312 struct mpd_connection *connection = mpdclient_get_connection(c);
313 struct mpd_status *status;
314
315 if (connection == NULL)
316 return false;
317
318 /* send "clear" and "status" */
319 if (!mpd_command_list_begin(connection, false) ||
320 !mpd_send_clear(connection) ||
321 !mpd_send_status(connection) ||
322 !mpd_command_list_end(connection))
323 return mpdclient_handle_error(c);
324
325 /* receive the new status, store it in the mpdclient struct */
326
327 status = mpdclient_recv_status(c);
328 if (status == NULL)
329 return false;
330
331 if (!mpd_response_finish(connection))
332 return mpdclient_handle_error(c);
333
334 /* update mpdclient.playlist */
335
336 if (mpd_status_get_queue_length(status) == 0) {
337 /* after the "clear" command, the queue is really
338 empty - this means we can clear it locally,
339 reducing the UI latency */
340 playlist_clear(&c->playlist);
341 c->playlist.version = mpd_status_get_queue_version(status);
342 c->song = NULL;
343 }
344
345 c->events |= MPD_IDLE_QUEUE;
346 return true;
347 }
348
349 bool
350 mpdclient_cmd_volume(struct mpdclient *c, gint value)
351 {
352 struct mpd_connection *connection = mpdclient_get_connection(c);
353 if (connection == NULL)
354 return false;
355
356 mpd_send_set_volume(connection, value);
357 return mpdclient_finish_command(c);
358 }
359
360 bool
361 mpdclient_cmd_volume_up(struct mpdclient *c)
362 {
363 struct mpd_connection *connection = mpdclient_get_connection(c);
364 if (connection == NULL)
365 return false;
366
367 if (c->status == NULL ||
368 mpd_status_get_volume(c->status) == -1)
369 return true;
370
371 if (c->volume < 0)
372 c->volume = mpd_status_get_volume(c->status);
373
374 if (c->volume >= 100)
375 return true;
376
377 return mpdclient_cmd_volume(c, ++c->volume);
378 }
379
380 bool
381 mpdclient_cmd_volume_down(struct mpdclient *c)
382 {
383 struct mpd_connection *connection = mpdclient_get_connection(c);
384 if (connection == NULL)
385 return false;
386
387 if (c->status == NULL || mpd_status_get_volume(c->status) < 0)
388 return true;
389
390 if (c->volume < 0)
391 c->volume = mpd_status_get_volume(c->status);
392
393 if (c->volume <= 0)
394 return true;
395
396 return mpdclient_cmd_volume(c, --c->volume);
397 }
398
399 bool
400 mpdclient_cmd_add_path(struct mpdclient *c, const gchar *path_utf8)
401 {
402 struct mpd_connection *connection = mpdclient_get_connection(c);
403 if (connection == NULL)
404 return false;
405
406 return mpd_send_add(connection, path_utf8)?
407 mpdclient_finish_command(c) : false;
408 }
409
410 bool
411 mpdclient_cmd_add(struct mpdclient *c, const struct mpd_song *song)
412 {
413 struct mpd_connection *connection = mpdclient_get_connection(c);
414 struct mpd_status *status;
415 struct mpd_song *new_song;
416
417 assert(c != NULL);
418 assert(song != NULL);
419
420 if (connection == NULL || c->status == NULL)
421 return false;
422
423 /* send the add command to mpd; at the same time, get the new
424 status (to verify the new playlist id) and the last song
425 (we hope that's the song we just added) */
426
427 if (!mpd_command_list_begin(connection, true) ||
428 !mpd_send_add(connection, mpd_song_get_uri(song)) ||
429 !mpd_send_status(connection) ||
430 !mpd_send_get_queue_song_pos(connection,
431 playlist_length(&c->playlist)) ||
432 !mpd_command_list_end(connection) ||
433 !mpd_response_next(connection))
434 return mpdclient_handle_error(c);
435
436 c->events |= MPD_IDLE_QUEUE;
437
438 status = mpdclient_recv_status(c);
439 if (status == NULL)
440 return false;
441
442 if (!mpd_response_next(connection))
443 return mpdclient_handle_error(c);
444
445 new_song = mpd_recv_song(connection);
446 if (!mpd_response_finish(connection) || new_song == NULL) {
447 if (new_song != NULL)
448 mpd_song_free(new_song);
449
450 return mpd_connection_clear_error(connection) ||
451 mpdclient_handle_error(c);
452 }
453
454 if (mpd_status_get_queue_length(status) == playlist_length(&c->playlist) + 1 &&
455 mpd_status_get_queue_version(status) == c->playlist.version + 1) {
456 /* the cheap route: match on the new playlist length
457 and its version, we can keep our local playlist
458 copy in sync */
459 c->playlist.version = mpd_status_get_queue_version(status);
460
461 /* the song we just received has the correct id;
462 append it to the local playlist */
463 playlist_append(&c->playlist, new_song);
464 }
465
466 mpd_song_free(new_song);
467
468 return true;
469 }
470
471 bool
472 mpdclient_cmd_delete(struct mpdclient *c, gint idx)
473 {
474 struct mpd_connection *connection = mpdclient_get_connection(c);
475 const struct mpd_song *song;
476 struct mpd_status *status;
477
478 if (connection == NULL || c->status == NULL)
479 return false;
480
481 if (idx < 0 || (guint)idx >= playlist_length(&c->playlist))
482 return false;
483
484 song = playlist_get(&c->playlist, idx);
485
486 /* send the delete command to mpd; at the same time, get the
487 new status (to verify the playlist id) */
488
489 if (!mpd_command_list_begin(connection, false) ||
490 !mpd_send_delete_id(connection, mpd_song_get_id(song)) ||
491 !mpd_send_status(connection) ||
492 !mpd_command_list_end(connection))
493 return mpdclient_handle_error(c);
494
495 c->events |= MPD_IDLE_QUEUE;
496
497 status = mpdclient_recv_status(c);
498 if (status == NULL)
499 return false;
500
501 if (!mpd_response_finish(connection))
502 return mpdclient_handle_error(c);
503
504 if (mpd_status_get_queue_length(status) == playlist_length(&c->playlist) - 1 &&
505 mpd_status_get_queue_version(status) == c->playlist.version + 1) {
506 /* the cheap route: match on the new playlist length
507 and its version, we can keep our local playlist
508 copy in sync */
509 c->playlist.version = mpd_status_get_queue_version(status);
510
511 /* remove the song from the local playlist */
512 playlist_remove(&c->playlist, idx);
513
514 /* remove references to the song */
515 if (c->song == song)
516 c->song = NULL;
517 }
518
519 return true;
520 }
521
522 /**
523 * Fallback for mpdclient_cmd_delete_range() on MPD older than 0.16.
524 * It emulates the "delete range" command with a list of simple
525 * "delete" commands.
526 */
527 static bool
528 mpdclient_cmd_delete_range_fallback(struct mpdclient *c,
529 unsigned start, unsigned end)
530 {
531 struct mpd_connection *connection = mpdclient_get_connection(c);
532 if (connection == NULL)
533 return false;
534
535 if (!mpd_command_list_begin(connection, false))
536 return mpdclient_handle_error(c);
537
538 for (; start < end; --end)
539 mpd_send_delete(connection, start);
540
541 if (!mpd_command_list_end(connection) ||
542 !mpd_response_finish(connection))
543 return mpdclient_handle_error(c);
544
545 return true;
546 }
547
548 bool
549 mpdclient_cmd_delete_range(struct mpdclient *c, unsigned start, unsigned end)
550 {
551 struct mpd_connection *connection;
552 struct mpd_status *status;
553
554 if (end == start + 1)
555 /* if that's not really a range, we choose to use the
556 safer "deleteid" version */
557 return mpdclient_cmd_delete(c, start);
558
559 connection = mpdclient_get_connection(c);
560 if (connection == NULL)
561 return false;
562
563 if (mpd_connection_cmp_server_version(connection, 0, 16, 0) < 0)
564 return mpdclient_cmd_delete_range_fallback(c, start, end);
565
566 /* MPD 0.16 supports "delete" with a range argument */
567
568 /* send the delete command to mpd; at the same time, get the
569 new status (to verify the playlist id) */
570
571 if (!mpd_command_list_begin(connection, false) ||
572 !mpd_send_delete_range(connection, start, end) ||
573 !mpd_send_status(connection) ||
574 !mpd_command_list_end(connection))
575 return mpdclient_handle_error(c);
576
577 c->events |= MPD_IDLE_QUEUE;
578
579 status = mpdclient_recv_status(c);
580 if (status == NULL)
581 return false;
582
583 if (!mpd_response_finish(connection))
584 return mpdclient_handle_error(c);
585
586 if (mpd_status_get_queue_length(status) == playlist_length(&c->playlist) - (end - start) &&
587 mpd_status_get_queue_version(status) == c->playlist.version + 1) {
588 /* the cheap route: match on the new playlist length
589 and its version, we can keep our local playlist
590 copy in sync */
591 c->playlist.version = mpd_status_get_queue_version(status);
592
593 /* remove the song from the local playlist */
594 while (end > start) {
595 --end;
596
597 /* remove references to the song */
598 if (c->song == playlist_get(&c->playlist, end))
599 c->song = NULL;
600
601 playlist_remove(&c->playlist, end);
602 }
603 }
604
605 return true;
606 }
607
608 bool
609 mpdclient_cmd_move(struct mpdclient *c, unsigned dest_pos, unsigned src_pos)
610 {
611 struct mpd_connection *connection;
612 struct mpd_status *status;
613
614 if (dest_pos == src_pos)
615 return true;
616
617 connection = mpdclient_get_connection(c);
618 if (connection == NULL)
619 return false;
620
621 /* send the "move" command to MPD; at the same time, get the
622 new status (to verify the playlist id) */
623
624 if (!mpd_command_list_begin(connection, false) ||
625 !mpd_send_move(connection, src_pos, dest_pos) ||
626 !mpd_send_status(connection) ||
627 !mpd_command_list_end(connection))
628 return mpdclient_handle_error(c);
629
630 c->events |= MPD_IDLE_QUEUE;
631
632 status = mpdclient_recv_status(c);
633 if (status == NULL)
634 return false;
635
636 if (!mpd_response_finish(connection))
637 return mpdclient_handle_error(c);
638
639 if (mpd_status_get_queue_length(status) == playlist_length(&c->playlist) &&
640 mpd_status_get_queue_version(status) == c->playlist.version + 1) {
641 /* the cheap route: match on the new playlist length
642 and its version, we can keep our local playlist
643 copy in sync */
644 c->playlist.version = mpd_status_get_queue_version(status);
645
646 /* swap songs in the local playlist */
647 playlist_move(&c->playlist, dest_pos, src_pos);
648 }
649
650 return true;
651 }
652
653
654 /****************************************************************************/
655 /*** Playlist management functions ******************************************/
656 /****************************************************************************/
657
658 /* update playlist */
659 bool
660 mpdclient_playlist_update(struct mpdclient *c)
661 {
662 struct mpd_connection *connection = mpdclient_get_connection(c);
663 struct mpd_entity *entity;
664
665 if (connection == NULL)
666 return false;
667
668 playlist_clear(&c->playlist);
669
670 mpd_send_list_queue_meta(connection);
671 while ((entity = mpd_recv_entity(connection))) {
672 if (mpd_entity_get_type(entity) == MPD_ENTITY_TYPE_SONG)
673 playlist_append(&c->playlist, mpd_entity_get_song(entity));
674
675 mpd_entity_free(entity);
676 }
677
678 c->playlist.version = mpd_status_get_queue_version(c->status);
679 c->song = NULL;
680
681 return mpdclient_finish_command(c);
682 }
683
684 /* update playlist (plchanges) */
685 bool
686 mpdclient_playlist_update_changes(struct mpdclient *c)
687 {
688 struct mpd_connection *connection = mpdclient_get_connection(c);
689 struct mpd_song *song;
690 guint length;
691
692 if (connection == NULL)
693 return false;
694
695 mpd_send_queue_changes_meta(connection, c->playlist.version);
696
697 while ((song = mpd_recv_song(connection)) != NULL) {
698 int pos = mpd_song_get_pos(song);
699
700 if (pos >= 0 && (guint)pos < c->playlist.list->len) {
701 /* update song */
702 playlist_replace(&c->playlist, pos, song);
703 } else {
704 /* add a new song */
705 playlist_append(&c->playlist, song);
706 }
707
708 mpd_song_free(song);
709 }
710
711 /* remove trailing songs */
712
713 length = mpd_status_get_queue_length(c->status);
714 while (length < c->playlist.list->len) {
715 guint pos = c->playlist.list->len - 1;
716
717 /* Remove the last playlist entry */
718 playlist_remove(&c->playlist, pos);
719 }
720
721 c->song = NULL;
722 c->playlist.version = mpd_status_get_queue_version(c->status);
723
724 return mpdclient_finish_command(c);
725 }
726
727
728 /****************************************************************************/
729 /*** Filelist functions *****************************************************/
730 /****************************************************************************/
731
732 bool
733 mpdclient_filelist_add_all(struct mpdclient *c, struct filelist *fl)
734 {
735 struct mpd_connection *connection = mpdclient_get_connection(c);
736 guint i;
737
738 if (connection == NULL)
739 return false;
740
741 if (filelist_is_empty(fl))
742 return true;
743
744 mpd_command_list_begin(connection, false);
745
746 for (i = 0; i < filelist_length(fl); ++i) {
747 struct filelist_entry *entry = filelist_get(fl, i);
748 struct mpd_entity *entity = entry->entity;
749
750 if (entity != NULL &&
751 mpd_entity_get_type(entity) == MPD_ENTITY_TYPE_SONG) {
752 const struct mpd_song *song =
753 mpd_entity_get_song(entity);
754
755 mpd_send_add(connection, mpd_song_get_uri(song));
756 }
757 }
758
759 mpd_command_list_end(connection);
760 return mpdclient_finish_command(c);
761 }
A ncurses (command line) interface for MPD.