/*

* 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: internet radio hs widget service client

*

*/

// System includes

#include <QSettings>

#include <QVariant>

#include <QString>

#include <hbicon.h>

#include <xqserviceglobal.h>

#include <xqservicerequest.h>

// User includes

#include "irserviceclient.h"

#include "irservicedata.h"

// Constants

// For services via Qt HighWay

static const QString KIrServiceName = "internet_radio_10_1";

static const QString KIrServiceControlInterfaceName = "com.nokia.symbian.IInternetRadioControl";

static const QString KIrServiceControlOperation     = "handleCmd(int)";

static const QString KIrServiceMonitorInterfaceName = "com.nokia.symbian.IInternetRadioMonitor";

static const QString KIrServiceMonitorOperation     = "registerNotifications()";

static const QString KIrServiceRefreshOperation     = "refreshAllData()";

// ==================== MEMBER FUNCTIONS ======================

// Constructor

IrServiceClient::IrServiceClient(QObject *aParent) :

    QObject(aParent),

    mIrAppInspector(NULL),

    mMonitorReqOngoing(false),    

    mControlReqOngoing(false),

    mMonitorRequest(NULL),

    mRefreshRequest(NULL),

    mControlRequest(NULL)

{

    mIrAppInspector = new IrAppInspector(this);

    QObject::connect(mIrAppInspector, SIGNAL(irRunningStatusChanged(IrAppInspector::IrRunningStatus)),

        this, SLOT(handleIrRunningStatusChanged(IrAppInspector::IrRunningStatus)));

}

// Destructor

IrServiceClient::~IrServiceClient()

{   

    delete mMonitorRequest;

    mMonitorRequest = NULL;

    delete mRefreshRequest;

    mRefreshRequest = NULL;

    delete mControlRequest;

    mControlRequest = NULL;

}

bool IrServiceClient::startMonitoringIrState()

{

    bool retVal = false;

    if (mIrAppInspector->isIrRunning())

    {

        retVal = doSendRefreshRequest();

    }

    else

    {

        if (isStationPlayed())

        {

            initHsWidgetNoRunStopped();

        }

        else

        {

            emit irStateChanged(IrAppState::NoRunInit);

        }

    }

    return mIrAppInspector->startInspectingIrRunningStatus() && retVal;    

}

void IrServiceClient::stopMonitoringIrState()

{

    delete mMonitorRequest;

    mMonitorRequest = NULL;

    delete mRefreshRequest;

    mRefreshRequest = NULL;

}

void IrServiceClient::initHsWidgetNoRunStopped()

{

    emit irStateChanged(IrAppState::NoRunStopped);

    QString stationName;

    if (loadStationName(stationName))

    {

        emit stationNameUpdated(stationName);

    }

    else

    {

        emit stationNameUpdated(QString(""));

    }

    emit stationLogoUpdated(loadStationLogoFlag());

}

/******************************************************************

****************   Monitor Service Request  **********************

*******************************************************************/

bool IrServiceClient::doSendMonitorRequest()

{

    if(mMonitorReqOngoing)

    {

        return false;

    }

    if (NULL == mMonitorRequest

        &&!createMonitorServiceRequest())

    {

        return false;

    }

    prepareRequestInfo(mMonitorRequest, DoNotChange);

    return mMonitorRequest->send();

}

bool IrServiceClient::createMonitorServiceRequest()

{

    bool retVal = false;

    if (NULL == mMonitorRequest)

    {

        mMonitorRequest = mApplicationManager.create(KIrServiceName,

                KIrServiceMonitorInterfaceName,

                KIrServiceMonitorOperation,

                false);

        if (mMonitorRequest)

        {

            retVal = true;

            connect(mMonitorRequest, SIGNAL(requestOk(const QVariant&)),

                this, SLOT(handleMonitorRequestOk(const QVariant&)));

            connect(mMonitorRequest, SIGNAL(requestError(int,const QString&)),

                this, SLOT(handleMonitorRequestError(int,const QString&)));

            mMonitorRequest->setEmbedded(false);

            mMonitorRequest->setSynchronous(false);

        }

    }

    else

    {

        retVal = true;

    }

    return retVal;

}

// ==================== Refresh Service Request ===========================

bool IrServiceClient::doSendRefreshRequest()

