/*

#include <hbmessagebox.h>

#include <QTimer>

#ifdef Q_CC_NOKIAX86

#include <QFile>

#include <QTextStream>

#endif

#include "irplaycontroller.h"

#include "irapplication.h"

#include "irqmediaplayer.h"

#include "irviewmanager.h"

#include "irqisdsdatastructure.h"

#include "irlastplayedstationinfo.h"

#include "irqnetworkcontroller.h" 

#include "irqsonghistoryengine.h"

#include "irqmetadata.h"

#include "irqsettings.h"

#include "irqfavoritesdb.h"

#include "irqstatisticsreporter.h"

#ifdef Q_CC_NOKIAX86

void getRadioServerAddress(QString & aUrl);

#endif

BEGIN_ENUM_MAP( KTerminationTypeMap )

    ENUM_MAP_ITEM( EIRQUserTerminated, IRQStatisticsReporter::EIRUserTerminated ),

    ENUM_MAP_ITEM( EIRQNoConnectionToServer, IRQStatisticsReporter::EIRNoConnToServer ),

    ENUM_MAP_ITEM( EIRQNoConnectionToNetwork, IRQStatisticsReporter::EIRNoConnToNetwork )            

END_ENUM_MAP( KTerminationTypeMap )

#define MAP_TO_ENGINE_TerminationType(ui_enum) \

          MAP_TO_ENGINE_ENUM( IRQTerminatedType, \

             IRQStatisticsReporter::IRTerminatedType, \

             ui_enum, KTerminationTypeMap )

BEGIN_ENUM_MAP( KServerResultMap )

    ENUM_MAP_ITEM( EIRQPlayerErrorServerFull, IRQStatisticsReporter::EIRServerFull ),

    ENUM_MAP_ITEM( EIRQPlayerErrorTimeOut, IRQStatisticsReporter::EIRTimeOut ),

    ENUM_MAP_ITEM( EIRQPlayerErrorConnectingFailed, IRQStatisticsReporter::EIRConnectFailed )              

END_ENUM_MAP( KServerResultMap )

#define MAP_TO_ENGINE_ServerResult(ui_enum) \

          MAP_TO_ENGINE_ENUM( IRQError, \

             IRQStatisticsReporter::IRServerResult, \

             ui_enum, KServerResultMap )

BEGIN_ENUM_MAP( KConnectedFromMap )

    ENUM_MAP_ITEM( EIRQIsds, IRQStatisticsReporter::EIRIsds ),

    ENUM_MAP_ITEM( EIRQPresetAdhoc, IRQStatisticsReporter::EIRPresetAdhoc ),

    ENUM_MAP_ITEM( EIRQPresetIsds, IRQStatisticsReporter::EIRPresetIsds ),

    ENUM_MAP_ITEM( EIRQHistoryAdhoc, IRQStatisticsReporter::EIRHistoryAdhoc ),

    ENUM_MAP_ITEM( EIRQHistoryIsds, IRQStatisticsReporter::EIRHistoryIsds ),

    ENUM_MAP_ITEM( EIRQAdhocManual, IRQStatisticsReporter::EIRAdhocManual ),                

    ENUM_MAP_ITEM( EIRQAdhocExternal, IRQStatisticsReporter::EIRAdhocExternal )            

END_ENUM_MAP( KConnectedFromMap )

#define MAP_TO_ENGINE_ConnectedFrom(ui_enum) \

          MAP_TO_ENGINE_ENUM( IRQConnectedFrom, \

             IRQStatisticsReporter::IRConnectedFrom, \

             ui_enum, KConnectedFromMap )                 

//                                        public functions

/*

 * Description : constructor

 */

IRPlayController::IRPlayController(IRApplication* aApplication) :

    iApplication(aApplication),

    iMediaPlayer(new IRQMediaPlayer()),

    iStatisticsReporter(NULL),

    iConnectedFrom(EIRQIsds),

    iGetServerResult(false),

    iNowPlayingPreset(new IRQPreset()),

    iMetaData(NULL),

    iSongHistoryEngine(IRQSongHistoryEngine::openInstance()),

    iPlayState(EIdle),

    iResuming(false),

    iTryingBitrate(0),

    iUrlArray(0),

    iRealBitrate(0),

    iLastError(EIRQErrorNone),

    iStopReason(EIRQUnknownTermination)

