chiark - git - mdw - disorder/blob - disobedience/log.c

   1 /*
   2  * This file is part of DisOrder.
   3  * Copyright (C) 2006, 2007 Richard Kettlewell
   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, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  18  * USA
  19  */
  20
  21 #include "disobedience.h"
  22
  23 /* State monitoring -------------------------------------------------------- */
  24
  25 static void log_connected(void *v);
  26 static void log_completed(void *v, const char *track);
  27 static void log_failed(void *v, const char *track, const char *status);
  28 static void log_moved(void *v, const char *user);
  29 static void log_playing(void *v, const char *track, const char *user);
  30 static void log_queue(void *v, struct queue_entry *q);
  31 static void log_recent_added(void *v, struct queue_entry *q);
  32 static void log_recent_removed(void *v, const char *id);
  33 static void log_removed(void *v, const char *id, const char *user);
  34 static void log_scratched(void *v, const char *track, const char *user);
  35 static void log_state(void *v, unsigned long state);
  36 static void log_volume(void *v, int l, int r);
  37
  38 /** @brief Callbacks for server state monitoring */
  39 const disorder_eclient_log_callbacks log_callbacks = {
  40   log_connected,
  41   log_completed,
  42   log_failed,
  43   log_moved,
  44   log_playing,
  45   log_queue,
  46   log_recent_added,
  47   log_recent_removed,
  48   log_removed,
  49   log_scratched,
  50   log_state,
  51   log_volume
  52 };
  53
  54 struct monitor {
  55   struct monitor *next;
  56   unsigned long mask;
  57   monitor_callback *callback;
  58   void *u;
  59 };
  60
  61 static struct monitor *monitors;
  62
  63 void all_update(void) {
  64   playing_update();
  65   queue_update();
  66   recent_update();
  67   control_update();
  68 }
  69
  70 static void log_connected(void attribute((unused)) *v) {
  71   struct callbackdata *cbd;
  72
  73   /* Don't know what we might have missed while disconnected so update
  74    * everything.  We get this at startup too and this is how we do the initial
  75    * state fetch. */
  76   all_update();
  77   /* Re-get the volume */
  78   cbd = xmalloc(sizeof *cbd);
  79   cbd->onerror = 0;
  80   disorder_eclient_volume(client, log_volume, -1, -1, cbd);
  81 }
  82
  83 static void log_completed(void attribute((unused)) *v,
  84                           const char attribute((unused)) *track) {
  85   playing = 0;
  86   playing_update();
  87   control_update();
  88 }
  89
  90 static void log_failed(void attribute((unused)) *v,
  91                        const char attribute((unused)) *track,
  92                        const char attribute((unused)) *status) {
  93   playing = 0;
  94   playing_update();
  95   control_update();
  96 }
  97
  98 static void log_moved(void attribute((unused)) *v,
  99                       const char attribute((unused)) *user) {
 100    queue_update();
 101 }
 102
 103 static void log_playing(void attribute((unused)) *v,
 104                         const char attribute((unused)) *track,
 105                         const char attribute((unused)) *user) {
 106   playing = 1;
 107   playing_update();
 108   control_update();
 109   /* we get a log_removed() anyway so we don't need to update_queue() from
 110    * here */
 111 }
 112
 113 static void log_queue(void attribute((unused)) *v,
 114                       struct queue_entry attribute((unused)) *q) {
 115   queue_update();
 116 }
 117
 118 static void log_recent_added(void attribute((unused)) *v,
 119                              struct queue_entry attribute((unused)) *q) {
 120   recent_update();
 121 }
 122
 123 static void log_recent_removed(void attribute((unused)) *v,
 124                                const char attribute((unused)) *id) {
 125   /* nothing - log_recent_added() will trigger the relevant update */
 126 }
 127
 128 static void log_removed(void attribute((unused)) *v,
 129                         const char attribute((unused)) *id,
 130                         const char attribute((unused)) *user) {
 131   queue_update();
 132 }
 133
 134 static void log_scratched(void attribute((unused)) *v,
 135                           const char attribute((unused)) *track,
 136                           const char attribute((unused)) *user) {
 137   playing = 0;
 138   playing_update();
 139   control_update();
 140 }
 141
 142 static void log_state(void attribute((unused)) *v,
 143                       unsigned long state) {
 144   const struct monitor *m;
 145   const unsigned long changes = state ^ last_state;
 146
 147   info("log_state %s", disorder_eclient_interpret_state(state));
 148   last_state = state;
 149   /* Tell anything that cares about the state change */
 150   for(m = monitors; m; m = m->next) {
 151     if(changes & m->mask)
 152       m->callback(m->u);
 153   }
 154   /* If the track is paused or resume then the currently playing track is
 155    * refetched so that we can continue to correctly calculate the played so-far
 156    * field */
 157   playing_update();
 158 }
 159
 160 static void log_volume(void attribute((unused)) *v,
 161                        int l, int r) {
 162   if(volume_l != l || volume_r != r) {
 163     volume_l = l;
 164     volume_r = r;
 165     control_update();
 166   }
 167 }
 168
 169 void register_monitor(monitor_callback *callback,
 170                       void *u,
 171                       unsigned long mask) {
 172   struct monitor *m = xmalloc(sizeof *m);
 173
 174   m->next = monitors;
 175   m->mask = mask;
 176   m->callback = callback;
 177   m->u = u;
 178   monitors = m;
 179 }
 180
 181 /*
 182 Local Variables:
 183 c-basic-offset:2
 184 comment-column:40
 185 fill-column:79
 186 indent-tabs-mode:nil
 187 End:
 188 */