{

    if(mMonitorReqOngoing)

    {

        return false;

    }

    if (NULL == mRefreshRequest

        && !createRefreshServiceRequest())

    {

        return false;

    }

    prepareRequestInfo(mRefreshRequest, DoNotChange);        

    return mRefreshRequest->send();

}

bool IrServiceClient::createRefreshServiceRequest()

{

    bool retVal = false;

    if (NULL == mRefreshRequest)

    {

        mRefreshRequest = mApplicationManager.create(KIrServiceName,

                KIrServiceMonitorInterfaceName,

                KIrServiceRefreshOperation,

                false);

        if (mRefreshRequest)

        {

            retVal = true;

            connect(mRefreshRequest, SIGNAL(requestOk(const QVariant&)),

                this, SLOT(handleMonitorRequestOk(const QVariant&)));

            connect(mRefreshRequest, SIGNAL(requestError(int,const QString&)),

                this, SLOT(handleMonitorRequestError(int,const QString&)));

            mRefreshRequest->setEmbedded(false);

            mRefreshRequest->setSynchronous(false);

        }

    }

    else

    {

        retVal = true;

    }

    return retVal;

}

void IrServiceClient::handleMonitorRequestOk(const QVariant &aRetValue)

{

    mMonitorReqOngoing = false;

    doSendMonitorRequest();

    if (aRetValue.isValid()

         && aRetValue.canConvert(QVariant::List))

    {

        QVariantList dataList = aRetValue.toList();

        foreach (const QVariant& data, dataList)

        {

            if (data.canConvert<IrServiceData>())

            {

                IrServiceData serviceData = data.value<IrServiceData>();

                processNotificationData(serviceData);

            }

        }

    }

}

void IrServiceClient::handleMonitorRequestError(int aErrCode, const QString &aErrMessage)

{

    mMonitorReqOngoing = false;

    Q_UNUSED(aErrCode);

    Q_UNUSED(aErrMessage);

}

/******************************************************************

****************   Control Service Request  **********************

*******************************************************************/

bool IrServiceClient::bringIrForeground()

{

    QVariant commandArgument(QVariant::Int);

    commandArgument.setValue((int)IrServiceCmd::Foreground);

    return doSendControlRequest(commandArgument, true, ToForeground);

}

bool IrServiceClient::launchIrNormally()

{

    QVariant commandArgument(QVariant::Int);

    commandArgument.setValue((int)IrServiceCmd::LaunchNormally);

    return doSendControlRequest(commandArgument, true, ToForeground);

}

bool IrServiceClient::launchIrNowPlaying()

{

    QVariant commandArgument(QVariant::Int);

    commandArgument.setValue((int)IrServiceCmd::LaunchNowPlayingView);

    return doSendControlRequest(commandArgument, false, ToBackground);

}

bool IrServiceClient::startPlaying()

{

    QVariant commandArgument(QVariant::Int);

    commandArgument.setValue((int)IrServiceCmd::Play);

    return doSendControlRequest(commandArgument, true, DoNotChange);

}

bool IrServiceClient::stopPlaying()

{

    QVariant commandArgument(QVariant::Int);

    commandArgument.setValue((int)IrServiceCmd::Stop);

    return doSendControlRequest(commandArgument, true, DoNotChange);

}

bool IrServiceClient::cancelLoading()

{

    QVariant commandArgument(QVariant::Int);

    commandArgument.setValue((int)IrServiceCmd::Cancel);

    return doSendControlRequest(commandArgument, true, DoNotChange);

}

bool IrServiceClient::doSendControlRequest(const QVariant &aArgument, bool aIsSync, IrAppVisibilty aVisibility)

{

    if(mControlReqOngoing)

    {

        return false;

    }

    if (NULL == mControlRequest &&

        !createControlServiceRequest())

    {

        return false;

    }

    QList<QVariant> arguments;

    arguments.append(aArgument);

    mControlRequest->setArguments(arguments);

    prepareRequestInfo(mControlRequest, aVisibility);

    mControlRequest->setSynchronous(aIsSync);    

    return mControlRequest->send();

}

bool IrServiceClient::createControlServiceRequest()

