libkcompactdisc/kcompactdisc.cpp

   1 /*
   2  *  KCompactDisc - A CD drive interface for the KDE Project.
   3  *
   4  *  Copyright (C) 2005 Shaheedur R. Haque <srhaque@iee.org>
   5  *  Copyright (C) 2007 Alexander Kern <alex.kern@gmx.de>
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2, or (at your option)
  10  *  any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  */
  21
  22 #include "kcompactdisc.h"
  23 #include "kcompactdisc_p.h"
  24
  25 #include <QtDBus>
  26
  27 #include <kdebug.h>
  28 #include <kurl.h>
  29 #include <klocale.h>
  30
  31 #include <solid/device.h>
  32 #include <solid/block.h>
  33 #include <solid/opticaldrive.h>
  34
  35 static QMap<QString, KUrl> cdromsNameToDeviceUrl;
  36 static QMap<QString, QString> cdromsNameToUdi;
  37 static QString ___null = QString();
  38
  39 static void refreshListOfCdromDevices()
  40 {
  41     cdromsNameToDeviceUrl.clear();
  42     cdromsNameToUdi.clear();
  43     QString name, type;
  44     KUrl url;
  45
  46     //get a list of all devices that are Cdrom
  47     foreach(Solid::Device device, Solid::Device::listFromType(Solid::DeviceInterface::OpticalDrive)) {
  48         kDebug() << device.udi().toLatin1().constData();
  49         Solid::Block *b = device.as<Solid::Block>();
  50         Solid::OpticalDrive *o = device.as<Solid::OpticalDrive>();
  51         Solid::OpticalDrive::MediumTypes mediumType = o->supportedMedia();
  52
  53         url = KUrl::fromPath(b->device().toLatin1());
  54
  55         if(mediumType < Solid::OpticalDrive::Cdrw) {
  56             type = "CD-ROM";
  57         } else if(mediumType < Solid::OpticalDrive::Dvd) {
  58             type = "CDRW";
  59         } else if(mediumType < Solid::OpticalDrive::Dvdr) {
  60             type = "DVD-ROM";
  61         } else if(mediumType < Solid::OpticalDrive::Bd) {
  62             type = "DVDRW";
  63         } else if(mediumType < Solid::OpticalDrive::HdDvd) {
  64             type = "Blu-ray";
  65         } else {
  66             type = "High Density DVD";
  67         }
  68
  69         if(!device.vendor().isEmpty())
  70             name = (QString('[') + type + " - " + device.vendor() + " - " + device.product() + "]");
  71         else
  72             name = (QString('[') + type + " - unknown vendor - " + device.product() + "]");
  73
  74         cdromsNameToDeviceUrl.insert(name, url);
  75         cdromsNameToUdi.insert(name, device.udi());
  76     }
  77 #if 0
  78     if(cdromsNameToDeviceUrl.empty()) {
  79         cdromsNameToDeviceUrl.insert(QString("Generic CDROM []"), KUrl::fromPath(wm_drive_default_device()));
  80     }
  81 #endif
  82 }
  83
  84 static QMap<QString, KUrl> &getListOfCdromDevicesNamesAndUrl()
  85 {
  86     if(cdromsNameToDeviceUrl.empty())
  87         refreshListOfCdromDevices();
  88
  89     return cdromsNameToDeviceUrl;
  90 }
  91
  92 static QMap<QString, QString> &getListOfCdromDevicesNamesAndUdi()
  93 {
  94     if(cdromsNameToUdi.empty())
  95         refreshListOfCdromDevices();
  96
  97     return cdromsNameToUdi;
  98 }
  99
 100 QString KCompactDisc::urlToDevice(const KUrl& deviceUrl)
 101 {
 102     if(deviceUrl.protocol() == "media" || deviceUrl.protocol() == "system") {
 103         kDebug() << "Asking mediamanager for " << deviceUrl.fileName();
 104
 105         QDBusInterface mediamanager( "org.kde.kded", "/modules/mediamanager", "org.kde.MediaManager" );
 106         QDBusReply<QStringList> reply = mediamanager.call("properties", deviceUrl.fileName());
 107
 108         QStringList properties = reply;
 109         if(!reply.isValid() || properties.count() < 6) {
 110             kError() << "Invalid reply from mediamanager" << endl;
 111             return deviceUrl.path();
 112         } else {
 113             kDebug() << "Reply from mediamanager " << properties[5];
 114             return properties[5];
 115         }
 116     } else if(deviceUrl.protocol() == "file") {
 117         return deviceUrl.path();
 118     } else {
 119         return QString();
 120     }
 121 }
 122
 123 const QStringList KCompactDisc::audioSystems()
 124 {
 125     QStringList list;
 126
 127     list << "phonon"
 128 #ifdef USE_ARTS
 129         << "arts"
 130 #endif
 131 #if defined(HAVE_LIBASOUND2)
 132         << "alsa"
 133 #endif
 134 #if defined(sun) || defined(__sun__)
 135         << "sun"
 136 #endif
 137     ;
 138     return list;
 139 }
 140
 141 const QStringList KCompactDisc::cdromDeviceNames()
 142 {
 143     return getListOfCdromDevicesNamesAndUrl().keys();
 144 }
 145
 146 const QString KCompactDisc::defaultCdromDeviceName()
 147 {
 148     return getListOfCdromDevicesNamesAndUrl().keys().at(0);
 149 }
 150
 151 const KUrl KCompactDisc::defaultCdromDeviceUrl()
 152 {
 153     return getListOfCdromDevicesNamesAndUrl().values().at(0);
 154 }
 155
 156 const KUrl KCompactDisc::cdromDeviceUrl(const QString &cdromDeviceName)
 157 {
 158     return getListOfCdromDevicesNamesAndUrl().value(cdromDeviceName, KCompactDisc::defaultCdromDeviceUrl());
 159 }
 160
 161 const QString KCompactDisc::defaultCdromDeviceUdi()
 162 {
 163     return getListOfCdromDevicesNamesAndUdi().values().at(0);
 164 }
 165
 166 const QString KCompactDisc::cdromDeviceUdi(const QString &cdromDeviceName)
 167 {
 168     return getListOfCdromDevicesNamesAndUdi().value(cdromDeviceName, KCompactDisc::defaultCdromDeviceUdi());
 169 }
 170
 171 KCompactDisc::KCompactDisc(InformationMode infoMode) :
 172     d_ptr(new KCompactDiscPrivate(this, KCompactDisc::defaultCdromDeviceName()))
 173 {
 174     Q_D(KCompactDisc);
 175     dummy_ptr = d;
 176     d->m_infoMode = infoMode;
 177 }
 178
 179 KCompactDisc::~KCompactDisc()
 180 {
 181     stop();
 182 }
 183
 184 const QString &KCompactDisc::deviceVendor()
 185 {
 186     Q_D(KCompactDisc);
 187     return d->m_deviceVendor;
 188 }
 189
 190 const QString &KCompactDisc::deviceModel()
 191 {
 192     Q_D(KCompactDisc);
 193     return d->m_deviceModel;
 194 }
 195
 196 const QString &KCompactDisc::deviceRevision()
 197 {
 198     Q_D(KCompactDisc);
 199     return d->m_deviceRevision;
 200 }
 201
 202 const QString &KCompactDisc::deviceName()
 203 {
 204     Q_D(KCompactDisc);
 205     return d->m_deviceName;
 206 }
 207
 208 const KUrl KCompactDisc::deviceUrl()
 209 {
 210     Q_D(KCompactDisc);
 211     return KCompactDisc::cdromDeviceUrl(d->m_deviceName);
 212 }
 213
 214 unsigned KCompactDisc::discId()
 215 {
 216     Q_D(KCompactDisc);
 217     return d->m_discId;
 218 }
 219
 220 const QList<unsigned> &KCompactDisc::discSignature()
 221 {
 222     Q_D(KCompactDisc);
 223     return d->m_trackStartFrames;
 224 }
 225
 226 const QString &KCompactDisc::discArtist()
 227 {
 228     Q_D(KCompactDisc);
 229     if (!d->m_tracks)
 230         return ___null;
 231     return d->m_trackArtists[0];
 232 }
 233
 234 const QString &KCompactDisc::discTitle()
 235 {
 236     Q_D(KCompactDisc);
 237     if (!d->m_tracks)
 238         return ___null;
 239     return d->m_trackTitles[0];
 240 }
 241
 242 unsigned KCompactDisc::discLength()
 243 {
 244     Q_D(KCompactDisc);
 245     if (!d->m_tracks)
 246         return 0;
 247     return d->m_discLength;
 248 }
 249
 250 unsigned KCompactDisc::discPosition()
 251 {
 252     Q_D(KCompactDisc);
 253     return d->m_discPosition;
 254 }
 255
 256 KCompactDisc::DiscStatus KCompactDisc::discStatus()
 257 {
 258     Q_D(KCompactDisc);
 259     return d->m_status;
 260 }
 261
 262 QString KCompactDisc::discStatusString(KCompactDisc::DiscStatus status)
 263 {
 264     return KCompactDiscPrivate::discStatusI18n(status);
 265 }
 266
 267 QString KCompactDisc::trackArtist()
 268 {
 269         Q_D(KCompactDisc);
 270         return trackArtist(d->m_track);
 271 }
 272
 273 QString KCompactDisc::trackArtist(unsigned track)
 274 {
 275         Q_D(KCompactDisc);
 276     if (!track)
 277         return QString();
 278     return d->m_trackArtists[track];
 279 }
 280
 281 QString KCompactDisc::trackTitle()
 282 {
 283         Q_D(KCompactDisc);
 284     return trackTitle(d->m_track);
 285 }
 286
 287 QString KCompactDisc::trackTitle(unsigned track)
 288 {
 289         Q_D(KCompactDisc);
 290     if (!track)
 291         return QString();
 292     return d->m_trackTitles[track];
 293 }
 294
 295 unsigned KCompactDisc::trackLength()
 296 {
 297         Q_D(KCompactDisc);
 298     return trackLength(d->m_track);
 299 }
 300
 301 unsigned KCompactDisc::trackLength(unsigned track)
 302 {
 303         Q_D(KCompactDisc);
 304     if (!track)
 305         return 0;
 306     return d->trackLength(track);
 307 }
 308
 309 unsigned KCompactDisc::track()
 310 {
 311         Q_D(KCompactDisc);
 312         return d->m_track;
 313 }
 314
 315 unsigned KCompactDisc::trackPosition()
 316 {
 317         Q_D(KCompactDisc);
 318     return d->m_trackPosition;
 319 }
 320
 321 unsigned KCompactDisc::tracks()
 322 {
 323         Q_D(KCompactDisc);
 324     return d->m_tracks;
 325 }
 326
 327 bool KCompactDisc::isPlaying()
 328 {
 329         Q_D(KCompactDisc);
 330         return (d->m_status == KCompactDisc::Playing);
 331 }
 332
 333 bool KCompactDisc::isPaused()
 334 {
 335         Q_D(KCompactDisc);
 336         return (d->m_status == KCompactDisc::Paused);
 337 }
 338
 339 bool KCompactDisc::isNoDisc()
 340 {
 341         Q_D(KCompactDisc);
 342         return (d->m_status == KCompactDisc::NoDisc);
 343 }
 344
 345 bool KCompactDisc::isAudio(unsigned track)
 346 {
 347         Q_D(KCompactDisc);
 348     if (!track)
 349         return 0;
 350     return d->isTrackAudio(track);
 351 }
 352
 353 void KCompactDisc::playTrack(unsigned track)
 354 {
 355         Q_D(KCompactDisc);
 356
 357         d->m_statusExpected = KCompactDisc::Playing;
 358     d->m_trackExpectedPosition = 0;
 359     d->m_seek = abs(d->m_trackExpectedPosition - trackPosition());
 360
 361         d->playTrackPosition(track, 0);
 362 }
 363
 364 void KCompactDisc::playPosition(unsigned position)
 365 {
 366         Q_D(KCompactDisc);
 367
 368         d->m_statusExpected = Playing;
 369     d->m_trackExpectedPosition = position;
 370     d->m_seek = abs(d->m_trackExpectedPosition - trackPosition());
 371
 372         d->playTrackPosition(d->m_track, position);
 373 }
 374
 375 void KCompactDisc::play()
 376 {
 377         doCommand(KCompactDisc::Play);
 378 }
 379
 380 void KCompactDisc::next()
 381 {
 382         doCommand(KCompactDisc::Next);
 383 }
 384
 385 void KCompactDisc::prev()
 386 {
 387         doCommand(KCompactDisc::Prev);
 388 }
 389
 390 void KCompactDisc::pause()
 391 {
 392         doCommand(KCompactDisc::Pause);
 393 }
 394
 395 void KCompactDisc::stop()
 396 {
 397         doCommand(KCompactDisc::Stop);
 398 }
 399
 400 void KCompactDisc::eject()
 401 {
 402         doCommand(KCompactDisc::Eject);
 403 }
 404
 405 void KCompactDisc::loop()
 406 {
 407         doCommand(KCompactDisc::Loop);
 408 }
 409
 410 void KCompactDisc::random()
 411 {
 412         doCommand(KCompactDisc::Random);
 413 }
 414
 415 void KCompactDisc::doCommand(KCompactDisc::DiscCommand cmd)
 416 {
 417         Q_D(KCompactDisc);
 418         unsigned track;
 419
 420         switch(cmd) {
 421         case Play:
 422                 if(d->m_status == KCompactDisc::Playing)
 423                         return;
 424                 next();
 425                 break;
 426
 427         case Next:
 428                 track = d->getNextTrackInPlaylist();
 429         if(track)
 430                         playTrack(track);
 431                 break;
 432
 433         case Prev:
 434                 track = d->getPrevTrackInPlaylist();
 435         if(track)
 436                         playTrack(track);
 437                 break;
 438
 439         case Pause:
 440                 if(d->m_status == KCompactDisc::Paused)
 441                         d->m_statusExpected = KCompactDisc::Playing;
 442                 else
 443                         d->m_statusExpected = KCompactDisc::Paused;
 444
 445                 d->pause();
 446                 break;
 447
 448         case Stop:
 449                 d->m_statusExpected = KCompactDisc::Stopped;
 450         d->stop();
 451                 break;
 452
 453         case Eject:
 454                 if(d->m_status != KCompactDisc::Ejected) {
 455                         if(d->m_status != KCompactDisc::Stopped) {
 456                                 d->m_statusExpected = KCompactDisc::Ejected;
 457                                 d->stop();
 458                         } else {
 459                                 d->eject();
 460                         }
 461                 } else {
 462                         d->m_statusExpected = KCompactDisc::Stopped;
 463                         d->closetray();
 464                 }
 465                 break;
 466
 467         case Loop:
 468                 setLoopPlaylist(!d->m_loopPlaylist);
 469                 break;
 470
 471         case Random:
 472                 setRandomPlaylist(!d->m_randomPlaylist);
 473                 break;
 474         }
 475 }
 476
 477 void KCompactDisc::metadataLookup()
 478 {
 479         Q_D(KCompactDisc);
 480         d->queryMetadata();
 481 }
 482
 483 void KCompactDisc::setRandomPlaylist(bool random)
 484 {
 485         Q_D(KCompactDisc);
 486         d->m_randomPlaylist = random;
 487         d->make_playlist();
 488         emit randomPlaylistChanged(d->m_randomPlaylist);
 489 }
 490
 491 void KCompactDisc::setLoopPlaylist(bool loop)
 492 {
 493         Q_D(KCompactDisc);
 494         d->m_loopPlaylist = loop;
 495         emit loopPlaylistChanged(d->m_loopPlaylist);
 496 }
 497
 498 void KCompactDisc::setAutoMetadataLookup(bool autoMetadata)
 499 {
 500         Q_D(KCompactDisc);
 501         d->m_autoMetadata = autoMetadata;
 502         if(d->m_autoMetadata)
 503                 metadataLookup();
 504 }
 505
 506 bool KCompactDisc::setDevice(const QString &deviceName, unsigned volume,
 507     bool digitalPlayback, const QString &audioSystem, const QString &audioDevice)
 508 {
 509         QString as = digitalPlayback ? audioSystem : QString("cdin");
 510         QString ad = digitalPlayback ? audioDevice : QString();
 511     kDebug() << "Device init: " << deviceName << ", " << as << ", " << ad;
 512
 513         if(dummy_ptr->moveInterface(deviceName, as, ad)) {
 514                 setVolume(volume);
 515                 return 1;
 516         } else {
 517         // Severe (OS-level) error.
 518                 return 0;
 519     }
 520 }
 521
 522 void KCompactDisc::setVolume(unsigned volume)
 523 {
 524         Q_D(KCompactDisc);
 525     kDebug() << "change volume: " << volume;
 526         d->setVolume(volume);
 527 }
 528
 529 void KCompactDisc::setBalance(unsigned balance)
 530 {
 531         Q_D(KCompactDisc);
 532     kDebug() << "change balance: " << balance;
 533         d->setBalance(balance);
 534 }
 535
 536 #include "kcompactdisc.moc"