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

     2 **

     3 ** Copyright (C) 2009 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::loaded()

   304 {

   305     stopStalledTimer();

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

   307         setMediaStatus(QMediaPlayer::LoadedMedia);

   308         TRAPD(err, updateMetaDataEntriesL());

   309         setError(err);

   310         setVolume(m_volume);

   311         setMuted(m_muted);

   312         emit durationChanged(duration());

   313         emit videoAvailableChanged(isVideoAvailable());

   314         emit audioAvailableChanged(isAudioAvailable());

   315     }

   316 }

   317 

   318 void S60MediaPlayerSession::endOfMedia()

   319 {

   320     setMediaStatus(QMediaPlayer::EndOfMedia);

   321     setState(QMediaPlayer::StoppedState);

   322     emit positionChanged(0);

   323 }

   324 

   325 void S60MediaPlayerSession::buffering()

   326 {

   327     startStalledTimer();

   328     setMediaStatus(QMediaPlayer::BufferingMedia);

   329 }

   330 

   331 void S60MediaPlayerSession::buffered()

   332 {

   333     stopStalledTimer();

   334     setMediaStatus(QMediaPlayer::BufferedMedia);

   335 }

   336 void S60MediaPlayerSession::stalled()

   337 {

   338     setMediaStatus(QMediaPlayer::StalledMedia);

   339 }

   340 

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

   342 {

   343     return m_metaDataMap;

   344 }

   345 

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

   347 {

   348     switch(error) {

   349         case KErrNoMemory:

   350         case KErrNotFound:

   351         case KErrBadHandle:

   352         case KErrAbort:

   353         case KErrNotSupported:

   354         case KErrCorrupt:

   355         case KErrGeneral:

   356         case KErrArgument:

   357         case KErrPathNotFound:

   358         case KErrDied:

   359         case KErrServerTerminated:

   360         case KErrServerBusy:

   361         case KErrCompletion:  

   362         case KErrBadPower:    

   363             return QMediaPlayer::ResourceError;

   364         

   365         case KErrMMPartialPlayback:   

   366             return QMediaPlayer::FormatError;

   367 

   368         case KErrMMAudioDevice:

   369         case KErrMMVideoDevice:

   370         case KErrMMDecoder:

   371         case KErrUnknown:    

   372             return QMediaPlayer::ServiceMissingError;

   373             

   374         case KErrMMNotEnoughBandwidth:

   375         case KErrMMSocketServiceNotFound:

   376         case KErrMMNetworkRead:

   377         case KErrMMNetworkWrite:

   378         case KErrMMServerSocket:

   379         case KErrMMServerNotSupported:

   380         case KErrMMUDPReceive:

   381         case KErrMMInvalidProtocol:

   382         case KErrMMInvalidURL:

   383         case KErrMMMulticast:

   384         case KErrMMProxyServer:

   385         case KErrMMProxyServerNotSupported:

   386         case KErrMMProxyServerConnect:

   387             return QMediaPlayer::NetworkError;

   388 

   389         case KErrNotReady:

   390         case KErrInUse:

   391         case KErrAccessDenied:

   392         case KErrLocked:

   393         case KErrMMDRMNotAuthorized:

   394         case KErrPermissionDenied:

   395         case KErrCancel:

   396         case KErrAlreadyExists:

   397             return QMediaPlayer::AccessDeniedError;

   398 

   399         case KErrNone:

   400         default:

   401             return QMediaPlayer::NoError;

   402     }

   403 }

   404 

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

   406 {

   407     if( forceReset ) {

   408         m_error = KErrNone;

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

   410         return;

   411     }

   412 

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

   414     if (error == m_error || 

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

   416         return;

   417     

   418     m_error = error;

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

   420     QString symbianError = QString(errorString);

   421 

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

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

   424         // These error string are only dev usable

   425         symbianError.append("Symbian:");

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

   427     }

   428      

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

   430     

   431     switch(mediaError){

   432         case QMediaPlayer::ResourceError:

   433         case QMediaPlayer::NetworkError:

   434         case QMediaPlayer::AccessDeniedError:

   435         case QMediaPlayer::ServiceMissingError:

   436             m_play_requested = false;

   437             setMediaStatus(QMediaPlayer::InvalidMedia);

   438             stop();

   439             break;

   440     }

   441 }

   442 

   443 void S60MediaPlayerSession::tick()

   444 {

   445     emit positionChanged(position());

   446 

   447     if (bufferStatus() < 100)

   448         emit bufferStatusChanged(bufferStatus());

   449 }

   450 

   451 void S60MediaPlayerSession::startProgressTimer()

   452 {

   453     m_progressTimer->start(500);

   454 }

   455 

   456 void S60MediaPlayerSession::stopProgressTimer()

   457 {

   458     m_progressTimer->stop();

   459 }

   460 

   461 void S60MediaPlayerSession::startStalledTimer()

   462 {

   463     m_stalledTimer->start(30000);

   464 }

   465 

   466 void S60MediaPlayerSession::stopStalledTimer()

   467 {

   468     m_stalledTimer->stop();

   469 }

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

   471 {

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

   473 }

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

   475 {

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

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

   478 }

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

   480 {

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

   482 }

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

   484 {

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

   486 }