{

    connectSignalSlot(); 

    iStatisticsReporter = IRQStatisticsReporter::openInstance();

}

/*

 * Description : destructor

 */

IRPlayController::~IRPlayController()

{

    stop(EIRQUserTerminated);

    delete iMediaPlayer;

    iMediaPlayer = NULL;

    delete iNowPlayingPreset;

    iNowPlayingPreset = NULL;

    delete iUrlArray;

    iUrlArray = NULL;

    if (iSongHistoryEngine)

    {

        iSongHistoryEngine->closeInstance();

        iSongHistoryEngine = NULL;

    }

    if (iStatisticsReporter)

    {

        iStatisticsReporter->closeInstance();

    }

}

/*

 * 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.

        // iAvailableBitrate is cleared in getAvailableBitrates().

        aPreset->sortURLArray();

        aPreset->getAvailableBitrates(iAvailableBitrate);

        if (iAvailableBitrate.count() == 0)

        {

            return;

        }

        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;

        *iNowPlayingPreset = *aPreset;

        delete iUrlArray;

        iUrlArray = NULL;

        iUrlArray = iNowPlayingPreset->getURLsForBitrate(selectedBitRate);

        if (iUrlArray)

        {

            QString url = iUrlArray->at(0);

#ifdef Q_CC_NOKIAX86

            if (iLastPlayedChannelName != aPreset->name)

            {

                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);

        }

    }

}

/*

 * Description : RESUME playing after play is stopped.

 *               Use the last played url as station's url.

 */

void IRPlayController::resume()

{

    qDebug("IRPlayController::resume(), Entering");

    if (iMediaPlayer && (EStopped == iPlayState))

    {

        iResuming = true;

        if (iLastPlayedUrl != "")

        {

            qDebug("IRPlayController::resume(), iLastPlayedUrl is not empty, doPlay()");

            doPlay(iLastPlayedUrl);

        }

    }

    qDebug("IRPlayController::resume(), Exiting");

}

/*

 * Description : stop playing

 */

void IRPlayController::stop(IRQTerminatedType aStopReason)

{

    qDebug("IRPlayController::stop, Entering, aStopReason=%d", aStopReason);

    if (iMediaPlayer)

    {

        iMediaPlayer->disableStereoEffect();

        iMediaPlayer->stop();

        if (EPlaying == iPlayState)

        {

            iStopReason = aStopReason;

            // 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();

        }

        iPlayState = EStopped;

    }

	endSession(aStopReason);

	qDebug("IRPlayController::stop, Exiting");

}

/*

 * Description : End Session

 */

void IRPlayController::endSession(IRQTerminatedType aStopReason)

{

    if(iStatisticsReporter)

    {

        if(!iGetServerResult)

        {

            iStatisticsReporter->logServerResult(iLastPlayedUrl,IRQStatisticsReporter::EIRConnectFailed);

        }

        iStatisticsReporter->sessionEnded(MAP_TO_ENGINE_TerminationType(aStopReason));

    }

}

/*

 * Description : get current volume setting from media player or

 *               central repository

 * Return      : current volume

 */

int IRPlayController::getVolume() const

{

    if (EPlaying == iPlayState)

    {

        return iMediaPlayer->getVolume();

    }

    else

    {

        return iApplication->getSettings()->getVolumeSetting();

    }

}

/*

 * Description : set volume to media player and central repository

 * Parameters  : aVolume : volume value, between 0 and 100

 */

void IRPlayController::setVolume(int aVolume)

{

    if (EPlaying == iPlayState)

    {

        iMediaPlayer->setVolume(aVolume);

    }

    iApplication->getSettings()->setVolumeSetting(aVolume);

}

/*

 * Description : return the flag of playing state

 * Return      : true  : playing is ongoing

 */

bool IRPlayController::isPlaying() const

{

    return (EPlaying == iPlayState);

}

/*

 * Description : return the flag of stopped state

 * Return      : true  : playing is stopped

 */

bool IRPlayController::isStopped() const

{

    return (EStopped == iPlayState);

}

/*

 * Description : return the now playing preset

 * Return      : pointer to the now playing preset

 */

IRQPreset * IRPlayController::getNowPlayingPreset() const

{

    return iNowPlayingPreset;

}

QString IRPlayController::getNowPlayingUrl() const

