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