← Back to branch summary

~ubuntu-branches/ubuntu/quantal/libkcompactdisc/quantal-updates

« back to all changes in this revision

Viewing changes to kcompactdisc.cpp

  • Committer: Package Import Robot
  • Author(s): Philip Muškovac
  • Date: 2012-05-26 15:25:35 UTC
  • Revision ID: package-import@ubuntu.com-20120526152535-60v997qsp1solymv
Tags: upstream-4.8.80a
Import upstream version 4.8.80a

Show diffs side-by-side

added added

removed removed

Lines of Context:
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(const Solid::Device &device, Solid::Device::listFromType(Solid::DeviceInterface::OpticalDrive)) {
 
48
        kDebug() << device.udi().toLatin1().constData();
 
49
        const Solid::Block *b = device.as<Solid::Block>();
 
50
        
 
51
        if(!b) {
 
52
            continue;
 
53
        }
 
54
 
 
55
        const Solid::OpticalDrive *o = device.as<Solid::OpticalDrive>();
 
56
        Solid::OpticalDrive::MediumTypes mediumType = o->supportedMedia();
 
57
 
 
58
        url = KUrl::fromPath(QLatin1String( b->device().toLatin1() ));
 
59
        //TODO translate them ?
 
60
        if(mediumType < Solid::OpticalDrive::Cdrw) {
 
61
            type = QLatin1String( "CD-ROM" );
 
62
        } else if(mediumType < Solid::OpticalDrive::Dvd) {
 
63
            type = QLatin1String( "CDRW" );
 
64
        } else if(mediumType < Solid::OpticalDrive::Dvdr) {
 
65
            type = QLatin1String( "DVD-ROM" );
 
66
        } else if(mediumType < Solid::OpticalDrive::Bd) {
 
67
            type = QLatin1String( "DVDRW" );
 
68
        } else if(mediumType < Solid::OpticalDrive::HdDvd) {
 
69
            type = QLatin1String( "Blu-ray" );
 
70
        } else {
 
71
            type = QLatin1String( "High Density DVD" );
 
72
        }
 
73
 
 
74
        if(!device.vendor().isEmpty())
 
75
            name = (QLatin1Char('[') + type + QLatin1String( " - " ) + device.vendor() + QLatin1String( " - " ) + device.product() + QLatin1Char( ']' ));
 
76
        else
 
77
            name = (QLatin1Char('[') + type + QLatin1String( " - unknown vendor - " ) + device.product() + QLatin1Char( ']' ));
 
78
 
 
79
        cdromsNameToDeviceUrl.insert(name, url);
 
80
        cdromsNameToUdi.insert(name, device.udi());
 
81
    }
 
82
#if 0
 
83
    if(cdromsNameToDeviceUrl.empty()) {
 
84
        cdromsNameToDeviceUrl.insert(QString("Generic CDROM []"), KUrl::fromPath(wm_drive_default_device()));
 
85
    }
 
86
#endif
 
87
}
 
88
 
 
89
static QMap<QString, KUrl> &getListOfCdromDevicesNamesAndUrl()
 
90
{
 
91
    if(cdromsNameToDeviceUrl.empty())
 
92
        refreshListOfCdromDevices();
 
93
 
 
94
    return cdromsNameToDeviceUrl;
 
95
}
 
96
 
 
97
static QMap<QString, QString> &getListOfCdromDevicesNamesAndUdi()
 
98
{
 
99
    if(cdromsNameToUdi.empty())
 
100
        refreshListOfCdromDevices();
 
101
 
 
102
    return cdromsNameToUdi;
 
103
}
 
104
 
 
105
QString KCompactDisc::urlToDevice(const KUrl& deviceUrl)
 
