1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "s60mediaplayersession.h"

    43 

    44 #include <QtCore/qdebug.h>

    45 #include <QtCore/qdir.h>

    46 #include <QtCore/qvariant.h>

    47 #include <QtCore/qtimer.h>

    48 #include <mmf/common/mmferrors.h>

    49 #include <qmediatimerange.h>

    50 

    51 S60MediaPlayerSession::S60MediaPlayerSession(QObject *parent)

    52     : QObject(parent)

    53     , m_playbackRate(0)

    54     , m_muted(false)

    55     , m_volume(0)

    56     , m_state(QMediaPlayer::StoppedState)

    57     , m_mediaStatus(QMediaPlayer::UnknownMediaStatus)

    58     , m_progressTimer(new QTimer(this))

    59     , m_stalledTimer(new QTimer(this))

    60     , m_error(KErrNone)

    61     , m_play_requested(false)

    62     , m_stream(false)

    63 {    

    64     connect(m_progressTimer, SIGNAL(timeout()), this, SLOT(tick()));

    65     connect(m_stalledTimer, SIGNAL(timeout()), this, SLOT(stalled()));

    66 }

    67 

    68 S60MediaPlayerSession::~S60MediaPlayerSession()

    69 {

    70 }

    71 

    72 int S60MediaPlayerSession::volume() const

    73 {

    74     return m_volume;

    75 }

    76 

    77 void S60MediaPlayerSession::setVolume(int volume)

    78 {

    79     if (m_volume == volume)

    80         return;

    81     

    82     m_volume = volume;

    83     // Dont set symbian players volume until media loaded.

    84     // Leaves with KerrNotReady although documentation says otherwise.

    85     if (!m_muted && 

    86         (  mediaStatus() == QMediaPlayer::LoadedMedia 

    87         || mediaStatus() == QMediaPlayer::StalledMedia 

    88         || mediaStatus() == QMediaPlayer::BufferingMedia

    89         || mediaStatus() == QMediaPlayer::BufferedMedia

    90         || mediaStatus() == QMediaPlayer::EndOfMedia)) {

    91         TRAPD(err, doSetVolumeL(m_volume));

    92         setError(err);

    93     }

    94 }

    95 

    96 bool S60MediaPlayerSession::isMuted() const

    97 {

    98     return m_muted;

    99 }

   100 

   101 bool S60MediaPlayerSession::isSeekable() const

   102 {

   103     return (m_stream)?false:true;

   104 }

   105 

   106 void S60MediaPlayerSession::setMediaStatus(QMediaPlayer::MediaStatus status)

   107 {

   108     if (m_mediaStatus == status)

   109         return;

   110     

   111     m_mediaStatus = status;

   112     

   113     emit mediaStatusChanged(m_mediaStatus);

   114     

   115     if (m_play_requested)

   116         play();

   117 }

   118 

   119 void S60MediaPlayerSession::setState(QMediaPlayer::State state)

   120 {

   121     if (m_state == state)

   122         return;

   123     

   124     m_state = state;

   125     emit stateChanged(m_state);

   126 }

   127 

   128 QMediaPlayer::State S60MediaPlayerSession::state() const 

   129 { 

   130     return m_state; 

   131 }

   132 

   133 QMediaPlayer::MediaStatus S60MediaPlayerSession::mediaStatus() const 

   134 { 

   135     return m_mediaStatus; 

   136 }

   137 

   138 void S60MediaPlayerSession::load(QUrl url)

   139 {

   140     setMediaStatus(QMediaPlayer::LoadingMedia);

   141     startStalledTimer();

   142     m_stream = (url.scheme() == "file")?false:true;

   143     TRAPD(err,

   144         if(m_stream)

   145             doLoadUrlL(QString2TPtrC(url.toString()));

   146         else

   147             doLoadL(QString2TPtrC(QDir::toNativeSeparators(url.toLocalFile()))));    

   148     setError(err);    

   149 }

   150 

   151 void S60MediaPlayerSession::play()

   152 {

   153     if (state() == QMediaPlayer::PlayingState

   154         || mediaStatus() == QMediaPlayer::UnknownMediaStatus

   155         || mediaStatus() == QMediaPlayer::NoMedia

   156         || mediaStatus() == QMediaPlayer::InvalidMedia)

   157         return;

   158     

   159     if (mediaStatus() == QMediaPlayer::LoadingMedia) {

   160         m_play_requested = true;

   161         return;

   162     }

   163     

   164     m_play_requested = false;

   165     setState(QMediaPlayer::PlayingState);

   166     startProgressTimer();

   167     doPlay();

   168 }

   169 

   170 void S60MediaPlayerSession::pause()

   171 {

   172     if (mediaStatus() == QMediaPlayer::NoMedia ||

   173         mediaStatus() == QMediaPlayer::InvalidMedia)

   174         return;    

   175     

   176     setState(QMediaPlayer::PausedState);

   177     stopProgressTimer();    

   178     TRAP_IGNORE(doPauseL());

   179 }

   180 

   181 void S60MediaPlayerSession::stop()

   182 {

   183     m_play_requested = false;

   184     setState(QMediaPlayer::StoppedState);

   185     if (mediaStatus() == QMediaPlayer::BufferingMedia ||

   186         mediaStatus() == QMediaPlayer::BufferedMedia)

   187         setMediaStatus(QMediaPlayer::LoadedMedia);

   188     if (mediaStatus() == QMediaPlayer::LoadingMedia)

   189         setMediaStatus(QMediaPlayer::UnknownMediaStatus);    

   190     stopProgressTimer();

   191     stopStalledTimer();

   192     doStop();

   193     emit positionChanged(0);

   194 }

   195 void S60MediaPlayerSession::reset()

   196 {

   197     m_play_requested = false;    

   198     setError(KErrNone, QString(), true);

   199     stopProgressTimer();

   200     stopStalledTimer();

   201     doStop();

   202     setState(QMediaPlayer::StoppedState);

   203     setMediaStatus(QMediaPlayer::UnknownMediaStatus);

   204 }

   205 

   206 void S60MediaPlayerSession::setVideoRenderer(QObject *renderer)

   207 {

   208     Q_UNUSED(renderer);

   209 }

   210 

   211 int S60MediaPlayerSession::bufferStatus()

   212 {

   213     if(   mediaStatus() == QMediaPlayer::LoadingMedia

   214        || mediaStatus() == QMediaPlayer::UnknownMediaStatus

   215        || mediaStatus() == QMediaPlayer::NoMedia

   216        || mediaStatus() == QMediaPlayer::InvalidMedia)

   217         return 0;

   218     

   219     int progress = 0;

   220     TRAPD(err, progress = doGetBufferStatusL());

   221     

   222     // If buffer status query not supported by codec return 100

   223     // do not set error

   224     if(err == KErrNotSupported)

   225         return 100;

   226     

   227     setError(err);

   228     return progress;

   229 }

   230 

   231 bool S60MediaPlayerSession::isMetadataAvailable() const

   232 {

   233     return !m_metaDataMap.isEmpty();    

   234 }

   235 

   236 QVariant S60MediaPlayerSession::metaData(const QString &key) const

   237 {

   238     return m_metaDataMap.value(key);    

   239 }

   240 

   241 QMap<QString, QVariant> S60MediaPlayerSession::availableMetaData() const

   242 {

   243     return m_metaDataMap;

   244 }

   245 

   246 void S60MediaPlayerSession::setMuted(bool muted)

   247 {

   248     m_muted = muted;

   249     

   250     if(   m_mediaStatus == QMediaPlayer::LoadedMedia 

   251        || m_mediaStatus == QMediaPlayer::StalledMedia 

   252        || m_mediaStatus == QMediaPlayer::BufferingMedia

   253        || m_mediaStatus == QMediaPlayer::BufferedMedia

   254        || m_mediaStatus == QMediaPlayer::EndOfMedia) {

   255         TRAPD(err, doSetVolumeL((m_muted)?0:m_volume));

   256         setError(err);

   257     }

   258 }

   259 

   260 qint64 S60MediaPlayerSession::duration() const

   261 {

   262     if(   mediaStatus() == QMediaPlayer::LoadingMedia

   263        || mediaStatus() == QMediaPlayer::UnknownMediaStatus

   264        || mediaStatus() == QMediaPlayer::NoMedia

   265        || mediaStatus() == QMediaPlayer::InvalidMedia)

   266         return -1;

   267     

   268     qint64 pos = 0;

   269     TRAP_IGNORE(pos = doGetDurationL());

   270     return pos;

   271 }

   272 

   273 qint64 S60MediaPlayerSession::position() const

   274 {

   275     if(   mediaStatus() == QMediaPlayer::LoadingMedia

   276        || mediaStatus() == QMediaPlayer::UnknownMediaStatus

   277        || mediaStatus() == QMediaPlayer::NoMedia

   278        || mediaStatus() == QMediaPlayer::InvalidMedia)

   279         return 0;

   280     

   281     qint64 pos = 0;

   282     TRAP_IGNORE(pos = doGetPositionL());

   283     return pos;

   284 }

   285 

   286 void S60MediaPlayerSession::setPosition(qint64 pos)

   287 {

   288     if (position() == pos)

   289         return;

   290     

   291     if (state() == QMediaPlayer::PlayingState) 

   292         pause();

   293 

   294     TRAPD(err, doSetPositionL(pos * 1000));

   295     setError(err);

   296 

   297     if (state() == QMediaPlayer::PausedState)

   298         play();

   299 

   300     emit positionChanged(position());

   301 }

   302 

   303 void S60MediaPlayerSession::setAudioEndpoint(const QString& audioEndpoint)

   304 {

   305     doSetAudioEndpoint(audioEndpoint);

   306 }

   307 

   308 void S60MediaPlayerSession::loaded()

   309 {

   310     stopStalledTimer();

   311     if (m_error == KErrNone || m_error == KErrMMPartialPlayback) {

   312         setMediaStatus(QMediaPlayer::LoadedMedia);

   313         TRAPD(err, updateMetaDataEntriesL());

   314         setError(err);

   315         setVolume(m_volume);

   316         setMuted(m_muted);

   317         emit durationChanged(duration());

   318         emit videoAvailableChanged(isVideoAvailable());

   319         emit audioAvailableChanged(isAudioAvailable());

   320     }

   321 }

   322 

   323 void S60MediaPlayerSession::endOfMedia()

   324 {

   325     setMediaStatus(QMediaPlayer::EndOfMedia);

   326     setState(QMediaPlayer::StoppedState);

   327     emit positionChanged(0);

   328 }

   329 

   330 void S60MediaPlayerSession::buffering()

   331 {

   332     startStalledTimer();

   333     setMediaStatus(QMediaPlayer::BufferingMedia);

   334 }

   335 

   336 void S60MediaPlayerSession::buffered()

   337 {

   338     stopStalledTimer();

   339     setMediaStatus(QMediaPlayer::BufferedMedia);

   340 }

   341 void S60MediaPlayerSession::stalled()

   342 {

   343     setMediaStatus(QMediaPlayer::StalledMedia);

   344 }

   345 

   346 QMap<QString, QVariant>& S60MediaPlayerSession::metaDataEntries()

   347 {

   348     return m_metaDataMap;

   349 }

   350 

   351 QMediaPlayer::Error S60MediaPlayerSession::fromSymbianErrorToMultimediaError(int error)

   352 {

   353     switch(error) {

   354         case KErrNoMemory:

   355         case KErrNotFound:

   356         case KErrBadHandle:

   357         case KErrAbort:

   358         case KErrNotSupported:

   359         case KErrCorrupt:

   360         case KErrGeneral:

   361         case KErrArgument:

   362         case KErrPathNotFound:

   363         case KErrDied:

   364         case KErrServerTerminated:

   365         case KErrServerBusy:

   366         case KErrCompletion:  

   367         case KErrBadPower:    

   368             return QMediaPlayer::ResourceError;

   369         

   370         case KErrMMPartialPlayback:   

   371             return QMediaPlayer::FormatError;

   372 

   373         case KErrMMAudioDevice:

   374         case KErrMMVideoDevice:

   375         case KErrMMDecoder:

   376         case KErrUnknown:    

   377             return QMediaPlayer::ServiceMissingError;

   378             

   379         case KErrMMNotEnoughBandwidth:

   380         case KErrMMSocketServiceNotFound:

   381         case KErrMMNetworkRead:

   382         case KErrMMNetworkWrite:

   383         case KErrMMServerSocket:

   384         case KErrMMServerNotSupported:

   385         case KErrMMUDPReceive:

   386         case KErrMMInvalidProtocol:

   387         case KErrMMInvalidURL:

   388         case KErrMMMulticast:

   389         case KErrMMProxyServer:

   390         case KErrMMProxyServerNotSupported:

   391         case KErrMMProxyServerConnect:

   392             return QMediaPlayer::NetworkError;

   393 

   394         case KErrNotReady:

   395         case KErrInUse:

   396         case KErrAccessDenied:

   397         case KErrLocked:

   398         case KErrMMDRMNotAuthorized:

   399         case KErrPermissionDenied:

   400         case KErrCancel:

   401         case KErrAlreadyExists:

   402             return QMediaPlayer::AccessDeniedError;

   403 

   404         case KErrNone:

   405         default:

   406             return QMediaPlayer::NoError;

   407     }

   408 }

   409 

   410 void S60MediaPlayerSession::setError(int error, const QString &errorString, bool forceReset)

   411 {

   412     if( forceReset ) {

   413         m_error = KErrNone;

   414         emit this->error(QMediaPlayer::NoError, QString());

   415         return;

   416     }

   417 

   418     // If error does not change and m_error is reseted without forceReset flag

   419     if (error == m_error || 

   420         (m_error != KErrNone && error == KErrNone))

   421         return;

   422     

   423     m_error = error;

   424     QMediaPlayer::Error mediaError = fromSymbianErrorToMultimediaError(m_error);

   425     QString symbianError = QString(errorString);

   426 

   427     if (mediaError != QMediaPlayer::NoError) {

   428         // TODO: fix to user friendly string at some point

   429         // These error string are only dev usable

   430         symbianError.append("Symbian:");

   431         symbianError.append(QString::number(m_error));

   432     }

   433      

   434     emit this->error(mediaError, symbianError);

   435     

   436     switch(mediaError){

   437         case QMediaPlayer::ResourceError:

   438         case QMediaPlayer::NetworkError:

   439         case QMediaPlayer::AccessDeniedError:

   440         case QMediaPlayer::ServiceMissingError:

   441             m_play_requested = false;

   442             setMediaStatus(QMediaPlayer::InvalidMedia);

   443             stop();

   444             break;

   445     }

   446 }

   447 

   448 void S60MediaPlayerSession::tick()

   449 {

   450     emit positionChanged(position());

   451 

   452     if (bufferStatus() < 100)

   453         emit bufferStatusChanged(bufferStatus());

   454 }

   455 

   456 void S60MediaPlayerSession::startProgressTimer()

   457 {

   458     m_progressTimer->start(500);

   459 }

   460 

   461 void S60MediaPlayerSession::stopProgressTimer()

   462 {

   463     m_progressTimer->stop();

   464 }

   465 

   466 void S60MediaPlayerSession::startStalledTimer()

   467 {

   468     m_stalledTimer->start(30000);

   469 }

   470 

   471 void S60MediaPlayerSession::stopStalledTimer()

   472 {

   473     m_stalledTimer->stop();

   474 }

   475 QString S60MediaPlayerSession::TDesC2QString(const TDesC& aDescriptor)

   476 {

   477     return QString::fromUtf16(aDescriptor.Ptr(), aDescriptor.Length());

   478 }

   479 TPtrC S60MediaPlayerSession::QString2TPtrC( const QString& string )

   480 {

   481 	// Returned TPtrC is valid as long as the given parameter is valid and unmodified

   482     return TPtrC16(static_cast<const TUint16*>(string.utf16()), string.length());

   483 }

   484 QRect S60MediaPlayerSession::TRect2QRect(const TRect& tr)

   485 {

   486     return QRect(tr.iTl.iX, tr.iTl.iY, tr.Width(), tr.Height());

   487 }

   488 TRect S60MediaPlayerSession::QRect2TRect(const QRect& qr)

   489 {

   490     return TRect(TPoint(qr.left(), qr.top()), TSize(qr.width(), qr.height()));

   491 }