/*
* 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: FM Radio widget radio service client
*
*/

// System includes
#include <xqserviceglobal.h>

// User includes
#include "radiohswidgetradioserviceclient.h"
#include "radiohswidget.h"
#include "radionotificationdata.h"
#include "radioservicedef.h"
#include "radiologger.h"

/*!
    \class RadioHsWidgetRadioServiceClient
    \brief Implementation of QtHighway based communicator with radio application.

    RadioHsWidgetRadioServiceClient implements monitoring of radio
    information and controlling of radio. This is done by service request
    through QtHighway.
*/

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

/*!
    Constructs a profile reader which is a child of \a parent.
 */
RadioHsWidgetRadioServiceClient::RadioHsWidgetRadioServiceClient(
    RadioHsWidget *parent) :
    QObject(parent),
    mParent(*parent),
    mRequestPending(false),
    mRadioMonitorRequest(NULL),
    mRadioControlRequest(NULL),
    mDataInitialized(false)
{
    LOG_METHOD;
}

/*!
    Destructor 
 */
RadioHsWidgetRadioServiceClient::~RadioHsWidgetRadioServiceClient()
{
    LOG_METHOD;
    stopMonitoring();
}

/*!
    Command FM Radio station.
 
    \param command Command to request radio to perform.
 */
void RadioHsWidgetRadioServiceClient::commandFmRadio(
    const RadioServiceCommand::CommandId command)
{
    LOG_METHOD_ENTER;
    QVariant commandArgument;
    commandArgument.setValue(static_cast<int>(command));
    FmRadio::VisibiltyAfterRequest visibility;
    if (command == RadioServiceCommand::Foreground) {
        visibility = FmRadio::VisibiltyToForeground;
    } else if (command == RadioServiceCommand::Background) {
        visibility = FmRadio::VisibiltyToBackground;
    }  else {
        visibility = FmRadio::VisibiltyDoNotChange;
    }
    sendControlRequest(commandArgument, visibility);
}

/*!
    Start radio monitoring.
    
    \param visibility Desired visibility for the radio after the request.
 */
void RadioHsWidgetRadioServiceClient::startMonitoring(
    FmRadio::VisibiltyAfterRequest visibility)
{
    LOG_METHOD_ENTER;
    createMonitorServiceRequest();
    sendMonitorRequest(visibility);
}

/*!
    Stops radio monitoring.
 */
void RadioHsWidgetRadioServiceClient::stopMonitoring()
{
    LOG_METHOD_ENTER;
    // Delete the mRadioMonitorRequest. 
    if (mRadioMonitorRequest) {
        delete mRadioMonitorRequest;
        mRadioMonitorRequest = NULL;
        mRequestPending = false;
        mDataInitialized = false;
    }
}

/*!
    Creates and returns RadioNotificationData.
    This is needed because radionotificationdata.h cannot be
    included on test code.
 */
QVariant RadioHsWidgetRadioServiceClient::createRadioNotificationData(int type, const QVariant& data)
{
    LOG_METHOD_ENTER;
    QVariant ret;
    ret.setValue(RadioNotificationData(type, data));
    return ret;
}


/*!
    Handles request errors.
 
    \param errorCode Code of the error type.
    \param errorMessage Error message.
 */
void RadioHsWidgetRadioServiceClient::handleError(const int errorCode,
    const QString &errorMessage)
{
    LOG_METHOD_ENTER;
    Q_UNUSED(errorMessage)
    LEVEL2(LOG_SLOT_CALLER);
    handleRequestError(errorCode);
}

/*!
    Handle changes in FM Radio.
 
    \param value List of information published by radio.
 */
void RadioHsWidgetRadioServiceClient::handleFmRadioChange(
    const QVariant &value)
{
    LOG_METHOD_ENTER;
    LEVEL2(LOG_SLOT_CALLER);
    // Request is not pending anymore.
    mRequestPending = false;
    // If first request was refresh operation.
    if (!mDataInitialized) {
        LOG("Set operation to KRadioServiceMonitorOperation");
        // Change the operation to the monitoring.
        mRadioMonitorRequest->setOperation(RADIO_MONITOR_SERVICE_OPERATION);
        // Data is now initialized.
        mDataInitialized = true;
    }
    // Request notifications again.
    startMonitoring(FmRadio::VisibiltyDoNotChange);
    
    // If valid and right kind of data was received.
    if (value.canConvert(QVariant::List) ) {
        QVariantList notificationList = value.toList();
        // Iterate through the list.
        foreach (const QVariant& variant, notificationList) {
            // Extract notification data.
            RadioNotificationData notification = variant.value<RadioNotificationData>();
            // And it's type.
            const int notificationId = notification.mType;
            // And the data
            const QVariant notificationData = notification.mData;
            // If the data is valid.
            if (notificationData.isValid()) {
                // Notify the observer about the new information.
                mParent.handleRadioInformationChange(notificationId, notificationData);
            }
        }
    }
}

/*!
    Handles request error.
 
    \param error Identifies the error. 
 */