106
{
 
107
    if(deviceUrl.protocol() == QLatin1String( "media" ) || deviceUrl.protocol() == QLatin1String( "system" )) {
 
108
        kDebug() << "Asking mediamanager for " << deviceUrl.fileName();
 
109
 
 
110
        QDBusInterface mediamanager( QLatin1String( "org.kde.kded" ), QLatin1String( "/modules/mediamanager" ), QLatin1String( "org.kde.MediaManager" ) );
 
111
        QDBusReply<QStringList> reply = mediamanager.call(QLatin1String( "properties" ), deviceUrl.fileName());
 
112
 
 
113
        QStringList properties = reply;
 
114
        if(!reply.isValid() || properties.count() < 6) {
 
115
            kError() << "Invalid reply from mediamanager" << endl;
 
116
            return deviceUrl.path();
 
117
        } else {
 
118
            kDebug() << "Reply from mediamanager " << properties[5];
 
119
            return properties[5];
 
120
        }
 
121
    } else if(deviceUrl.protocol() == QLatin1String( "file" )) {
 
122
        return deviceUrl.path();
 
123
    } else {
 
124
        return QString();
 
125
    }
 
126
}
 
127
 
 
128
const QStringList KCompactDisc::audioSystems()
 
129
{
 
130
    QStringList list;
 
131
 
 
132
    list << QLatin1String( "phonon" )
 
133
#if defined(HAVE_LIBASOUND2)
 
134
        << QLatin1String( "alsa" )
 
135
#endif
 
136
#if defined(sun) || defined(__sun__)
 
137
        << QLatin1String( "sun" )
 
138
#endif
 
139
    ;
 
140
    return list;
 
141
}
 
142
 
 
143
const QStringList KCompactDisc::cdromDeviceNames()
 
144
{
 
145
    return getListOfCdromDevicesNamesAndUrl().keys();
 
146
}
 
147
 
 
148
const QString KCompactDisc::defaultCdromDeviceName()
 
149
{
 
150
    const QStringList names = getListOfCdromDevicesNamesAndUrl().keys();
 
151
    if (!names.isEmpty()) return names[0];
 
152
    else return QString();
 
153
}
 
154
 
 
155
const KUrl KCompactDisc::defaultCdromDeviceUrl()
 
156
{
 
157
    const QList<KUrl> urls = getListOfCdromDevicesNamesAndUrl().values();
 
158
    if (!urls.isEmpty()) return urls[0];
 
159
    else return KUrl();
 
160
}
 
161
 
 
162
const KUrl KCompactDisc::cdromDeviceUrl(const QString &cdromDeviceName)
 
163
{
 
164
    const QMap<QString, KUrl> &nameUrls = getListOfCdromDevicesNamesAndUrl();
 
165
    KUrl result = nameUrls.value(cdromDeviceName);
 
166
    if (!result.isValid())
 
167
    {
 
168
        const KUrl passedUrl(cdromDeviceName);
 
169
        foreach(const KUrl &url, nameUrls)
 
170
        {
 
171
            if (url == passedUrl)
 
172
            {
 
173
                return passedUrl;
 
174
            }
 
175
        }
 
176
        result = KCompactDisc::defaultCdromDeviceUrl();
 
177
    }
 
178
    return result;
 
179
}
 
180
 
 
181
const QString KCompactDisc::defaultCdromDeviceUdi()
 
182
{
 
183
    const QStringList udis = getListOfCdromDevicesNamesAndUdi().values();
 
184
    if (!udis.isEmpty()) return udis[0];
 
185
    else return QString();
 
186
}
 
187
 
 
188
const QString KCompactDisc::cdromDeviceUdi(const QString &cdromDeviceName)
 
189
{
 
190
    return getListOfCdromDevicesNamesAndUdi().value(cdromDeviceName, KCompactDisc::defaultCdromDeviceUdi());
 
191
}
 
192
 
 
193
KCompactDisc::KCompactDisc(InformationMode infoMode) :
 
194
    d_ptr(new KCompactDiscPrivate(this, KCompactDisc::defaultCdromDeviceName()))
 
195
{
 
196
    Q_D(KCompactDisc);
 
197
    d->m_infoMode = infoMode;
 
198
}
 
199
 
 
200
KCompactDisc::~KCompactDisc()
 
201
{
 
202
    stop();
 
203
    delete d_ptr;
 
204
}
 
205
 
 
206
const QString &KCompactDisc::deviceVendor()
 
