FCL/sf/app/internetradio: comparison qtinternetradio/ui/src/irplaycontroller.cpp

equal deleted inserted replaced

-:bfc95e24a059
+:c9471d26c7f2
 /*
 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 *
 * Initial Contributors:
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description:
 *
 */
-#include <hbprogressdialog.h>
 #include <hbmessagebox.h>
 #include <QTimer>
 #ifdef Q_CC_NOKIAX86
 #include <QFile>
 #include <QTextStream>
+#endif
+#ifdef HS_WIDGET_ENABLED
+#include <QSettings>
 #endif
 #include "irplaycontroller.h"
 #include "irapplication.h"
 #include "irqmediaplayer.h"
 #include "irqsonghistoryengine.h"
 #include "irqmetadata.h"
 #include "irqsettings.h"
 #include "irqfavoritesdb.h"
 #include "irqstatisticsreporter.h"
 #include "irenummapper.h"
+#include "irqlogger.h"
+#ifdef HS_WIDGET_ENABLED
+#include "irservicedef.h"
+#endif
 #ifdef Q_CC_NOKIAX86
 void getRadioServerAddress(QString & aUrl);
 #endif
 #define MAP_TO_ENGINE_ConnectedFrom(ui_enum) \
 MAP_TO_ENGINE_ENUM( IRQConnectedFrom, \
 IRQStatisticsReporter::IRConnectedFrom, \
 ui_enum, KConnectedFromMap )
+static bool loadStationLogoFlag();
+static void saveStationLogoFlag(bool aIsStationLogoAvailable);
 //                                        public functions
 /*
 * Description : constructor
 */
 IRPlayController::IRPlayController(IRApplication* aApplication) :
 iApplication(aApplication),
 iMediaPlayer(new IRQMediaPlayer()),
 iStatisticsReporter(NULL),
+iGetServerResult(false),
+iNowPlayingPreset(new IRQPreset()),
+iNowPlayingPresetBackup(new IRQPreset()),
 iConnectedFrom(EIRQIsds),
-iGetServerResult(false),
+iConnectedFromBackup(EIRQIsds),
-iBufferingDialog(NULL),
+iStationLogoAvailable(false),
-iNowPlayingPreset(new IRQPreset()),
+iStationLogoAvailableBackup(false),
 iMetaData(NULL),
 iSongHistoryEngine(IRQSongHistoryEngine::openInstance()),
 iPlayState(EIdle),
 iResuming(false),
 iTryingBitrate(0),
 iUrlArray(0),
 iRealBitrate(0),
 iLastError(EIRQErrorNone),