void RadioHsWidgetRadioServiceClient::handleRequestError(const int error)
{
    LOG_METHOD;
    QString errorStr;
    switch (error) {
    case XQService::ENoError:
        errorStr = "No error";
        break;
    case XQService::EConnectionError:
        errorStr = "Error in IPC Connection";
        break;
    case XQService::EConnectionClosed:
        errorStr = "IPC Connection is closed";
        stopMonitoring();
        mParent.handleRadioStateChange(FmRadio::StateNotRunning);
        break;
    case XQService::EServerNotFound:
        errorStr = "Can not find server";
        break;
    case XQService::EIPCError:
        errorStr = "Known IPC error defined by SDK";
        break;
    case XQService::EUnknownError:
        errorStr = "Unknown IPC error";
        break;
    case XQService::ERequestPending:
        errorStr = "Already pending request";
        break;
    default:
        errorStr = "default case at error";
        break;
    }
    LOG(GETSTRING(errorStr));
}

/*!
    Creates control service request object.
 */
void RadioHsWidgetRadioServiceClient::createControlServiceRequest()
{
    LOG_METHOD_ENTER;
    if (!mRadioControlRequest) {
        LOG("Create request");
        mRadioControlRequest = mApplicationManager.create(
            RADIO_CONTROL_SERVICE, RADIO_CONTROL_SERVICE_OPERATION, false);
        
        if (mRadioControlRequest) {
            LOG("Request created");
            // Connect request to handle it's error.
            Radio::connect(mRadioControlRequest,
                SIGNAL(requestError(int,const QString&)), this,
                SLOT(handleError(int,const QString&)));
            
            // Request is synchronous.
            mRadioControlRequest->setSynchronous(true);
            // Request is not embedded.
            mRadioControlRequest->setEmbedded(false);
        }
    }
}

/*!
    Creates monitor service request object.
 */
void RadioHsWidgetRadioServiceClient::createMonitorServiceRequest()
{
    LOG_METHOD_ENTER;
    if (!mRadioMonitorRequest) {
        // If data is not initialized, set operation to refresh,
        // otherwise to monitor operation.
        QString operation = mDataInitialized ? RADIO_MONITOR_SERVICE_OPERATION
            : RADIO_MONITOR_SERVICE_REFRESH_OPERATION;

        LOG("Create request");
        mRadioMonitorRequest = mApplicationManager.create(
            RADIO_MONITOR_SERVICE, operation, false);
        
        if (mRadioMonitorRequest) {
            LOG("Request created");
            // Connect request to handle it's completion.
            Radio::connect(mRadioMonitorRequest, SIGNAL(requestOk(const QVariant&)),
                this, SLOT(handleFmRadioChange(const QVariant&)));
            // Connect request to handle it's error.
            Radio::connect(mRadioMonitorRequest,
                SIGNAL(requestError(int,const QString&)), this,
                SLOT(handleError(int,const QString&)));
            
            // Request is asynchronous.
            mRadioMonitorRequest->setSynchronous(false);
            // Request is not embedded.
            mRadioMonitorRequest->setEmbedded(false);
        }
    }
}

/*!
    Sends the control request containing the command.
    
    \param argument Contains the command.
    \param visibility Desired visibility for the radio after the request.
 */
void RadioHsWidgetRadioServiceClient::sendControlRequest(
    const QVariant &argument,
    const FmRadio::VisibiltyAfterRequest visibility)
{
    LOG_METHOD_ENTER;
    if (!argument.isValid()) {
        return;
    }
    
    // If there is not mRadioControlRequest already.
    if (!mRadioControlRequest) {
        // Create it.
        createControlServiceRequest();
    }
    
    // Set argument list for request.
    QVariantList arguments;
    arguments.append(argument);
    mRadioControlRequest->setArguments(arguments);
    
    prepareRequestInfo(mRadioControlRequest, visibility);
    
    LOG("Send request");
    bool res = mRadioControlRequest->send();
    
    /*
    if (!res) {
        LOG("Send failed");
        int error = mRadioControlRequest->lastError();
        handleRequestError(error);
    }
    */
}

/*!
    Sends the monitor request.
    
    \param visibility Desired visibility for the radio after the request.
 */
void RadioHsWidgetRadioServiceClient::sendMonitorRequest(
    const FmRadio::VisibiltyAfterRequest visibility)
{
    LOG_METHOD_ENTER;
    prepareRequestInfo(mRadioMonitorRequest, visibility);
    if (!mRequestPending) {
        LOG("Send request");
        mRequestPending = mRadioMonitorRequest->send();
    }
}

/*!
    Prepares the visibility of the request.
    
    \param request Request to prepare.
    \param visibility Desired visibility for the radio after the request.
 */
void RadioHsWidgetRadioServiceClient::prepareRequestInfo(
    XQAiwRequest *request,
    const FmRadio::VisibiltyAfterRequest visibility)
{
    LOG_METHOD_ENTER;
    XQRequestInfo info;
    if (visibility == FmRadio::VisibiltyToForeground) {
        info.setForeground(true);
    } else if (visibility == FmRadio::VisibiltyToBackground) {
        info.setBackground(true);
    }
    if (request) {
        request->setInfo(info);
    }
}