{

    bool retVal = false;

    if (NULL == mControlRequest)

    {

        mControlRequest = mApplicationManager.create(KIrServiceName,

                KIrServiceControlInterfaceName,

                KIrServiceControlOperation,

                false);

        if (mControlRequest)

        {

            retVal = true;

            connect(mControlRequest, SIGNAL(requestOk(const QVariant&)),

                this, SLOT(handleControlRequestOk(const QVariant&)));

            connect(mControlRequest, SIGNAL(requestError(int,const QString&)),

                this, SLOT(handleControlRequestError(int,const QString&)));

            mControlRequest->setEmbedded(false);

        }

    }

    else

    {

        retVal = true;

    }

    return retVal;

}

void IrServiceClient::handleControlRequestOk(const QVariant &aRetValue)

{

    mControlReqOngoing = false;    

    if (aRetValue.isValid()

         && aRetValue.canConvert(QVariant::Int))

    {

        if (IrServiceResult::Fail == aRetValue.toInt())

        {

            emit controlFailed();

        }

    }    

}

void IrServiceClient::handleControlRequestError(int aErrCode, const QString &aErrMessage)

{

    mControlReqOngoing = false;

    emit controlFailed();

    Q_UNUSED(aErrCode);

    Q_UNUSED(aErrMessage);    

}

/******************************************************************

*************************   Others   ******************************

*******************************************************************/

// slot connected to signals from IrAppInspector,

// used to monitor the startup / exit of IR

void IrServiceClient::handleIrRunningStatusChanged(IrAppInspector::IrRunningStatus aNewStatus)

{

    switch (aNewStatus)

    {

        case IrAppInspector::StartingUp :

            doSendRefreshRequest();

            break;

        case IrAppInspector::Exiting :

            stopMonitoringIrState();

            if (isStationPlayed())

            {

                resetHsWidgetExitStopped();

            }

            else

            {

                emit irStateChanged(IrAppState::NoRunInit);

            }            

            break;

        default:

            break;

    }

}

void IrServiceClient::resetHsWidgetExitStopped()

{

    emit irStateChanged(IrAppState::NoRunStopped);

    emit metaDataUpdated(QString(""));

}

// used to process service data sent from IR app.

void IrServiceClient::processNotificationData(const IrServiceData &aServiceData)

{

    QVariant data = aServiceData.mData;

    if (!data.isValid())

    {

        return;

    }

    switch (aServiceData.mType)

    {

        case IrServiceNotification::StationName:

            if (data.canConvert(QVariant::String))

            {

                emit stationNameUpdated(data.toString());

            }

            break;

        case IrServiceNotification::MetaData:

            if (data.canConvert(QVariant::String))

            {

                emit metaDataUpdated(data.toString());

            }

            break;

        case IrServiceNotification::StationLogo:

            if (data.canConvert(QVariant::Bool))

            {

                emit stationLogoUpdated(data.toBool());

            }            

            break;

        case IrServiceNotification::IrState:

            if (data.canConvert(QVariant::Int))

            {

                emit irStateChanged((IrAppState::Type)data.toInt());

            }

            break;

        default:

            break;

    }

}

// prepare the request send to IR app, including control request, refresh request, monitor request.

void IrServiceClient::prepareRequestInfo(XQAiwRequest *aRequest, IrAppVisibilty aVisibility)

{

    if (NULL == aRequest)

    {

        return;

    } 

    XQRequestInfo reqInfo;

    switch (aVisibility)

    {

        case ToForeground:

            reqInfo.setForeground(true);

            break;

        case ToBackground:

            reqInfo.setBackground(true);

            break;

        case DoNotChange:

            break;

        default:

            break;

    }

    aRequest->setInfo(reqInfo);

}

bool IrServiceClient::isStationPlayed()

{

    QSettings settings(KIrSettingOrganization, KIrSettingApplicaton);

    QString stationName = settings.value(KIrSettingStationName,KIrDefaultStationName).toString();

    return stationName != KIrDefaultStationName;

}

bool IrServiceClient::loadStationLogoFlag()

{

    QSettings settings(KIrSettingOrganization, KIrSettingApplicaton);

    return settings.value(KIrSettingStationLogoAvailable,false).toBool();

}

bool IrServiceClient::loadStationName(QString &aStationName)

{

    QSettings settings(KIrSettingOrganization, KIrSettingApplicaton);

    aStationName = settings.value(KIrSettingStationName,KIrDefaultStationName).toString();

    if(aStationName != KIrDefaultStationName)

    {

        return true;

    }

    else

    {

        return false;

    }

}

Q_IMPLEMENT_USER_METATYPE(IrServiceData)