-iStopReason(EIRQUnknownTermination)
+iStopReason(EIRQUnknownTermination),
-{
+iErrorNote(NULL)
+{
+// use the last played station to initiliaze the backup value.
+// can regard the player is bootup, and initilize its LCD screen with last played station info if available.
+IRQPreset *lastPlayedPreset = iApplication->getLastPlayedStationInfo()->getLastPlayedStation();
+if (lastPlayedPreset)
+{
+*iNowPlayingPreset      =   *lastPlayedPreset;
+iLastPlayedUrl          =   getFirstTryUrl(lastPlayedPreset);
+iConnectedFrom          =   iApplication->getLastPlayedStationInfo()->connectedFrom();
+iStationLogoAvailable   =   loadStationLogoFlag();
+}
+if (iNowPlayingPreset->getChannelURLCount())
+{
+iPlayState = EStopped;
+}
+else
+{
+iPlayState = EIdle;
+}
 connectSignalSlot();
 iStatisticsReporter = IRQStatisticsReporter::openInstance();
 }
 /*
 * Description : destructor
 */
 IRPlayController::~IRPlayController()
 {
-delete iBufferingDialog;
-iBufferingDialog = NULL;
 stop(EIRQUserTerminated);
 delete iMediaPlayer;
 iMediaPlayer = NULL;
 delete iNowPlayingPreset;
 iNowPlayingPreset = NULL;
+delete iNowPlayingPresetBackup;
+iNowPlayingPresetBackup = NULL;
 delete iUrlArray;
 iUrlArray = NULL;
+delete iErrorNote;
+iErrorNote = NULL;
+saveStationLogoFlag(iStationLogoAvailable);
 if (iSongHistoryEngine)
 {
 iSongHistoryEngine->closeInstance();
 iSongHistoryEngine = NULL;
 }
 * Description : connect to a channel specified by aPreset.
 * Parameters  : aPreset : the preset of the channel
 */
 void IRPlayController::connectToChannel(IRQPreset *aPreset, IRQConnectedFrom aConnectedFrom)
 {
-iConnectedFrom = aConnectedFrom;
 if (!aPreset)
 {
 return;
 }
 if (iMediaPlayer)
 {
-// sort the URL by ascending order and get all available rates.
+QString firstTryUrl = getFirstTryUrl(aPreset);
-// iAvailableBitrate is cleared in getAvailableBitrates().
+if (firstTryUrl.isEmpty())
-aPreset->sortURLArray();
-aPreset->getAvailableBitrates(iAvailableBitrate);
-if (iAvailableBitrate.count() == 0)
 {
 return;
 }
-int selectedBitRate = 0;
+*iNowPlayingPresetBackup = *iNowPlayingPreset;
-IRQPreferredQuality preferredQuality = iApplication->getSettings()->getPreferredQuality();
+iLastPlayedUrlBackup = iLastPlayedUrl;
-switch(preferredQuality)
+iConnectedFromBackup = iConnectedFrom;
-{
-case EIRQStandardQuality:
+*iNowPlayingPreset = *aPreset;
-selectedBitRate = iAvailableBitrate.first();
+iLastPlayedUrl = firstTryUrl;
-break;
+iConnectedFrom = aConnectedFrom;
-case EIRQHighQuality:
+iResuming = false;
-selectedBitRate = iAvailableBitrate.last();
+doPlay(iLastPlayedUrl);
-break;
+}
-default:
+}
-selectedBitRate = iAvailableBitrate.first();
-break;
+QString IRPlayController::getFirstTryUrl(IRQPreset *aPreset)
-}
+{
+QString firstTryUrl;
-// get URL to play
+// sort the URL by ascending order and get all available rates.
-iTryingBitrate = selectedBitRate;
+// iAvailableBitrate is cleared in getAvailableBitrates().
-*iNowPlayingPreset = *aPreset;
+aPreset->sortURLArray();
-delete iUrlArray;
+aPreset->getAvailableBitrates(iAvailableBitrate);
-iUrlArray = NULL;
+if (iAvailableBitrate.count() == 0)
-iUrlArray = iNowPlayingPreset->getURLsForBitrate(selectedBitRate);
+{
-if (iUrlArray)
+return firstTryUrl;
-{
+}
-QString url = iUrlArray->at(0);
+int selectedBitRate = 0;
+IRQPreferredQuality preferredQuality = iApplication->getSettings()->getPreferredQuality();
+switch(preferredQuality)
+{
+case EIRQStandardQuality:
+selectedBitRate = iAvailableBitrate.first();
+break;
+case EIRQHighQuality:
+selectedBitRate = iAvailableBitrate.last();
+break;
+default:
+selectedBitRate = iAvailableBitrate.first();
+break;
+}
+// get URL to play
+iTryingBitrate = selectedBitRate;
+delete iUrlArray;
+iUrlArray = NULL;
+iUrlArray = aPreset->getURLsForBitrate(selectedBitRate);
+if (iUrlArray)
+{
+firstTryUrl = iUrlArray->at(0);
 #ifdef Q_CC_NOKIAX86
-if (iLastPlayedChannelName != aPreset->name)
+firstTryUrl = "http://172.28.182.59:8000";
-{
+getRadioServerAddress(firstTryUrl);
-emit initializeLogo();
-}
-url = "http://172.28.205.171:8000";
-getRadioServerAddress(url);
-iLastPlayedChannelName = aPreset->name;
-#else
-if (iLastPlayedUrl != iUrlArray->at(0))
-{
-emit initializeLogo();
-}
 #endif
-iLastPlayedUrl = url;
+}
-iResuming = false;
-doPlay(url);
+return firstTryUrl;
-}
-}
 }
 /*
 * Description : RESUME playing after play is stopped.
 *               Use the last played url as station's url.
 /*
 * Description : stop playing
 */
 void IRPlayController::stop(IRQTerminatedType aStopReason)
 {
 qDebug("IRPlayController::stop, Entering, aStopReason=%d", aStopReason);
-if (iMediaPlayer)
-{
+switch (iPlayState)
-iMediaPlayer->disableStereoEffect();
+{
+case EPlaying:
-iMediaPlayer->stop();
+iPlayState = EStopped;
-if (EPlaying == iPlayState)
-{
 iStopReason = aStopReason;
+if (iMediaPlayer)
+{
+iMediaPlayer->disableStereoEffect();
+iMediaPlayer->stop();
+}
 // playingStarted is emitted while iPlaying is set to true,
 // so when stop() is called and iPlaying is true, playingStopped
 // should be emitted.
 qDebug("IRPlayController::stop, emit playingStopped()");
 emit playingStopped();
-}
+break;
-iPlayState = EStopped;
+#ifdef HS_WIDGET_ENABLED
+case EConnecting:
+// No need to restore because when connecting occurs, because the connectToChannel() has NOT been invoked yet.
+// Only need to reset the player state
+if (iNowPlayingPreset->getChannelURLCount())
+{
+iPlayState = EStopped;
+}
+else
+{
+iPlayState = EIdle;
+}
+iStopReason = aStopReason;
+// Only need to restore the station logo flag since we may force it to be false when connecting started.
+// force logo to be default when current view is NOT nowplaying view && is not resuming (start playing a different station.)
+if (EIRView_PlayingView != iApplication->getViewManager()->currentViewId()
+&& iConnectingStationName != iNowPlayingPreset->name)
+{
+iStationLogoAvailable = iStationLogoAvailableBackup;
+emit stationLogoUpdated(iStationLogoAvailable);
+}
+emit connectingCancelled(iNowPlayingPreset->name);
+break;
+#endif
+case EBuffering:
+if (iMediaPlayer)
+{
+iMediaPlayer->disableStereoEffect();
+iMediaPlayer->stop();
+}
+// when player is forced to stop in bufferring state, we have to revert to backup preset.
+// only with exception when current view is nowplaying view.
+// in IR case, user can only stay in nowplaying view when buffering:
+// 1. starging view is now playing view; 2. open a pls file with only one url
+if (EIRView_PlayingView != iApplication->getViewManager()->currentViewId())
+{
+iLastPlayedUrl        = iLastPlayedUrlBackup;
+*iNowPlayingPreset    = *iNowPlayingPresetBackup;
+iConnectedFrom        = iConnectedFromBackup;
+}
+if (iNowPlayingPreset->getChannelURLCount())
+{
+iPlayState = EStopped;
+}
+else
+{
+iPlayState = EIdle;
+}
+iStopReason = aStopReason;
+#ifdef HS_WIDGET_ENABLED
+// Need to restore the station logo flag since we may force it to be false when buffering started.
+// force logo to be default when current view is NOT nowplaying view && is not resuming (start playing a different station.)
+if (EIRView_PlayingView != iApplication->getViewManager()->currentViewId()
+&& !iResuming)
+{
+iStationLogoAvailable = iStationLogoAvailableBackup;
+emit stationLogoUpdated(iStationLogoAvailable);
+}
+emit bufferingCancelled(iNowPlayingPreset->name);
+#endif
+break;
+case EIdle:
+case EStopped:
+default:
+break;
 }
 	endSession(aStopReason);
 	qDebug("IRPlayController::stop, Exiting");
 }
 iMediaPlayer->setVolume(aVolume);
 }
 iApplication->getSettings()->setVolumeSetting(aVolume);
 }
