FCL/sf/mw/qt: comparison src/3rdparty/phonon/mmf/abstractmediaplayer.cpp

equal deleted inserted replaced

-:41300fa6a67c
+:3b1da2848fc7
 #include <QUrl>
 #include "abstractmediaplayer.h"
 #include "defs.h"
+#include "mediaobject.h"
 #include "utils.h"
 QT_BEGIN_NAMESPACE
 using namespace Phonon;
 //-----------------------------------------------------------------------------
 // Constants
 //-----------------------------------------------------------------------------
 const int       NullMaxVolume = -1;
+const int       BufferStatusTimerInterval = 100; // ms
 //-----------------------------------------------------------------------------
 // Constructor / destructor
 //-----------------------------------------------------------------------------
-MMF::AbstractMediaPlayer::AbstractMediaPlayer() :
+MMF::AbstractMediaPlayer::AbstractMediaPlayer
-m_playPending(false)
+(MediaObject *parent, const AbstractPlayer *player)
-,   m_tickTimer(new QTimer(this))
+:   AbstractPlayer(player)
+,   m_parent(parent)
+,   m_playPending(false)
+,   m_positionTimer(new QTimer(this))
+,   m_bufferStatusTimer(new QTimer(this))
 ,   m_mmfMaxVolume(NullMaxVolume)