207
{
 
208
    Q_D(KCompactDisc);
 
209
    return d->m_deviceVendor;
 
210
}
 
211
 
 
212
const QString &KCompactDisc::deviceModel()
 
213
{
 
214
    Q_D(KCompactDisc);
 
215
    return d->m_deviceModel;
 
216
}
 
217
 
 
218
const QString &KCompactDisc::deviceRevision()
 
219
{
 
220
    Q_D(KCompactDisc);
 
221
    return d->m_deviceRevision;
 
222
}
 
223
 
 
224
const QString &KCompactDisc::deviceName()
 
225
{
 
226
    Q_D(KCompactDisc);
 
227
    return d->m_deviceName;
 
228
}
 
229
 
 
230
const KUrl KCompactDisc::deviceUrl()
 
231
{
 
232
    Q_D(KCompactDisc);
 
233
    return KCompactDisc::cdromDeviceUrl(d->m_deviceName);
 
234
}
 
235
 
 
236
unsigned KCompactDisc::discId()
 
237
{
 
238
    Q_D(KCompactDisc);
 
239
    return d->m_discId;
 
240
}
 
241
 
 
242
const QList<unsigned> &KCompactDisc::discSignature()
 
243
{
 
244
    Q_D(KCompactDisc);
 
245
    return d->m_trackStartFrames;
 
246
}
 
247
 
 
248
const QString &KCompactDisc::discArtist()
 
249
{
 
250
    Q_D(KCompactDisc);
 
251
    if (!d->m_tracks)
 
252
        return ___null;
 
253
    return d->m_trackArtists[0];
 
254
}
 
255
 
 
256
const QString &KCompactDisc::discTitle()
 
257
{
 
258
    Q_D(KCompactDisc);
 
259
    if (!d->m_tracks)
 
260
        return ___null;
 
261
    return d->m_trackTitles[0];
 
262
}
 
263
 
 
264
unsigned KCompactDisc::discLength()
 
265
{
 
266
    Q_D(KCompactDisc);
 
267
    if (!d->m_tracks)
 
268
        return 0;
 
269
    return d->m_discLength;
 
270
}
 
271
 
 
272
unsigned KCompactDisc::discPosition()
 
273
{
 
274
    Q_D(KCompactDisc);
 
275
    return d->m_discPosition;
 
276
}
 
277
 
 
278
KCompactDisc::DiscStatus KCompactDisc::discStatus()
 
279
{
 
280
    Q_D(KCompactDisc);
 
281
    return d->m_status;
 
282
}
 
283
 
 
284
QString KCompactDisc::discStatusString(KCompactDisc::DiscStatus status)
 
285
{
 
286
    return KCompactDiscPrivate::discStatusI18n(status);
 
287
}
 
288
 
 
289
QString KCompactDisc::trackArtist()
 
290
{
 
291
        Q_D(KCompactDisc);
 
292
        return trackArtist(d->m_track);
 
293
}
 
294
 
 
295
QString KCompactDisc::trackArtist(unsigned track)
 
296
{
 
297
        Q_D(KCompactDisc);
 
298
    if (!track)
 
299
        return QString();
 
300
    return d->m_trackArtists[track];
 
301
}
 
302
 
 
303
QString KCompactDisc::trackTitle()
 
304
{
 
305
        Q_D(KCompactDisc);
 
306
    return trackTitle(d->m_track);
 
307
}
 
308
 
 
309
QString KCompactDisc::trackTitle(unsigned track)
 
310
{
 
311
        Q_D(KCompactDisc);
 
312
    if (!track)
 
313
        return QString();
 
314
    return d->m_trackTitles[track];
 
315
}
 
316
 
 
317
unsigned KCompactDisc::trackLength()
 
318
{
 
319
        Q_D(KCompactDisc);
 
320
    return trackLength(d->m_track);
 
321
}
 
322
 
 
323
unsigned KCompactDisc::trackLength(unsigned track)
 
324
{
 
325
        Q_D(KCompactDisc);
 
326
    if (!track)
 
327
        return 0;
 
328
    return d->trackLength(track);
 
329
}
 
