Merged in DummyPlayer changes

4 files changed, 257 insertions, 137 deletions

diff --git a/src/3rdparty/phonon/mmf/abstractplayer.h b/src/3rdparty/phonon/mmf/abstractplayer.h
index 97527ff3ab..02c08079d6 100644
--- a/src/3rdparty/phonon/mmf/abstractplayer.h
+++ b/src/3rdparty/phonon/mmf/abstractplayer.h
@@ -56,8 +56,7 @@ namespace Phonon
             // This is a temporary hack to work around KErrInUse from MMF
             // client utility OpenFileL calls
             //virtual void setSource(const Phonon::MediaSource &) = 0;
-            virtual void setFileSource
-				(const Phonon::MediaSource&, RFile&) = 0;
+            virtual void setFileSource(const Phonon::MediaSource&, RFile&) = 0;
             
             virtual void setNextSource(const Phonon::MediaSource &) = 0;
 
diff --git a/src/3rdparty/phonon/mmf/dummyplayer.cpp b/src/3rdparty/phonon/mmf/dummyplayer.cpp
new file mode 100644
index 0000000000..ecd68159c1
--- /dev/null
+++ b/src/3rdparty/phonon/mmf/dummyplayer.cpp
@@ -0,0 +1,137 @@
+/*  This file is part of the KDE project.
+
+Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+
+This library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 2.1 or 3 of the License.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "dummyplayer.h"
+
+using namespace Phonon;
+using namespace Phonon::MMF;
+
+void MMF::DummyPlayer::play()
+{
+}
+
+void MMF::DummyPlayer::pause()
+{
+}
+
+void MMF::DummyPlayer::stop()
+{
+}
+
+void MMF::DummyPlayer::seek(qint64)
+{
+}
+
+qint32 MMF::DummyPlayer::tickInterval() const
+{
+    return 0;
+}
+
+void MMF::DummyPlayer::setTickInterval(qint32)
+{
+}
+
+bool MMF::DummyPlayer::hasVideo() const
+{
+    return false;
+}
+
+bool MMF::DummyPlayer::isSeekable() const
+{
+    return false;
+}
+
+Phonon::State MMF::DummyPlayer::state() const
+{
+    return Phonon::StoppedState;
+}
+
+qint64 MMF::DummyPlayer::currentTime() const
+{
+    return 0;
+}
+
+QString MMF::DummyPlayer::errorString() const
+{
+    return QString();
+}
+
+Phonon::ErrorType MMF::DummyPlayer::errorType() const
+{
+    return Phonon::NoError;
+}
+
+qint64 MMF::DummyPlayer::totalTime() const
+{
+    return 0;
+}
+
+MediaSource MMF::DummyPlayer::source() const
+{
+    return MediaSource();
+}
+
+void MMF::DummyPlayer::setSource(const MediaSource &)
+{
+}
+
+void MMF::DummyPlayer::setNextSource(const MediaSource &)
+{
+}
+
+qint32 MMF::DummyPlayer::prefinishMark() const
+{
+    return 0;
+}
+
+void MMF::DummyPlayer::setPrefinishMark(qint32)
+{
+}
+
+qint32 MMF::DummyPlayer::transitionTime() const
+{
+    return 0;
+}
+
+void MMF::DummyPlayer::setTransitionTime(qint32)
+{
+}
+
+void MMF::DummyPlayer::setFileSource(const Phonon::MediaSource &, RFile &)
+{
+}
+
+//-----------------------------------------------------------------------------
+// Volume
+//-----------------------------------------------------------------------------
+
+qreal MMF::DummyPlayer::volume() const
+{
+    return 0;
+}
+
+bool MMF::DummyPlayer::setVolume(qreal)
+{
+    return true;
+}
+
+void MMF::DummyPlayer::setAudioOutput(AudioOutput *)
+{
+}
+
+
diff --git a/src/3rdparty/phonon/mmf/dummyplayer.h b/src/3rdparty/phonon/mmf/dummyplayer.h
new file mode 100644
index 0000000000..263a013178
--- /dev/null
+++ b/src/3rdparty/phonon/mmf/dummyplayer.h
@@ -0,0 +1,74 @@
+/*  This file is part of the KDE project.
+
+Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+
+This library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 2.1 or 3 of the License.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef PHONON_MMF_DUMMYPLAYER_H
+#define PHONON_MMF_DUMMYPLAYER_H
+
+#include "abstractplayer.h"
+
+namespace Phonon
+{
+    namespace MMF
+    {
+        class AudioOutput;
+
+        /**
+         * @short In order to make the implementation of MediaObject simpler,
+         * we have this class.
+         */
+        class DummyPlayer : public AbstractPlayer
+        {
+        public:
+            // AbstractPlayer
+            virtual void play();
+            virtual void pause();
+            virtual void stop();
+            virtual void seek(qint64 milliseconds);
+            virtual qint32 tickInterval() const;
+            virtual void setTickInterval(qint32 interval);
+            virtual bool hasVideo() const;
+            virtual bool isSeekable() const;
+            virtual qint64 currentTime() const;
+            virtual Phonon::State state() const;
+            virtual QString errorString() const;
+            virtual Phonon::ErrorType errorType() const;
+            virtual qint64 totalTime() const;
+            virtual MediaSource source() const;
+            virtual void setSource(const MediaSource &);
+            virtual void setNextSource(const MediaSource &source);
+            virtual qint32 prefinishMark() const;
+            virtual void setPrefinishMark(qint32);
+            virtual qint32 transitionTime() const;
+            virtual void setTransitionTime(qint32);
+            virtual qreal volume() const;
+            virtual bool setVolume(qreal volume);
+
+            virtual void setAudioOutput(AudioOutput* audioOutput);
+            virtual void setFileSource(const Phonon::MediaSource&, RFile&);
+
+        Q_SIGNALS:
+            void totalTimeChanged();
+            void stateChanged(Phonon::State oldState,
+                              Phonon::State newState);
+            void finished();
+            void tick(qint64 time);
+        };
+    }
+}
+
+#endif
diff --git a/src/3rdparty/phonon/mmf/mediaobject.cpp b/src/3rdparty/phonon/mmf/mediaobject.cpp
index 5b0ac3693f..c5310a53d5 100644
--- a/src/3rdparty/phonon/mmf/mediaobject.cpp
+++ b/src/3rdparty/phonon/mmf/mediaobject.cpp
@@ -17,6 +17,7 @@ along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "audioplayer.h"
+#include "dummyplayer.h"
 #include "mediaobject.h"
 #include "utils.h"
 #include "videoplayer.h"
