medialib.cpp

   1 //
   2 // C++ Implementation: medialib
   3 //
   4 // Author: Oliver Groß <z.o.gross@gmx.de>, (C) 2008
   5 //
   6 // Copyright: See COPYING file that comes with this distribution
   7 //
   8 #include "medialib.h"
   9 #include "client.h"
  10 #include "common.h"
  11 #include <QDebug>
  12 namespace XmmsQt {
  13         QMedialib::QMedialib(QClient * parent) : QObject(parent), m_Connection(0) {
  14                 connect(parent, SIGNAL(connectionChanged(xmmsc_connection_t *)),
  15                         this,   SLOT(setConnection(xmmsc_connection_t *)));
  16         }
  17
  18         QMedialib::~QMedialib() {
  19                 clearMediaInfo();
  20                 foreach(QPlaylist * i, m_Playlists)
  21                         delete i;
  22                 m_Playlists.clear();
  23         }
  24
  25         void QMedialib::playlistChangedCallback(xmmsc_result_t * result, void * instance) {
  26                 if (instance) {
  27                         QMedialib * medialib = static_cast<QMedialib *>(instance);
  28                         char * strBuffer;
  29                         xmmsc_result_get_dict_entry_string(result, "name", &strBuffer);
  30                         QString name = strBuffer;
  31                         QPlaylist::changedCallback(result, medialib->m_Playlists[name]);
  32                 }
  33         }
  34
  35         void QMedialib::currentPosCallback(xmmsc_result_t * result, void * instance) {
  36                 if (instance) {
  37                         QMedialib * medialib = static_cast<QMedialib *>(instance);
  38
  39                         QPlaylist::currentPosCallback(result, medialib->m_ActivePlaylist);
  40                 }
  41                 //xmmsc_result_unref(result);
  42         }
  43
  44         void QMedialib::activePlaylistCallback(xmmsc_result_t * result, void * instance) {
  45                 if (instance) {
  46                         QMedialib * medialib = static_cast<QMedialib *>(instance);
  47                         char * strBuffer;
  48                         xmmsc_result_get_string(result, &strBuffer);
  49                         medialib->m_ActivePlaylist = medialib->m_Playlists[QString(strBuffer)];
  50
  51                         emit medialib->activePlaylistChanged();
  52                 }
  53                 //xmmsc_result_unref(result);
  54         }
  55
  56         void QMedialib::fillPlaylists(xmmsc_result_t * result, void * instance) {
  57                 if (instance) {
  58                         QMedialib * medialib = static_cast<QMedialib *>(instance);
  59
  60                         char * strBuffer;
  61
  62                         xmmsc_result_t * i = result;
  63                         while (xmmsc_result_list_valid(i)) {
  64                                 xmmsc_result_get_string(i, &strBuffer);
  65                                 medialib->m_Playlists.insert(QString(strBuffer), new QPlaylist((QClient *)(medialib->parent()), QString(strBuffer)));
  66                                 xmmsc_result_list_next(i);
  67                         }
  68                         emit medialib->playlistsReseted();
  69                 }
  70         }
  71
  72         void QMedialib::collectionChangedCallback(xmmsc_result_t * result, void * instance) {
  73                 if (instance) {
  74                         QMedialib * medialib = static_cast<QMedialib *>(instance);
  75
  76                         xmms_collection_changed_actions_t type;
  77                         xmmsc_result_get_dict_entry_int(result, "type", (qint32 *)(&type));
  78
  79                         char * strBuffer;
  80
  81                         xmmsc_result_get_dict_entry_string(result, "namespace", &strBuffer);
  82                         QString collNamespace = strBuffer;
  83
  84                         xmmsc_result_get_dict_entry_string(result, "name", &strBuffer);
  85                         QString collName = strBuffer;
  86
  87                         //currently we only support playlists
  88                         if (QString(collNamespace) != "Playlists")
  89                                 return;
  90
  91                         switch (type) {
  92                         case XMMS_COLLECTION_CHANGED_ADD:
  93                                 medialib->m_Playlists.insert(collName, new QPlaylist((QClient *)(medialib->parent()), collName));
  94                                 emit medialib->collectionAdded(collName);
  95                                 break;
  96                         case XMMS_COLLECTION_CHANGED_RENAME:
  97                                 xmmsc_result_get_dict_entry_string(result, "newname", &strBuffer);
  98                                 {
  99                                         QString collNewName = strBuffer;
 100                                         medialib->m_Playlists.insert(collNewName, medialib->m_Playlists.take(collName));
 101
 102                                         emit medialib->collectionRenamed(collName, collNewName);
 103                                 }
 104                                 break;
 105                         case XMMS_COLLECTION_CHANGED_UPDATE:
 106                                 emit medialib->collectionUpdated(collName);
 107                                 break;
 108                         case XMMS_COLLECTION_CHANGED_REMOVE:
 109                                 if (medialib->m_Playlists.contains(collName)) {
 110                                         delete medialib->m_Playlists.take(collName);
 111                                         emit medialib->collectionRemoved(collName);
 112                                 }
 113                                 break;
 114                         default:
 115                                 break;
 116                         }
 117                 }
 118         }
 119
 120         void QMedialib::recievedMediaInfoCallback(xmmsc_result_t * result, void * instance) {
 121                 if (instance) {
 122                         QMedialib * medialib = static_cast<QMedialib *>(instance);
 123                         int intBuffer, id;
 124                         char * strBuffer;
 125
 126                         xmmsc_result_get_dict_entry_int(result, "id", &id);
 127                         MediaInfo * newMediaInfo = new MediaInfo();
 128
 129                         xmmsc_result_get_dict_entry_string(result, "genre",  &strBuffer);
 130                         newMediaInfo->genre = strBuffer;
 131                         xmmsc_result_get_dict_entry_string(result, "album",  &strBuffer);
 132                         newMediaInfo->album = strBuffer;
 133                         xmmsc_result_get_dict_entry_string(result, "artist", &strBuffer);
 134                         newMediaInfo->artist = strBuffer;
 135                         xmmsc_result_get_dict_entry_string(result, "title",  &strBuffer);
 136                         newMediaInfo->title = strBuffer;
 137
 138                         xmmsc_result_get_dict_entry_int(result, "duration", &intBuffer);
 139                         newMediaInfo->duration = intBuffer;
 140                         xmmsc_result_get_dict_entry_int(result, "channels", &intBuffer);
 141                         newMediaInfo->channels = intBuffer;
 142                         xmmsc_result_get_dict_entry_int(result, "samplerate", &intBuffer);
 143                         newMediaInfo->sampleRate = intBuffer;
 144                         xmmsc_result_get_dict_entry_int(result, "sample_format", &intBuffer);
 145                         newMediaInfo->sampleFormat = intBuffer;
 146
 147                         medialib->m_CachedMedia.insert(id, newMediaInfo);
 148                         emit medialib->mediaInfoReady(id);
 149                 }
 150                 xmmsc_result_unref(result);
 151         }
 152
 153         void QMedialib::setConnection(xmmsc_connection_t * connection) {
 154                 if (m_Connection == connection)
 155                         return;
 156
 157                 //disconnect
 158                 if (m_Connection) {
 159                         disconnectNotifierUnref(xmmsc_broadcast_playlist_loaded(m_Connection));
 160                         disconnectNotifierUnref(xmmsc_broadcast_playlist_changed(m_Connection));
 161                         disconnectNotifierUnref(xmmsc_broadcast_playlist_current_pos(m_Connection));
 162                         disconnectNotifierUnref(xmmsc_broadcast_collection_changed(m_Connection));
 163                 }
 164
 165                 m_Connection = connection;
 166
 167                 //connect
 168                 if (m_Connection) {
 169                         connectNotifierUnref(xmmsc_broadcast_playlist_loaded(m_Connection), activePlaylistCallback, this);
 170                         connectNotifierUnref(xmmsc_broadcast_playlist_changed(m_Connection), playlistChangedCallback, this);
 171                         connectNotifierUnref(xmmsc_broadcast_playlist_current_pos(m_Connection), currentPosCallback, this);
 172                         connectNotifierUnref(xmmsc_broadcast_collection_changed(m_Connection), collectionChangedCallback, this);
 173
 174                         connectNotifierUnref(xmmsc_playlist_list(m_Connection), fillPlaylists, this);
 175                 }
 176
 177                 clearMediaInfo();
 178         }
 179
 180         void QMedialib::setActivePlaylist(QString name) {
 181                 xmmsc_result_unref(xmmsc_playlist_load(m_Connection, name.toAscii().data()));
 182         }
 183
 184         void QMedialib::clearMediaInfo() {
 185                 foreach (MediaInfo * i, m_CachedMedia)
 186                         delete i;
 187                 m_CachedMedia.clear();
 188         }
 189
 190         void QMedialib::removeMediaInfo(quint32 id) {
 191                 delete m_CachedMedia.take(id);
 192         }
 193
 194         bool QMedialib::checkMediaInfo(quint32 id) {
 195                 if (m_CachedMedia.contains(id))
 196                         return true;
 197                 else {
 198                         requestMediaInfo(id);
 199                         return false;
 200                 }
 201         }
 202
 203         void QMedialib::requestMediaInfo(quint32 id) {
 204                 connectNotifierUnref(xmmsc_medialib_get_info(m_Connection, id), recievedMediaInfoCallback, this);
 205         }
 206 }