330
 
 
331
unsigned KCompactDisc::track()
 
332
{
 
333
        Q_D(KCompactDisc);
 
334
        return d->m_track;
 
335
}
 
336
 
 
337
unsigned KCompactDisc::trackPosition()
 
338
{
 
339
        Q_D(KCompactDisc);
 
340
    return d->m_trackPosition;
 
341
}
 
342
 
 
343
unsigned KCompactDisc::tracks()
 
344
{
 
345
        Q_D(KCompactDisc);
 
346
    return d->m_tracks;
 
347
}
 
348
 
 
349
bool KCompactDisc::isPlaying()
 
350
{
 
351
        Q_D(KCompactDisc);
 
352
        return (d->m_status == KCompactDisc::Playing);
 
353
}
 
354
 
 
355
bool KCompactDisc::isPaused()
 
356
{
 
357
        Q_D(KCompactDisc);
 
358
        return (d->m_status == KCompactDisc::Paused);
 
359
}
 
360
 
 
361
bool KCompactDisc::isNoDisc()
 
362
{
 
363
        Q_D(KCompactDisc);
 
364
        return (d->m_status == KCompactDisc::NoDisc);
 
365
}
 
366
 
 
367
bool KCompactDisc::isAudio(unsigned track)
 
368
{
 
369
        Q_D(KCompactDisc);
 
370
    if (!track)
 
371
        return 0;
 
372
    return d->isTrackAudio(track);
 
373
}
 
374
 
 
375
void KCompactDisc::playTrack(unsigned track)
 
376
{
 
377
        Q_D(KCompactDisc);
 
378
 
 
379
        d->m_statusExpected = KCompactDisc::Playing;
 
380
    d->m_trackExpectedPosition = 0;
 
381
    d->m_seek = abs( (double) d->m_trackExpectedPosition - trackPosition());
 
382
 
 
383
        d->playTrackPosition(track, 0);
 
384
}
 
385
 
 
386
void KCompactDisc::playPosition(unsigned position)
 
387
{
 
388
        Q_D(KCompactDisc);
 
389
 
 
390
        d->m_statusExpected = Playing;
 
391
    d->m_trackExpectedPosition = position;
 
392
    d->m_seek = abs( (double) d->m_trackExpectedPosition - trackPosition());
 
393
 
 
394
        d->playTrackPosition(d->m_track, position);
 
395
}
 
396
 
 
397
void KCompactDisc::play()
 
398
{
 
399
        doCommand(KCompactDisc::Play);
 
400
}
 
401
 
 
402
void KCompactDisc::next()
 
403
{
 
404
        doCommand(KCompactDisc::Next);
 
405
}
 
406
 
 
407
void KCompactDisc::prev()
 
408
{
 
409
        doCommand(KCompactDisc::Prev);
 
410
}
 
411
 
 
412
void KCompactDisc::pause()
 
413
{
 
414
        doCommand(KCompactDisc::Pause);
 
415
}
 
416
 
 
417
void KCompactDisc::stop()
 
418
{
 
419
        doCommand(KCompactDisc::Stop);
 
420
}
 
421
 
 
422
void KCompactDisc::eject()
 
423
{
 
424
        doCommand(KCompactDisc::Eject);
 
425
}
 
426
 
 
427
void KCompactDisc::loop()
 
428
{
 
429
        doCommand(KCompactDisc::Loop);
 
430
}
 
431
 
 
432
void KCompactDisc::random()
 
433
{
 
434
        doCommand(KCompactDisc::Random);
 
435
}
 
436
 
 
437
void KCompactDisc::doCommand(KCompactDisc::DiscCommand cmd)
 