-{
+,   m_prefinishMarkSent(false)
-connect(m_tickTimer.data(), SIGNAL(timeout()), this, SLOT(tick()));
+,   m_aboutToFinishSent(false)
-}
+{
+connect(m_positionTimer.data(), SIGNAL(timeout()), this, SLOT(positionTick()));
-MMF::AbstractMediaPlayer::AbstractMediaPlayer(const AbstractPlayer& player) :
+connect(m_bufferStatusTimer.data(), SIGNAL(timeout()), this, SLOT(bufferStatusTick()));
-AbstractPlayer(player)
-,   m_playPending(false)
-,   m_tickTimer(new QTimer(this))
-,   m_mmfMaxVolume(NullMaxVolume)
-{
-connect(m_tickTimer.data(), SIGNAL(timeout()), this, SLOT(tick()));
 }
 //-----------------------------------------------------------------------------
 // MediaObjectInterface
 //-----------------------------------------------------------------------------
 TRACE_CONTEXT(AbstractMediaPlayer::play, EAudioApi);
 TRACE_ENTRY("state %d", privateState());
 switch (privateState()) {
 case GroundState:
-setError(NormalError);
+setError(tr("Not ready to play"));
 break;
 case LoadingState:
 m_playPending = true;
 break;
 case StoppedState:
 case PausedState:
 doPlay();
-startTickTimer();
+startPositionTimer();
 changeState(PlayingState);
 break;
 case PlayingState:
 case BufferingState:
 {
 TRACE_CONTEXT(AbstractMediaPlayer::pause, EAudioApi);
 TRACE_ENTRY("state %d", privateState());
 m_playPending = false;
+stopTimers();
 switch (privateState()) {
 case GroundState:
 case LoadingState:
 case PausedState:
+case StoppedState:
 // Do nothing
 break;
-case StoppedState:
 case PlayingState:
+case BufferingState:
+changeState(PausedState);
+// Fall through
 case ErrorState:
-case BufferingState:
 doPause();
-stopTickTimer();
-changeState(PausedState);
 break;
 // Protection against adding new states and forgetting to update this switch
 default:
 TRACE_PANIC(InvalidStatePanic);
 {
 TRACE_CONTEXT(AbstractMediaPlayer::stop, EAudioApi);
 TRACE_ENTRY("state %d", privateState());
 m_playPending = false;
+stopTimers();
 switch (privateState()) {
 case GroundState:
 case LoadingState:
 case StoppedState:
 case PlayingState:
 case BufferingState:
 case PausedState:
 doStop();
-stopTickTimer();
 changeState(StoppedState);
 break;
 // Protection against adding new states and forgetting to update this switch
 default:
 case StoppedState:
 case PausedState:
 case PlayingState:
 case LoadingState:
 {
-const bool tickTimerWasRunning = m_tickTimer->isActive();
+bool wasPlaying = false;
-stopTickTimer();
+if (state() == PlayingState) {
+stopPositionTimer();
+doPause();
+wasPlaying = true;
+}
 doSeek(ms);
+resetMarksIfRewound();
-if (tickTimerWasRunning) {
-startTickTimer();
+if(wasPlaying && state() != ErrorState) {
-}
+doPlay();
+startPositionTimer();
+}
 break;
 }
 case BufferingState:
 // Fallthrough
 case ErrorState:
 void MMF::AbstractMediaPlayer::doSetTickInterval(qint32 interval)
 {
 TRACE_CONTEXT(AbstractMediaPlayer::doSetTickInterval, EAudioApi);
 TRACE_ENTRY("state %d m_interval %d interval %d", privateState(), tickInterval(), interval);
-m_tickTimer->setInterval(interval);
+m_positionTimer->setInterval(interval);
 TRACE_EXIT_0();
 }
-MediaSource MMF::AbstractMediaPlayer::source() const
+void MMF::AbstractMediaPlayer::open(const MediaSource &source, RFile& file)
-{
-return m_source;
-}
-void MMF::AbstractMediaPlayer::setFileSource(const MediaSource &source, RFile& file)
 {
 TRACE_CONTEXT(AbstractMediaPlayer::setFileSource, EAudioApi);
 TRACE_ENTRY("state %d source.type %d", privateState(), source.type());
 close();
 changeState(GroundState);
-// TODO: is it correct to assign even if the media type is not supported in
-// the switch statement below?
-m_source = source;
 TInt symbianErr = KErrNone;
+QString errorMessage;
-switch (m_source.type()) {
+switch (source.type()) {
 case MediaSource::LocalFile: {
 symbianErr = openFile(file);
+if (KErrNone != symbianErr)
+errorMessage = tr("Error opening file");
 break;
 }
 case MediaSource::Url: {
 const QUrl url(source.url());
 if (url.scheme() == QLatin1String("file")) {
 symbianErr = openFile(file);
-}
+if (KErrNone != symbianErr)
-else {
+errorMessage = tr("Error opening file");
-TRACE_0("Source type not supported");
+} else {
-// TODO: support network URLs
+symbianErr = openUrl(url.toString());
-symbianErr = KErrNotSupported;
+if (KErrNone != symbianErr)
-}
+errorMessage = tr("Error opening URL");
+}
-break;
-}
+break;
+}
-case MediaSource::Invalid:
-case MediaSource::Disc:
+// Other source types are handled in MediaObject::createPlayer
-case MediaSource::Stream:
-TRACE_0("Source type not supported");
+// Protection against adding new media types and forgetting to update this switch
-symbianErr = KErrNotSupported;
-break;
-case MediaSource::Empty:
-TRACE_0("Empty source - doing nothing");
-TRACE_EXIT_0();
-return;
-// Protection against adding new media types and forgetting to update this switch
 default:
 TRACE_PANIC(InvalidMediaTypePanic);
 }
-if (KErrNone == symbianErr) {
+if (errorMessage.isEmpty()) {
 changeState(LoadingState);
 } else {
-TRACE("error %d", symbianErr)
+if (symbianErr)
-setError(NormalError);
+setError(errorMessage, symbianErr);
+else
+setError(errorMessage);
 }
 TRACE_EXIT_0();
 }
-void MMF::AbstractMediaPlayer::setNextSource(const MediaSource &source)
-{
-TRACE_CONTEXT(AbstractMediaPlayer::setNextSource, EAudioApi);
-TRACE_ENTRY("state %d", privateState());
-// TODO: handle 'next source'
-m_nextSource = source;
-Q_UNUSED(source);
-TRACE_EXIT_0();
-}
 void MMF::AbstractMediaPlayer::volumeChanged(qreal volume)
 {
 TRACE_CONTEXT(AbstractMediaPlayer::volumeChanged, EAudioInternal);
 TRACE_ENTRY("state %d", privateState());
 doVolumeChanged();
 TRACE_EXIT_0();
 }
+//-----------------------------------------------------------------------------
+// Private functions
+//-----------------------------------------------------------------------------
+void MMF::AbstractMediaPlayer::startPositionTimer()
+{
+m_positionTimer->start(tickInterval());
+}
+void MMF::AbstractMediaPlayer::stopPositionTimer()
+{
+m_positionTimer->stop();
+}
+void MMF::AbstractMediaPlayer::startBufferStatusTimer()
+{
+m_bufferStatusTimer->start(BufferStatusTimerInterval);
+}
+void MMF::AbstractMediaPlayer::stopBufferStatusTimer()
+{
+m_bufferStatusTimer->stop();
+}
+void MMF::AbstractMediaPlayer::stopTimers()
+{
+stopPositionTimer();
+stopBufferStatusTimer();
+}
 void MMF::AbstractMediaPlayer::doVolumeChanged()
 {
 switch (privateState()) {
 case GroundState:
 case BufferingState: {
 const qreal volume = (m_volume * m_mmfMaxVolume) + 0.5;
 const int err = setDeviceVolume(volume);
 if (KErrNone != err) {
-setError(NormalError);
+setError(tr("Setting volume failed"), err);
 }
 break;
 }
 // Protection against adding new states and forgetting to update this
 default:
 Utils::panic(InvalidStatePanic);
 }
 }
 //-----------------------------------------------------------------------------
 // Protected functions
 //-----------------------------------------------------------------------------
-void MMF::AbstractMediaPlayer::startTickTimer()
+void MMF::AbstractMediaPlayer::bufferingStarted()
 {
-m_tickTimer->start(tickInterval());
+m_stateBeforeBuffering = privateState();
-}
+changeState(BufferingState);
+bufferStatusTick();
-void MMF::AbstractMediaPlayer::stopTickTimer()
+startBufferStatusTimer();
-{
+}
-m_tickTimer->stop();
+void MMF::AbstractMediaPlayer::bufferingComplete()
+{
+stopBufferStatusTimer();
+emit MMF::AbstractPlayer::bufferStatus(100);
+changeState(m_stateBeforeBuffering);
 }
 void MMF::AbstractMediaPlayer::maxVolumeChanged(int mmfMaxVolume)
 {
 m_mmfMaxVolume = mmfMaxVolume;
 doVolumeChanged();
 }
+void MMF::AbstractMediaPlayer::playbackComplete(int error)
+{
+stopTimers();
+if (KErrNone == error) {
+changeState(StoppedState);
+// MediaObject::switchToNextSource deletes the current player, so we
+// call it via delayed slot invokation to ensure that this object does
+// not get deleted during execution of a member function.
+QMetaObject::invokeMethod(m_parent, "switchToNextSource", Qt::QueuedConnection);
+}
+else {
+setError(tr("Playback complete"), error);
+}
+}
 qint64 MMF::AbstractMediaPlayer::toMilliSeconds(const TTimeIntervalMicroSeconds &in)
 {
 return in.Int64() / 1000;
 }
 //-----------------------------------------------------------------------------
 // Slots
 //-----------------------------------------------------------------------------
-void MMF::AbstractMediaPlayer::tick()
+void MMF::AbstractMediaPlayer::positionTick()
 {
-// For the MWC compiler, we need to qualify the base class.
+emitMarksIfReached();
-emit MMF::AbstractPlayer::tick(currentTime());
+const qint64 current = currentTime();
+emit MMF::AbstractPlayer::tick(current);
+}
+void MMF::AbstractMediaPlayer::emitMarksIfReached()
+{
+const qint64 current = currentTime();
+const qint64 total = totalTime();
+const qint64 remaining = total - current;
+if (prefinishMark() && !m_prefinishMarkSent) {
+if (remaining < (prefinishMark() + tickInterval()/2)) {
+m_prefinishMarkSent = true;
+emit prefinishMarkReached(remaining);
+}
+}
+if (!m_aboutToFinishSent) {
+if (remaining < tickInterval()) {
+m_aboutToFinishSent = true;
+emit aboutToFinish();
+}
+}
+}
+void MMF::AbstractMediaPlayer::resetMarksIfRewound()
+{
+const qint64 current = currentTime();
+const qint64 total = totalTime();
+const qint64 remaining = total - current;
+if (prefinishMark() && m_prefinishMarkSent)
+if (remaining >= (prefinishMark() + tickInterval()/2))
+m_prefinishMarkSent = false;
+if (m_aboutToFinishSent)
+if (remaining >= tickInterval())
+m_aboutToFinishSent = false;
+}
+void MMF::AbstractMediaPlayer::bufferStatusTick()
+{
+emit MMF::AbstractPlayer::bufferStatus(bufferStatus());
 }
 void MMF::AbstractMediaPlayer::changeState(PrivateState newState)
 {
 TRACE_CONTEXT(AbstractMediaPlayer::changeState, EAudioInternal);

branch	RCL_3
changeset 4	3b1da2848fc7
parent 3	41300fa6a67c
child 14	c0432d11811c