{

    return iLastPlayedUrl;

}

int IRPlayController::getNowPlayingBitRate() const

{

    return iRealBitrate;

}

/*

 * Description : return current metadata

 * Return      : pointer to current metadata

 */

IRQMetaData * IRPlayController::getMetaData() const

{

    return iMetaData;

}

IRQTerminatedType IRPlayController::getStopReason() const

{

    return iStopReason;

}

//                                           slot  functions

/*

 * Description : data connection has been established. Signal is emitted by media player.

 * 

 */

void IRPlayController::connectionEstablished(int aBitrate)

{

    if(iStatisticsReporter)

    {

        iStatisticsReporter->logServerResult(iLastPlayedUrl,IRQStatisticsReporter::EIRConnected);

        iGetServerResult = true;

        iStatisticsReporter->markSessionStart();

    }

    iMetaData = NULL;

    iRealBitrate = aBitrate;

    // update bitrate for user defined channel

    if (0 == iNowPlayingPreset->type)

    {

        if (iTryingBitrate != iRealBitrate)

        {

            iNowPlayingPreset->setUrlBitrate(0,iRealBitrate);

            //when bitrate is available, it should be written to favorites db

            iApplication->getFavoritesDB()->replaceUserDefinedPreset(*iNowPlayingPreset);

            iTryingBitrate = iRealBitrate;

        }

    }

}

/*

 * Description : error occurred in media player. Signal is emitted by media player.

 * Parameters  : aError : error value

 */

void IRPlayController::errorOccured(IRQError aError)

{

    iLastError = aError;

    QTimer::singleShot(1, this, SLOT(handleError()));

}

/*

 * Description : handle the error async.

 */

void IRPlayController::handleError()

{

    qDebug("IRPlayController::handleError(), Entering, iLastError - %d", iLastError);

    switch (iLastError)

    {

    case EIRQPlayerErrorServerFull:

    case EIRQPlayerErrorTimeOut:

    case EIRQPlayerErrorConnectingFailed:

        if(iStatisticsReporter)

        {

            iStatisticsReporter->logServerResult(iLastPlayedUrl,MAP_TO_ENGINE_ServerResult(iLastError));

            iGetServerResult = true;

        }

        // if there's NO other URL to try, show warning.

        if (iNowPlayingPreset->getChannelURLCount() == 1)

        {

		    stop(EIRQNoConnectionToServer);

            break;

        }

        if (iResuming)

        {

            HbMessageBox::information(tr("Connecting failed, try next URL"), (QObject*)NULL, NULL);

            connectToChannel(iNowPlayingPreset,iConnectedFrom);

            iResuming = false;

            return;

        }

        // try next

        if (true == playNextUrl())

        {

            return;

        }

        else

        {

            stop(EIRQNoConnectionToServer);

        }

        break;

    case EIRQPlayerErrorConnectionLost:

        qDebug("IRPlayController::handleError, connection lost");

        stop(EIRQNoConnectionToServer);

        break;

    case EIRQPlayerErrorGeneral:

    default:

        stop(EIRQUnknownTermination);

        break;

    }

    createNote();

    qDebug("IRPlayController::handleError(), Exiting");

}

/*

 * Description : buffering process has updated, change the display of buffering dialog.

 *               If aProress is 100, buffering is complete, now playing view needs to 

 *               be shown to user.

 * Parameters  : aProgress : progress value, between 0 and 100.

 */

void IRPlayController::updateProgress(int aProgress)

{

    if (100 == aProgress)

    {

        //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)

        {

            iApplication->getViewManager()->activateView(EIRView_PlayingView);

            iPlayState = EPlaying;

            //update last played station

            IRLastPlayedStationInfo *lastPlayedStationInfo = iApplication->getLastPlayedStationInfo();

            lastPlayedStationInfo->updateLastPlayedStation(iNowPlayingPreset,iConnectedFrom);

            lastPlayedStationInfo->commitLastPlayedStation();

            //increase the played times of current preset

            iApplication->getFavoritesDB()->increasePlayedTimes(*iNowPlayingPreset);

            emit playingStarted();

            // if the metadata is available, show it.

            emit metaDataAvailable(iMetaData);

            // 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

 *               to set volume.

 * Parameters  : aVolume : volume value

 */

void IRPlayController::fetchVolume(int &aVolume)