438
{
 
439
        Q_D(KCompactDisc);
 
440
        unsigned track;
 
441
 
 
442
        switch(cmd) {
 
443
        case Play:
 
444
                if(d->m_status == KCompactDisc::Playing)
 
445
                        return;
 
446
                next();
 
447
                break;
 
448
 
 
449
        case Next:
 
450
                track = d->getNextTrackInPlaylist();
 
451
        if(track)
 
452
                        playTrack(track);
 
453
                break;
 
454
 
 
455
        case Prev:
 
456
                track = d->getPrevTrackInPlaylist();
 
457
        if(track)
 
458
                        playTrack(track);
 
459
                break;
 
460
 
 
461
        case Pause:
 
462
                if(d->m_status == KCompactDisc::Paused)
 
463
                        d->m_statusExpected = KCompactDisc::Playing;
 
464
                else
 
465
                        d->m_statusExpected = KCompactDisc::Paused;
 
466
 
 
467
                d->pause();
 
468
                break;
 
469
 
 
470
        case Stop:
 
471
                d->m_statusExpected = KCompactDisc::Stopped;
 
472
        d->stop();
 
473
                break;
 
474
 
 
475
        case Eject:
 
476
                if(d->m_status != KCompactDisc::Ejected) {
 
477
                        if(d->m_status != KCompactDisc::Stopped) {
 
478
                                d->m_statusExpected = KCompactDisc::Ejected;
 
479
                                d->stop();
 
480
                        } else {
 
481
                                d->eject();
 
482
                        }
 
483
                } else {
 
484
                        d->m_statusExpected = KCompactDisc::Stopped;
 
485
                        d->closetray();
 
486
                }
 
487
                break;
 
488
 
 
489
        case Loop:
 
490
                setLoopPlaylist(!d->m_loopPlaylist);
 
491
                break;
 
492
 
 
493
        case Random:
 
494
                setRandomPlaylist(!d->m_randomPlaylist);
 
495
                break;
 
496
        }
 
497
}
 
498
 
 
499
void KCompactDisc::metadataLookup()
 
500
{
 
501
        Q_D(KCompactDisc);
 
502
        d->queryMetadata();
 
503
}
 
504
 
 
505
void KCompactDisc::setRandomPlaylist(bool random)
 
506
{
 
507
        Q_D(KCompactDisc);
 
508
        d->m_randomPlaylist = random;
 
509
        d->make_playlist();
 
510
        emit randomPlaylistChanged(d->m_randomPlaylist);
 
511
}
 
512
 
 
513
void KCompactDisc::setLoopPlaylist(bool loop)
 
514
{
 
515
        Q_D(KCompactDisc);
 
516
        d->m_loopPlaylist = loop;
 
517
        emit loopPlaylistChanged(d->m_loopPlaylist);
 
518
}
 
519
 
 
520
void KCompactDisc::setAutoMetadataLookup(bool autoMetadata)
 
521
{
 
522
        Q_D(KCompactDisc);
 
523
        d->m_autoMetadata = autoMetadata;
 
524
        if(d->m_autoMetadata)
 
525
                metadataLookup();
 
526
}
 
527
 
 
528
bool KCompactDisc::setDevice(const QString &deviceName, unsigned volume,
 
529
    bool digitalPlayback, const QString &audioSystem, const QString &audioDevice)
 
530
{
 
531
        const QString as = digitalPlayback ? audioSystem : QLatin1String("cdin");
 
532
        const QString ad = digitalPlayback ? audioDevice : QString();
 
533
    kDebug() << "Device init: " << deviceName << ", " << as << ", " << ad;
 
534
 
 
535
        if(d_ptr->moveInterface(deviceName, as, ad)) {
 
536
                setVolume(volume);
 
537
                return 1;
 
538
        } else {
 
539
        // Severe (OS-level) error.
 
540
                return 0;
 
541
    }
 
542
}
 
543
 
 
544
void KCompactDisc::setVolume(unsigned volume)
 
545
{
 
546
        Q_D(KCompactDisc);
 
547
    kDebug() << "change volume: " << volume;
 
548
        d->setVolume(volume);
 
549
}
 
550
 
 
551
void KCompactDisc::setBalance(unsigned balance)
 
552
{
 
553
        Q_D(KCompactDisc);
 
554
    kDebug() << "change balance: " << balance;
 
555
        d->setBalance(balance);
 
556
}
 
557
 
 
558
#include "kcompactdisc.moc"