@@ -32,6 +33,8 @@ using namespace Phonon::MMF;
 MMF::MediaObject::MediaObject(QObject *parent)	: 	QObject::QObject(parent)
 												,	m_recognizerOpened(false)
 {
+    m_player.reset(new DummyPlayer());
+
     TRACE_CONTEXT(MediaObject::MediaObject, EAudioApi);
     TRACE_ENTRY_0();
 
@@ -142,145 +145,81 @@ MMF::MediaObject::MediaType MMF::MediaObject::fileMediaType
 
 void MMF::MediaObject::play()
 {
-	if(!m_player.isNull())
-	{
-		m_player->play();
-	}
+    m_player->play();
 }
 
 void MMF::MediaObject::pause()
 {
-	if(!m_player.isNull())
-	{
-		m_player->pause();
-	}
+    m_player->pause();
 }
 
 void MMF::MediaObject::stop()
 {
-	if(!m_player.isNull())
-	{
-		m_player->stop();
-	}
+    m_player->stop();
 }
 
 void MMF::MediaObject::seek(qint64 ms)
 {
-	if(!m_player.isNull())
-	{
-		m_player->seek(ms);
-	}   
+    m_player->seek(ms);
 }
 
 qint32 MMF::MediaObject::tickInterval() const
 {
-	qint32 result = 0;
-	if(!m_player.isNull())
-	{
-		result = m_player->tickInterval();
-	}
-	return result;
+    return m_player->tickInterval();
 }
 
 void MMF::MediaObject::setTickInterval(qint32 interval)
 {
-	if(!m_player.isNull())
-	{
-		m_player->setTickInterval(interval);
-	}
+    m_player->setTickInterval(interval);
 }
 
 bool MMF::MediaObject::hasVideo() const
 {
-	bool result = false;
-	if(!m_player.isNull())
-	{
-		result = m_player->hasVideo();
-	}
-	return result;
+    return m_player->hasVideo();
 }
 
 bool MMF::MediaObject::isSeekable() const
 {
-	bool result = false;
-	if(!m_player.isNull())
-	{
-		result = m_player->isSeekable();
-	}
-	return result;
+    return m_player->isSeekable();
 }
 
 Phonon::State MMF::MediaObject::state() const
 {
-	Phonon::State result = Phonon::StoppedState;
-	if(!m_player.isNull())
-	{
-		result = m_player->state();
-	}
-	return result;
+    return m_player->state();
 }
 
 qint64 MMF::MediaObject::currentTime() const
 {
-	qint64 result = 0;
-	if(!m_player.isNull())
-	{
-		result = m_player->currentTime();
-	}
-	return result;
+    return m_player->currentTime();
 }
 
 QString MMF::MediaObject::errorString() const
 {
-	QString result;
-	if(!m_player.isNull())
-	{
-		result = m_player->errorString();
-	}
-	return result;
+    return m_player->errorString();
 }
 
 Phonon::ErrorType MMF::MediaObject::errorType() const
 {
-	Phonon::ErrorType result = Phonon::NoError;
-	if(!m_player.isNull())
-	{
-		result = m_player->errorType();
-	}
-	return result;
+    return m_player->errorType();
 }
 
 qint64 MMF::MediaObject::totalTime() const
 {
-	qint64 result = 0;
-	if(!m_player.isNull())
-	{
-		result = m_player->totalTime();
-	}
-	return result;
+    return m_player->totalTime();
 }
 
 MediaSource MMF::MediaObject::source() const
 {
-	MediaSource result;
-	if(!m_player.isNull())
-	{
-		result = m_player->source();
-	}
-	return result;
+    return m_player->source();
 }
 
 void MMF::MediaObject::setSource(const MediaSource &source)
 {
-    createPlayer(source);
-    if(!m_player.isNull())
-    {
-		//m_player->setSource(source);
-    
-		// This is a hack to work around KErrInUse from MMF client utility
-		// OpenFileL calls
-		m_player->setFileSource(source, m_file);
-    }
+	createPlayer(source);
+	
+    // This is a hack to work around KErrInUse from MMF client utility
+    // OpenFileL calls
+    m_player->setFileSource(source, m_file);
 }
 
 void MMF::MediaObject::createPlayer(const MediaSource &source)
@@ -289,12 +228,18 @@ void MMF::MediaObject::createPlayer(const MediaSource &source)
     TRACE_ENTRY("state %d source.type %d", state(), source.type());
 	TRACE_ENTRY("source.type %d", source.type());
 	
+	// Store old player object
+/*
+	AbstractPlayer* oldPlayer = m_player.take();
+
+	
     // Destroy old player object
 	if(!m_player.isNull())
 	{
 		disconnect(m_player.data(), 0, this, 0);
-		m_player.reset(NULL);
+		m_player.reset();
 	}
+*/
 	
 	MediaType mediaType = MediaTypeUnknown;
 	
@@ -308,14 +253,13 @@ void MMF::MediaObject::createPlayer(const MediaSource &source)
 		case MediaSource::Url:
 			// TODO: support detection of media type from HTTP streams
 			TRACE_0("Network streaming not supported yet");
-			
 		/*
 		 * TODO: handle error
 		 * 
 			m_error = NormalError;
 			changeState(ErrorState);
-			break;
 		 */
+			break;
 			
 		case MediaSource::Invalid:
 		case MediaSource::Disc:
@@ -330,14 +274,15 @@ void MMF::MediaObject::createPlayer(const MediaSource &source)
 			break;
 			
 		case MediaSource::Empty:
-			TRACE_EXIT_0();
-			return;
+			TRACE_0("Empty media source");
+			break;
 	}
 	
 	switch(mediaType)
 	{
 		case MediaTypeUnknown:
 			TRACE_0("Media type could not be determined");
+			m_player.reset(new DummyPlayer());
 		/*
 		 * TODO: handle error
 		 * 
@@ -355,57 +300,35 @@ void MMF::MediaObject::createPlayer(const MediaSource &source)
 			break;
 	}
 		
-    if(!m_player.isNull())
-    {
-		connect(m_player.data(), SIGNAL(totalTimeChanged()), SIGNAL(totalTimeChanged()));
-		connect(m_player.data(), SIGNAL(stateChanged(Phonon::State, Phonon::State)), SIGNAL(stateChanged(Phonon::State, Phonon::State)));
-		connect(m_player.data(), SIGNAL(finished()), SIGNAL(finished()));
-		connect(m_player.data(), SIGNAL(tick(qint64)), SIGNAL(tick(qint64)));
-    }
+	connect(m_player.data(), SIGNAL(totalTimeChanged()), SIGNAL(totalTimeChanged()));
+	connect(m_player.data(), SIGNAL(stateChanged(Phonon::State, Phonon::State)), SIGNAL(stateChanged(Phonon::State, Phonon::State)));
+	connect(m_player.data(), SIGNAL(finished()), SIGNAL(finished()));
+	connect(m_player.data(), SIGNAL(tick(qint64)), SIGNAL(tick(qint64)));
 }
 
 void MMF::MediaObject::setNextSource(const MediaSource &source)
 {
-	if(!m_player.isNull())
-	{
-		m_player->setNextSource(source);
-	}
+    m_player->setNextSource(source);
 }
 
 qint32 MMF::MediaObject::prefinishMark() const
 {
-	qint32 result = 0;
-	if(!m_player.isNull())
-	{
-		result = m_player->prefinishMark();
-	}
-	return result;
+    return m_player->prefinishMark();
 }
 
 void MMF::MediaObject::setPrefinishMark(qint32 mark)
 {
-	if(!m_player.isNull())
-	{
-		m_player->setPrefinishMark(mark);
-	}
+    m_player->setPrefinishMark(mark);
 }
 
 qint32 MMF::MediaObject::transitionTime() const
 {
-	qint32 result = 0;
-	if(!m_player.isNull())
-	{
-		result = m_player->transitionTime();
-	}
-	return result;
+    return m_player->transitionTime();
 }
 
 void MMF::MediaObject::setTransitionTime(qint32 time)
 {
-	if(!m_player.isNull())
-	{
-		m_player->setTransitionTime(time);
-	}
+    m_player->setTransitionTime(time);
 }
 
 //-----------------------------------------------------------------------------
@@ -414,29 +337,16 @@ void MMF::MediaObject::setTransitionTime(qint32 time)
 
 qreal MMF::MediaObject::volume() const
 {
-	qreal result = 0.0;
-	if(!m_player.isNull())
-	{
-		m_player->volume();
-	}
-	return result;
+    return m_player->volume();
 }
 
 bool MMF::MediaObject::setVolume(qreal volume)
 {
-	bool result = false;
-	if(!m_player.isNull())
-	{
-		result = m_player->setVolume(volume);
-	}
-	return result;
+    return m_player->setVolume(volume);
 }
 
 void MMF::MediaObject::setAudioOutput(AudioOutput* audioOutput)
 {
-	if(!m_player.isNull())
-	{
-		m_player->setAudioOutput(audioOutput);
-	}
+    m_player->setAudioOutput(audioOutput);
 }