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 3 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
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 /** @file disobedience/log.c
  19  * @brief State monitoring
  20  *
  21  * Disobedience relies on the server to tell when essentially anything changes,
  22  * even if it initiated the change itself.  It uses the @c log command to
  23  * achieve this.
  24  */
  25
  26 #include "disobedience.h"
  27
  28 /* State monitoring -------------------------------------------------------- */
  29
  30 static void log_connected(void *v);
  31 static void log_completed(void *v, const char *track);
  32 static void log_failed(void *v, const char *track, const char *status);
  33 static void log_moved(void *v, const char *user);
  34 static void log_playing(void *v, const char *track, const char *user);
  35 static void log_queue(void *v, struct queue_entry *q);
  36 static void log_recent_added(void *v, struct queue_entry *q);
  37 static void log_recent_removed(void *v, const char *id);
  38 static void log_removed(void *v, const char *id, const char *user);
  39 static void log_scratched(void *v, const char *track, const char *user);
  40 static void log_state(void *v, unsigned long state);
  41 static void log_volume(void *v, int l, int r);
  42 static void log_rescanned(void *v);
  43 static void log_rights_changed(void *v, rights_type r);
  44 static void log_adopted(void *v, const char *id, const char *user);
  45 static void log_playlist_created(void *v,
  46                                  const char *playlist, const char *sharing);
  47 static void log_playlist_modified(void *v,
  48                                   const char *playlist, const char *sharing);
  49 static void log_playlist_deleted(void *v,
  50                                  const char *playlist);
  51
  52 /** @brief Callbacks for server state monitoring */
  53 const disorder_eclient_log_callbacks log_callbacks = {
  54   .connected = log_connected,
  55   .completed = log_completed,
  56   .failed = log_failed,
  57   .moved = log_moved,
  58   .playing = log_playing,
  59   .queue = log_queue,
  60   .recent_added = log_recent_added,
  61   .recent_removed = log_recent_removed,
  62   .removed = log_removed,
  63   .scratched = log_scratched,
  64   .state = log_state,
  65   .volume = log_volume,
  66   .rescanned = log_rescanned,
  67   .rights_changed = log_rights_changed,
  68   .adopted = log_adopted,
  69   .playlist_created = log_playlist_created,
  70   .playlist_modified = log_playlist_modified,
  71   .playlist_deleted = log_playlist_deleted,
  72 };
  73
  74 /** @brief Update everything */
  75 void all_update(void) {
  76   ++suppress_actions;
  77   event_raise("queue-changed", 0);
  78   event_raise("recent-changed", 0);
  79   event_raise("volume-changed", 0);
  80   event_raise("rescan-complete", 0);
  81   --suppress_actions;
  82 }
  83
  84 /** @brief Called when the client connects
  85  *
  86  * Depending on server and network state the TCP connection to the server may
  87  * go up or down many times during the lifetime of Disobedience.  This function
  88  * is called whenever it connects.
  89  */
  90 static void log_connected(void attribute((unused)) *v) {
  91   /* Don't know what we might have missed while disconnected so update
  92    * everything.  We get this at startup too and this is how we do the initial
  93    * state fetch. */
  94   all_update();
  95   event_raise("log-connected", 0);
  96 }
  97
  98 /** @brief Called when the current track finishes playing */
  99 static void log_completed(void attribute((unused)) *v,
 100                           const char attribute((unused)) *track) {
 101 }
 102
 103 /** @brief Called when the current track fails */
 104 static void log_failed(void attribute((unused)) *v,
 105                        const char attribute((unused)) *track,
 106                        const char attribute((unused)) *status) {
 107 }
 108
 109 /** @brief Called when some track is moved within the queue */
 110 static void log_moved(void attribute((unused)) *v,
 111                       const char attribute((unused)) *user) {
 112   event_raise("queue-changed", 0);
 113 }
 114
 115 static void log_playing(void attribute((unused)) *v,
 116                         const char attribute((unused)) *track,
 117                         const char attribute((unused)) *user) {
 118   event_raise("playing-started", 0);
 119 }
 120
 121 /** @brief Called when a track is added to the queue */
 122 static void log_queue(void attribute((unused)) *v,
 123                       struct queue_entry attribute((unused)) *q) {
 124   event_raise("queue-changed", 0);
 125 }
 126
 127 /** @brief Called when a track is added to the recently-played list */
 128 static void log_recent_added(void attribute((unused)) *v,
 129                              struct queue_entry attribute((unused)) *q) {
 130   event_raise("recent-changed", 0);
 131 }
 132
 133 /** @brief Called when a track is removed from the recently-played list
 134  *
 135  * We do nothing here - log_recent_added() suffices.
 136  */
 137 static void log_recent_removed(void attribute((unused)) *v,
 138                                const char attribute((unused)) *id) {
 139   /* nothing - log_recent_added() will trigger the relevant update */
 140 }
 141
 142 /** @brief Called when a track is removed from the queue */
 143 static void log_removed(void attribute((unused)) *v,
 144                         const char attribute((unused)) *id,
 145                         const char attribute((unused)) *user) {
 146   event_raise("queue-changed", 0);
 147 }
 148
 149 /** @brief Called when the current track is scratched */
 150 static void log_scratched(void attribute((unused)) *v,
 151                           const char attribute((unused)) *track,
 152                           const char attribute((unused)) *user) {
 153 }
 154
 155 /** @brief Map from state bits to state change events */
 156 static const struct {
 157   unsigned long bit;
 158   const char *event;
 159 } state_events[] = {
 160   { DISORDER_PLAYING_ENABLED, "enabled-changed" },
 161   { DISORDER_RANDOM_ENABLED, "random-changed" },
 162   { DISORDER_TRACK_PAUSED, "pause-changed" },
 163   { DISORDER_PLAYING, "playing-changed" },
 164   { DISORDER_CONNECTED, "connected-changed" },
 165 };
 166 #define NSTATE_EVENTS (sizeof state_events / sizeof *state_events)
 167
 168 /** @brief Called when a state change occurs */
 169 static void log_state(void attribute((unused)) *v,
 170                       unsigned long state) {
 171   unsigned long changes = state ^ last_state;
 172   static int first = 1;
 173
 174   ++suppress_actions;
 175   if(first) {
 176     changes = -1UL;
 177     first = 0;
 178   }
 179   D(("log_state old=%s new=%s changed=%s",
 180      disorder_eclient_interpret_state(last_state),
 181      disorder_eclient_interpret_state(state),
 182      disorder_eclient_interpret_state(changes)));
 183   last_state = state;
 184   /* Notify interested parties what has changed */
 185   for(unsigned n = 0; n < NSTATE_EVENTS; ++n)
 186     if(changes & state_events[n].bit)
 187       event_raise(state_events[n].event, 0);
 188   --suppress_actions;
 189 }
 190
 191 /** @brief Called when volume changes */
 192 static void log_volume(void attribute((unused)) *v,
 193                        int l, int r) {
 194   if(!rtp_supported && (volume_l != l || volume_r != r)) {
 195     volume_l = l;
 196     volume_r = r;
 197     ++suppress_actions;
 198     event_raise("volume-changed", 0);
 199     --suppress_actions;
 200   }
 201 }
 202
 203 /** @brief Called when a rescan completes */
 204 static void log_rescanned(void attribute((unused)) *v) {
 205   event_raise("rescan-complete", 0);
 206 }
 207
 208 /** @brief Called when our rights change */
 209 static void log_rights_changed(void attribute((unused)) *v,
 210                                rights_type new_rights) {
 211   ++suppress_actions;
 212   last_rights = new_rights;
 213   event_raise("rights-changed", 0);
 214   --suppress_actions;
 215 }
 216
 217 /** @brief Called when a track is adopted */
 218 static void log_adopted(void attribute((unused)) *v,
 219                         const char attribute((unused)) *id,
 220                         const char attribute((unused)) *who) {
 221   event_raise("queue-changed", 0);
 222 }
 223
 224 static void log_playlist_created(void attribute((unused)) *v,
 225                                  const char *playlist,
 226                                  const char attribute((unused)) *sharing) {
 227   event_raise("playlist-created", (void *)playlist);
 228 }
 229
 230 static void log_playlist_modified(void attribute((unused)) *v,
 231                                   const char *playlist,
 232                                   const char attribute((unused)) *sharing) {
 233   event_raise("playlist-modified", (void *)playlist);
 234 }
 235
 236 static void log_playlist_deleted(void attribute((unused)) *v,
 237                                  const char *playlist) {
 238   event_raise("playlist-deleted", (void *)playlist);
 239 }
 240
 241 /*
 242 Local Variables:
 243 c-basic-offset:2
 244 comment-column:40
 245 fill-column:79
 246 indent-tabs-mode:nil
 247 End:
 248 */