-/*
+#ifdef HS_WIDGET_ENABLED
-* Description : enable stereo effect
+void IRPlayController::setConnectingStationName(const QString &aStationName, bool aForceConnecting)
-*/
+{
-void IRPlayController::enableStereo()
+iConnectingStationName = aStationName;
-{
+if (aForceConnecting
-if (iMediaPlayer)
+|| !iApplication->getNetworkController()->getNetworkStatus())
 {
-iMediaPlayer->enableStereoEffect();
+LOG_FORMAT("IRPlayController::setConnectingStationName, the station name is %s", STRING2CHAR(aStationName));
-}
+iPlayState = EConnecting;
-}
+// force logo to be default when current view is NOT nowplaying view && is not resuming (start playing a different station.)
-/*
+if (EIRView_PlayingView != iApplication->getViewManager()->currentViewId()
-* Description : disable stereo effect
+&& iConnectingStationName != iNowPlayingPreset->name)
-*/
+{
-void IRPlayController::disableStereo()
+emitStationLogoUpdated(false);
-{
+}
-if (iMediaPlayer)
+emit connectingStarted(aStationName);
-{
+}
-iMediaPlayer->disableStereoEffect();
+}
-}
+QString IRPlayController::getConnectingStationName() const
+{
+return iConnectingStationName;
+}
+void IRPlayController::reloadNowplayingPreset(IRQPreset *aPreset, bool aIsLogoAvailable, IRQConnectedFrom aConnectedFrom)
+{
+if (aPreset)
+{
+*iNowPlayingPreset      =   *aPreset;
+iLastPlayedUrl          =   getFirstTryUrl(aPreset);
+iConnectedFrom          =   aConnectedFrom;
+iStationLogoAvailable   =   aIsLogoAvailable;
+}
+if (iNowPlayingPreset->getChannelURLCount())
+{
+iPlayState = EStopped;
+}
+else
+{
+iPlayState = EIdle;
+}
+}
+bool IRPlayController::isStationLogoAvailable() const
+{
+return iStationLogoAvailable;
+}
+void IRPlayController::emitStationLogoUpdated(bool aIsLogoAvailable)
+{
+iStationLogoAvailableBackup = iStationLogoAvailable;
+iStationLogoAvailable = aIsLogoAvailable;
+emit stationLogoUpdated(iStationLogoAvailable);
+}
+bool loadStationLogoFlag()
+{
+QSettings settings(KIrSettingOrganization, KIrSettingApplication);
+return settings.value(KIrSettingStationLogoAvailable,false).toBool();
+}
+#endif
+IRPlayController::EPlayState IRPlayController::state() const
+{
+return iPlayState;
 }
 /*
 * Description : return the flag of playing state
 * Return      : true  : playing is ongoing
-*               false : playing is stopped
+*               false : playing is not ongoing
 */
 bool IRPlayController::isPlaying() const
 {
 return (EPlaying == iPlayState);
 }
 /*
 * Description : return the flag of stopped state
 * Return      : true  : playing is stopped
-*               false : playing is ongoing
+*               false : playing is not stopped
 */
 bool IRPlayController::isStopped() const
 {
 return (EStopped == iPlayState);
+}
+/*
+* Description : return the flag of idle state
+* Return      : true  : playing is idle
+*               false : playing is not idle
+*/
+bool IRPlayController::isIdle() const
+{
+return (EIdle == iPlayState);
 }
 /*
 * Description : return the now playing preset
 * Return      : pointer to the now playing preset
 }
 IRQTerminatedType IRPlayController::getStopReason() const
 {
 return iStopReason;
-}
-/*
-* Description : show a buffering dialog to inform user the buffering stage.
-*               If the dialog is not created yet, create first.
-*/
-void IRPlayController::createBufferingDialog(const QObject *aReceiver, const char *aFunc)
-{
-if (NULL == iBufferingDialog)
-{
-iBufferingDialog = new HbProgressDialog(HbProgressDialog::ProgressDialog);
-iBufferingDialog->setMinimum(0);
-iBufferingDialog->setMaximum(100);
-iBufferingDialog->setModal(true);
-}
-//disconnect everything connected to signal cancelled()
-iBufferingDialog->disconnect(SIGNAL(cancelled()));
-connect(iBufferingDialog, SIGNAL(cancelled()), aReceiver, aFunc);
-iBufferingDialog->setProgressValue(0);
-iBufferingDialog->setText("0%");
-iBufferingDialog->show();
-}
-/*
-* Description : close the buffering dialog
-*/
-void IRPlayController::closeBufferingDialog()
-{
-if (iBufferingDialog)
-{
-iBufferingDialog->close();
-delete iBufferingDialog;
-iBufferingDialog = NULL;
-}
 }
 //                                           slot  functions
 /*
 * Description : error occurred in media player. Signal is emitted by media player.
 * Parameters  : aError : error value
 */
 void IRPlayController::errorOccured(IRQError aError)
 {
+LOG_METHOD;
+LOG_FORMAT("the error is occured %d",aError);
 iLastError = aError;
 QTimer::singleShot(1, this, SLOT(handleError()));
 }
 /*
 * Description : handle the error async.
 */
 void IRPlayController::handleError()
 {
+LOG_METHOD;
+LOG_FORMAT("the last error is %d", iLastError);
 qDebug("IRPlayController::handleError(), Entering, iLastError - %d", iLastError);
 switch (iLastError)
 {
 case EIRQPlayerErrorServerFull:
 case EIRQPlayerErrorTimeOut:
 case EIRQPlayerErrorConnectionLost:
 qDebug("IRPlayController::handleError, connection lost");
 stop(EIRQNoConnectionToServer);
 break;
+case EIRQPlayerErrorAudioDeviceLost:
+//this is a temporary way to handle the plug-out event
+iApplication->stopLoadingAnimation();
+		stop(EIRQCallIsActivated);
+return;
 case EIRQPlayerErrorGeneral:
-case EIRQPlayerErrorAudioDeviceLost:
 default:
 stop(EIRQUnknownTermination);
 break;
 }
-closeBufferingDialog();
+iApplication->stopLoadingAnimation();
+popupNote();
-createNote();
 qDebug("IRPlayController::handleError(), Exiting");
 }
 /*
 * Description : buffering process has updated, change the display of buffering dialog.
 *               be shown to user.
 * Parameters  : aProgress : progress value, between 0 and 100.
 */
 void IRPlayController::updateProgress(int aProgress)
 {
-/* we added this condition for sometimes, the function will be called
-* when the state is playing. reference cr_9010
-*/
-if( iBufferingDialog && EBuffering == iPlayState )
-{
-iBufferingDialog->setProgressValue(aProgress);
-iBufferingDialog->setText(QString("%1%").arg(aProgress));
-}
 if (100 == aProgress)
 {
-closeBufferingDialog();
 //updateProgress(100) sometimes can be called more than one time, to improve performance,
 //we only need to do the following work once.
-if (EBuffering == iPlayState)
+if (EPlaying == iPlayState)
 {
-iApplication->getViewManager()->activateView(EIRView_PlayingView);
+iApplication->stopLoadingAnimation();
-iPlayState = EPlaying;
+return;
+}
-//update last played station
-IRLastPlayedStationInfo *lastPlayedStationInfo = iApplication->getLastPlayedStationInfo();
+iPlayState = EPlaying;
-lastPlayedStationInfo->updateLastPlayedStation(iNowPlayingPreset,iConnectedFrom);
+iApplication->stopLoadingAnimation();
-lastPlayedStationInfo->commitLastPlayedStation();
+iApplication->getViewManager()->activateView(EIRView_PlayingView);
-//increase the played times of current preset
-iApplication->getFavoritesDB()->increasePlayedTimes(*iNowPlayingPreset);
+//update last played station
+IRLastPlayedStationInfo *lastPlayedStationInfo = iApplication->getLastPlayedStationInfo();
-emit playingStarted();
+lastPlayedStationInfo->updateLastPlayedStation(iNowPlayingPreset,iConnectedFrom);
+lastPlayedStationInfo->commitLastPlayedStation();
-// if the metadata is available, show it.
-emit metaDataAvailable(iMetaData);
+//increase the played times of current preset
+iApplication->getFavoritesDB()->increasePlayedTimes(*iNowPlayingPreset);
-// Save the station information to database
-IRQMetaData tmpMetaData;
+emit playingStarted();
-tmpMetaData.setBitrate(iRealBitrate);
-tmpMetaData.setStreamUrl(iLastPlayedUrl);
+// if the metadata is available, show it.
-iSongHistoryEngine->handleMetaDataReceived(tmpMetaData, *iNowPlayingPreset);
+emit metaDataAvailable(iMetaData);
-// open stereo defaultly
-iMediaPlayer->enableStereoEffect();
+// Save the station information to database
-}
+IRQMetaData tmpMetaData;
+tmpMetaData.setBitrate(iRealBitrate);
+tmpMetaData.setStreamUrl(iLastPlayedUrl);
+iSongHistoryEngine->handleMetaDataReceived(tmpMetaData, *iNowPlayingPreset);
+// open stereo defaultly
+iMediaPlayer->enableStereoEffect();
 }
 }
 /*
 * Description : get volume value from application setting. media player use the value
 * Description : handle the receiption of metadata. Notify now playing view to update display
 * Parameters  : aIRmetaData : the metadata object
 */
 void IRPlayController::handleMetaDataReceived(IRQMetaData& aIRmetaData)
 {
 iMetaData = &aIRmetaData;
 //TO DO: there maybe a potential bug when the user cancel the play,
 if ((aIRmetaData.getSongName().trimmed() != "")
 || (aIRmetaData.getArtistName().trimmed() != ""))
 {
 //when we are play the musicplayer and get the metadata from lower layer, we save the
 //song's metadata into the db.  After we save it to db, we emit the next signal to notify the UI
 iSongHistoryEngine->handleSongMetaDataReceived(*iMetaData,
-iNowPlayingPreset->musicStoreStatus);
+*iNowPlayingPreset);
 }
 if (EPlaying == iPlayState)
 {
 // This signal will cause addBanner() work. Sometimes the metadata will come before
 * Description : during buffering stage, cancel playing request
 */
 void IRPlayController::cancelBuffering()
 {
 stop(EIRQUserTerminated);
-if (!iResuming && EIRView_PlayingView == iApplication->getViewManager()->currentViewId())
+iApplication->stopLoadingAnimation();
-{
-iApplication->getViewManager()->backToPreviousView();
-}
 }
 //                                       private functions
 /*
 * Description : show a note to user to inform that error occured.
 *
 */
-void IRPlayController::createNote(const QString &aNote)
+void IRPlayController::popupNote(const QString &aNote)
 {
-HbMessageBox::warning(aNote, (QObject*)NULL, NULL);
+if (NULL == iErrorNote)
+{
+iErrorNote = new HbMessageBox(HbMessageBox::MessageTypeWarning);
+iErrorNote->setModal(true);
+iErrorNote->setTimeout(HbPopup::StandardTimeout);
+}
+iErrorNote->setText(aNote);
+// if there is already on error note showing, only change the text
+if (!iErrorNote->isVisible())
+{
+iErrorNote->show();
+}
 }
 /*
 * Description : establish the signal&slot connection between media player and play controller
 */
 unsigned long apId = 0;
 iApplication->getNetworkController()->getIAPId(apId);
 qDebug("IRPlayController::doPlay, access point : %d", apId);
 iMediaPlayer->playStation(aUrl, apId);
 iPlayState = EBuffering;
+#ifdef HS_WIDGET_ENABLED
+// force logo to be default when current view is NOT nowplaying view && is not resuming (start playing a different station.)
+if (EIRView_PlayingView != iApplication->getViewManager()->currentViewId()
+&& !iResuming)
+{
+emitStationLogoUpdated(false);
+}
+emit bufferingStarted(iNowPlayingPreset->name);
+#endif
 startSession();
-createBufferingDialog(this, SLOT(cancelBuffering()));
+iApplication->startLoadingAnimation(this, SLOT(cancelBuffering()));
 }
 /*
 * Description : start a session
 */
 int IRPlayController::bitrateTrying() const
 {
 return iTryingBitrate;
 }
 #endif
+void saveStationLogoFlag(bool aIsStationLogoAvailable)
+{
+QSettings settings(KIrSettingOrganization, KIrSettingApplication);
+QVariant data(QVariant::Bool);
+data.setValue(aIsStationLogoAvailable);
+settings.setValue(KIrSettingStationLogoAvailable,data);
+}
 //get IP address configuration of test radio server
 #ifdef Q_CC_NOKIAX86
 void getRadioServerAddress(QString & aUrl)
 {

branch	GCC_SURGE
changeset 13	c9471d26c7f2
parent 12	608f67c22514
child 14	896e9dbc5f19