/*

* Copyright (c) 2010 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 home screen widget

*

*/

// System includes

#include <HbPushButton>

#include <HbLabel>

#include <HbDocumentLoader>

#include <HbFrameDrawer>

#include <HbFrameItem>

#include <HbIcon>

#include <HbIconAnimationManager>

#include <HbIconAnimationDefinition>

#include <HbColorScheme>

#include <HbDeviceMessageBox>

#include <QGraphicsLinearLayout>

#include <QGraphicsItem>

#include <QDesktopServices>

#include <QSignalMapper>

// User includes

#include "radiohswidget.h"

#include "radiohswidgetprofilereader.h"

#include "radiohswidgetradioserviceclient.h"

#include "radioservicedef.h"

#include "radio_global.h"

#include "radiologger.h"

// Constants

/** Path to docml file */

const QString DOCML(":/ui/resource/fmradiohswidget.docml");

/** Path to css file */

const QString CSS(":/ui/resource/fmradiohswidget.css");

/**  DOCML object name for mainLayout */

const QString DOCML_OBJECT_NAME_MAIN_LAYOUT("mainLayout");

/**  DOCML object name for contentLayout */

const QString DOCML_OBJECT_NAME_CONTENT_LAYOUT("contentLayout");

/**  DOCML object name for tunerBackgroundPushButton */

const QString DOCML_OBJECT_NAME_TUNER_BACKGROUND_BUTTON(

    "tunerBackgroundPushButton");

/**  DOCML object name for tunerStackedLayout */

const QString DOCML_OBJECT_NAME_TUNER_STACKED_LAYOUT("tunerStackedLayout");

/**  DOCML object name for tunerInformationStackedLayout */

const QString DOCML_OBJECT_NAME_TUNER_INFORMATION_STACKED_LAYOUT(

    "tunerInformationStackedLayout");

/**  DOCML object name for controlButtons */

const QString DOCML_OBJECT_NAME_CONTROL_BUTTONS_LAYOUT("controlButtons");

/**  DOCML object name for powerToggleButton */

const QString DOCML_OBJECT_NAME_POWER_BUTTON("powerButton");

/**  DOCML object name for previousPushButton */

const QString DOCML_OBJECT_NAME_PREVIOUS_BUTTON("previousPushButton");

/**  DOCML object name for nextPushButton */

const QString DOCML_OBJECT_NAME_NEXT_BUTTON("nextPushButton");

/**  DOCML object name for twoRowsLayout */

const QString DOCML_OBJECT_NAME_TWO_ROWS_LAYOUT("twoRowsLayout");

/**  DOCML object name for firstRowLabel */

const QString DOCML_OBJECT_NAME_FIRST_ROW_LABEL("firstRowLabel");

/**  DOCML object name for secondRowLabel */

const QString DOCML_OBJECT_NAME_SECOND_ROW_LABEL("secondRowLabel");

/**  DOCML object name for lonelyRowLabel */

const QString DOCML_OBJECT_NAME_LONELY_ROW_LABEL("lonelyRowLabel");

/**  DOCML object name for animationIcon */

const QString DOCML_OBJECT_NAME_ANIMATION_ICON("animationIcon");

/** Unknown favorite station count. */

const int FAVORITE_STATION_COUNT_UNDEFINED(-1);

/** One favorite station set. */

const int FAVORITE_STATION_COUNT_ONE(1);

// Graphics identifiers for different push button states

const QString CONTROL_BUTTON_GRAPHICS_NORMAL  ("qtg_fr_hsbutton_normal");

const QString CONTROL_BUTTON_GRAPHICS_PRESSED ("qtg_fr_hsbutton_pressed");

const QString CONTROL_BUTTON_GRAPHICS_DISABLED("qtg_fr_hsbutton_disabled");

const QString CONTROL_BUTTON_GRAPHICS_LATCHED ("qtg_fr_hsbutton_latched");

// Push button icon colors for each of the states (normal, pressed, disabled

// and latched)

const QString CONTROL_BUTTON_ICON_COLOR_NORMAL  ("qtc_button_normal");

const QString CONTROL_BUTTON_ICON_COLOR_PRESSED ("qtc_button_pressed");

const QString CONTROL_BUTTON_ICON_COLOR_DISABLED("qtc_button_disabled");

const QString CONTROL_BUTTON_ICON_COLOR_LATCHED ("qtc_button_latched");

// File name suffix lists for push buttons

const QStringList POWER_BUTTON_SUFFIX(

    (QStringList() << "_l" << "_c" << "_cr"));

const QStringList PREVIOUS_BUTTON_SUFFIX(

    (QStringList() << "_cl" << "_c" << "_cr"));

const QStringList NEXT_BUTTON_SUFFIX(

    (QStringList() << "_cl" << "_c" << "_r"));

/** Icon for power button off. */

const QString POWER_BUTTON_ICON_OFF("qtg_mono_power"); 

/** Icon for power button on. */

const QString POWER_BUTTON_ICON_ON ("qtg_mono_power"); 

// Tuner background button graphics for different states.

const QString TUNER_BUTTON_NORMAL_OFF("qtg_fr_tuner");

const QString TUNER_BUTTON_NORMAL_ON("qtg_fr_tuner");

const QString TUNER_BUTTON_NORMAL_PRESSED("qtg_fr_hsitems2_pressed");

/*!

    \class RadioHsWidget

    \brief Implementation of FM Radio home screen widget.

    RadioHsWidget implements needed functions for the FM Radio home screen

    widget.

*/

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

/*!

    Constructs a widget which is a child of \a parent, with widget flags set

    to \a flags.

    Constructor should be empty and all the actual construction should be

    done in onInitialize().

 */

RadioHsWidget::RadioHsWidget(QGraphicsItem* parent, Qt::WindowFlags flags)

    : HbWidget(parent, flags),

      mInformationAreaBackgroundButton(NULL),

      mPowerButton(NULL),

      mPreviousButton(NULL),

      mNextButton(NULL),

      mInformationAreaTwoRowsLayout(NULL),

      mInformationLonelyRowLabel(NULL),

      mInformationFirstRowLabel(NULL),

      mInformationSecondRowLabel(NULL),

      mAnimationIcon(NULL),

      mFmRadioState(FmRadio::StateUndefined),

      mFavoriteStationCount(FAVORITE_STATION_COUNT_UNDEFINED),

      mCurrentStationIsFavorite(false),

      mProfileMonitor(NULL),

      mRadioServiceClient(NULL)

{

    LOG_METHOD;

}

/*!

    Destructor

 */

RadioHsWidget::~RadioHsWidget()

{

    LOG_METHOD;

}

/*!

    Handles changes in FM Radio information.

    \param informationType Type of changed information.

    \param information Actual information.

 */

void RadioHsWidget::handleRadioInformationChange(const int informationType,

    const QVariant &information)

{

    LOG_METHOD;

    LEVEL2(LOG_SLOT_CALLER);

    if (!information.isValid()) {

        // informationValue is not valid so return.

        return;

    }

    switch (informationType) {

    case RadioServiceNotification::FavoriteCount:

        LEVEL2(LOG("FavoriteCount"));

        if (information.canConvert(QVariant::Int)) {

            mFavoriteStationCount = information.toInt();

            // If there are favorite stations, enable the next/previous

            // buttons.

            LEVEL2(LOG_FORMAT("favoriteCount: %d, mFavoriteStations: %d",

                    mFavoriteStationCount, mFavoriteStations));

            // Enable or disable buttons only if favoriteCount differs

            // from 1. CurrentIsFavorite case handles situation when there

            // is only one favorite station.

            if (mFavoriteStationCount != FAVORITE_STATION_COUNT_ONE) {

                enableStationButtons();

            }

        }

        break;

    case RadioServiceNotification::CurrentIsFavorite:

        LEVEL2(LOG("CurrentIsFavorite"));

        if (information.canConvert(QVariant::Bool)) {

            mCurrentStationIsFavorite = information.toBool();

            LEVEL2(LOG_FORMAT("currentIsFavorite: %d", mCurrentStationIsFavorite));

            // If current station is favorite disable next/prev buttons.

            // Radio sends this information only when there is only one

            // favorite station set.

            enableStationButtons();

        }

        break;

    case RadioServiceNotification::RadioStatus:

        LEVEL2(LOG("RadioStatus"));

        if (information.canConvert(QVariant::Int)) {

            const int status = information.toInt();

            switch (status) {

            case RadioStatus::Playing:

                LOG("Playing");

                //handleRadioStateChange(FmRadio::StateControllingAudio);

                //handleRadioStateChange(FmRadio::StateRunning);

                break;

            case RadioStatus::Muted:

                LOG("Muted");

                //handleRadioStateChange(FmRadio::StateNotControllingAudio);

                break;

            case RadioStatus::Seeking:

                LEVEL2(LOG("Seeking"));

                handleRadioStateChange(FmRadio::StateSeeking);

                break;

            case RadioStatus::NoAntenna:

                LEVEL2(LOG("NoAntenna"));

                handleRadioStateChange(FmRadio::StateAntennaNotConnected);

                break;

            case RadioStatus::PoweringOff:

                LEVEL2(LOG("PoweringOff"));

                handleRadioStateChange(FmRadio::StateClosing);

                break;

            default:

                LOG("default case at case RadioStatus");

                break;

            }

        }

        break;

    case RadioServiceNotification::Frequency:

        LEVEL2(LOG("Frequency"));

        if (information.canConvert(QVariant::String)) {

            LEVEL2(LOG_FORMAT("frequency: %s", GETSTRING(information.toString())));

            // TODO: Remove comment when localisation is working on device.

            //frequencyString = hbTrId("txt_fmradiohswidget_rad_list_l1_mhz").arg(freqString);

            bool frequencyCleared = false;

            // If widget has some frequency information and new frequency

            // differs from that

            if (mRadioInformation.contains(Frequency)

                && mRadioInformation[Frequency].compare(information.toString()) != 0) {

                // Clear all infromation from widget because station has changed.

                clearRadioInformation();

                frequencyCleared = true;

            }

            // If widget do not have any frquency information, update it.

            bool frequencyUpdated = updateRadioInformation(Frequency,

                information.toString());

            if (frequencyCleared || frequencyUpdated) {

                // Information changed, update the UI.

                changeInRadioInformation();

            }

        }

        break;

    case RadioServiceNotification::Name:

        LEVEL2(LOG("Name"));

        handleSimilarRadioInformation(StationName, information);

        break;

    case RadioServiceNotification::Genre:

        LEVEL2(LOG("Genre"));

        handleSimilarRadioInformation(Pty, information);

        break;

    case RadioServiceNotification::RadioText:

        LEVEL2(LOG("RadioText"));

        handleSimilarRadioInformation(RadioText, information);

        break;

    case RadioServiceNotification::DynamicPS:

        LOG("DynamicPS");

        handleSimilarRadioInformation(DynamicPsName, information);

        break;

    default:

        LOG("default case at notificationId");

        break;

    }

}

/*!

    Handles changes in FM Radio state.

    \param value New state of the radio application.

*/

void RadioHsWidget::handleRadioStateChange(const QVariant &value)

{

    LOG_METHOD;

    int state;

    if (value.canConvert(QVariant::Int)) {

        state = value.toInt();

    } else {

        return;

    }

    if (state == mFmRadioState) {

        // State did not change, so return.

        return;

    }

    switch (state) {

    case FmRadio::StateUndefined:

        LEVEL2(LOG("FmRadio::StateUndefined"));

        // Something went wrong. Widget should not be in this state after onInitialize().

        mFmRadioState = FmRadio::StateUndefined;

        break;

    case FmRadio::StateNotRunning:

        LEVEL2(LOG("FmRadio::StateNotRunning"));

        mFmRadioState = FmRadio::StateNotRunning;

        mRadioServiceClient->stopMonitoring();

        changePowerButtonOn(false);

        mFavoriteStationCount = FAVORITE_STATION_COUNT_UNDEFINED;

        mCurrentStationIsFavorite = false;

        enableStationButtons();

        clearRadioInformation();

        mInformationFirstRowLabel->setPlainText("");

        mInformationSecondRowLabel->setPlainText("");

        mInformationLonelyRowLabel->setPlainText(hbTrId("txt_fmradiohswidget_rad_list_fm_radio"));

        changeInformationAreaLayout(OneRow);

        break;

    case FmRadio::StateStarting:

        LEVEL2(LOG("FmRadio::StateStarting"));

        mFmRadioState = FmRadio::StateStarting;

        changePowerButtonOn(true);

        mFavoriteStationCount = FAVORITE_STATION_COUNT_UNDEFINED;

        mCurrentStationIsFavorite = false;

        enableStationButtons();

        changeInformationAreaLayout(Animation);

        break;

    case FmRadio::StateRunning:

        LEVEL2(LOG("FmRadio::StateRunning"));

        mFmRadioState = FmRadio::StateRunning;

        // Stop timer if it is running because radio is now running.

        mRadioServiceClient->startMonitoring(

            FmRadio::VisibiltyDoNotChange);

        changePowerButtonOn(true);

        enableStationButtons();

        changeInformationAreaLayout(OneRow);

        break;

/*        

    case FmRadio::StateControllingAudio:

        LEVEL2(LOG("FmRadio::StateControllingAudio"));

        mFmRadioState = FmRadio::StateControllingAudio;

        enableStationButtons();

        changeInRadioInformation();

        break;

    case FmRadio::StateNotControllingAudio:

        LEVEL2(LOG("FmRadio::StateNotControllingAudio"));

        mFmRadioState = FmRadio::StateNotControllingAudio;

        enableStationButtons();

        changeInRadioInformation();

        break;

*/

    case FmRadio::StateSeeking:

        LEVEL2(LOG("FmRadio::StateSeeking"));

        mFmRadioState = FmRadio::StateSeeking;

        mFavoriteStationCount = FAVORITE_STATION_COUNT_UNDEFINED;

        mCurrentStationIsFavorite = false;

        enableStationButtons();

        changeInformationAreaLayout(Animation);

        break;

    case FmRadio::StateAntennaNotConnected:

        LEVEL2(LOG("FmRadio::StateAntennaNotConnected"));

        mFmRadioState = FmRadio::StateAntennaNotConnected;

        mFavoriteStationCount = FAVORITE_STATION_COUNT_UNDEFINED;

        mCurrentStationIsFavorite = false;

        enableStationButtons();

        mInformationFirstRowLabel->setPlainText("");

        mInformationSecondRowLabel->setPlainText("");

        mInformationLonelyRowLabel->setPlainText(hbTrId(

            "txt_fmradiohswidget_rad_info_connect_wired_headset"));

        changeInformationAreaLayout(OneRow);

        break;

    case FmRadio::StateClosing:

        LEVEL2(LOG("FmRadio::StateClosing"));

        mFmRadioState = FmRadio::StateClosing;

        changePowerButtonOn(false);

        mFavoriteStationCount = FAVORITE_STATION_COUNT_UNDEFINED;

        mCurrentStationIsFavorite = false;

        enableStationButtons();

        clearRadioInformation();

        mInformationFirstRowLabel->setPlainText("");

        mInformationSecondRowLabel->setPlainText("");

        mInformationLonelyRowLabel->setPlainText(hbTrId(

            "txt_fmradiohswidget_rad_list_fm_radio"));

        changeInformationAreaLayout(OneRow);

        break;

    default:

        LOG("default case at state");

        break;

    }

}

/*!

    Called when widget is initialized. Constructs objects and connects them.

*/

void RadioHsWidget::onInitialize()

{

    LOG_METHOD_ENTER;

    mProfileMonitor = new RadioHsWidgetProfileReader(this);

    mRadioServiceClient = new RadioHsWidgetRadioServiceClient(this);

    load(DOCML);

    // Use signal mapper to indicate button identifiers to button event

    // slots. 

    QSignalMapper* signalMapperPressed = new QSignalMapper(this); 

    signalMapperPressed->setMapping(mPowerButton, Power);

    signalMapperPressed->setMapping(mPreviousButton, Previous);

    signalMapperPressed->setMapping(mNextButton, Next);

    // Need to use different signal mapper for pressed and released events, 

    // both have same mappings but they are mapped to different slots.

    QSignalMapper* signalMapperReleased = new QSignalMapper(this);

    signalMapperReleased->setMapping(mPowerButton, Power);

    signalMapperReleased->setMapping(mPreviousButton, Previous);

    signalMapperReleased->setMapping(mNextButton, Next);

    // Connect button events to signal maps.

    Radio::connect(mPowerButton, SIGNAL(pressed()), signalMapperPressed, SLOT (map()));

    Radio::connect(mPowerButton, SIGNAL(released()), signalMapperReleased, SLOT (map()));

    Radio::connect(mPreviousButton, SIGNAL(pressed()), signalMapperPressed, SLOT (map()));

    Radio::connect(mPreviousButton, SIGNAL(released()), signalMapperReleased, SLOT (map()));

    Radio::connect(mNextButton, SIGNAL(pressed()), signalMapperPressed, SLOT (map()));

    Radio::connect(mNextButton, SIGNAL(released()), signalMapperReleased, SLOT (map()));

    // Connect mapper signals to self implemented slots.

    Radio::connect(signalMapperPressed, SIGNAL(mapped(int)), this, SLOT(changeButtonToPressed(int)));

    Radio::connect(signalMapperReleased, SIGNAL(mapped(int)), this, SLOT(changeButtonToReleased(int)));

    mProfileMonitor->startMonitoringRadioRunningStatus();

}

/*!

    Called when widget is shown in the home screen

*/

void RadioHsWidget::onShow()

{

    LOG_METHOD_ENTER;

}

/*!

    Called when widget is hidden from the home screen

*/

void RadioHsWidget::onHide()

{

    LOG_METHOD_ENTER;

}

/*!

    Emited from HbPushButton:pressed() signal, changes the button layout to

    pressed state.

    \param hsButtonIdentifier Identifies the button which was pressed.

 */

void RadioHsWidget::changeButtonToPressed(int hsButtonIdentifier)

{

    LOG_METHOD;

    buttonEvent(static_cast<ControlButtonIdentifier>(hsButtonIdentifier), Pressed);

}

/*!

    Emited from HbPushButton:released() signal, changes the button layout to

    normal state.

    \param hsButtonIdentifier Identifies the button which was released.

 */

void RadioHsWidget::changeButtonToReleased(int hsButtonIdentifier)

{

    LOG_METHOD;

    buttonEvent(static_cast<ControlButtonIdentifier>(hsButtonIdentifier), Normal);

}

/*!

    Slot for closing FM Radio application from power button.

 */

void RadioHsWidget::closeRadio()

{

    LOG_SLOT_CALLER;

    mRadioServiceClient->commandFmRadio(RadioServiceCommand::PowerOff);

}

/*!

    Slot for previous button clicked.

 */

void RadioHsWidget::changeToPreviousStation()

{

    LOG_SLOT_CALLER;

    clearRadioInformation();

    mRadioServiceClient->commandFmRadio(RadioServiceCommand::Previous);

}

/*!

    Slot for next button clicked.

 */

void RadioHsWidget::changeToNextStation()

{

    LOG_SLOT_CALLER;

    clearRadioInformation();

    mRadioServiceClient->commandFmRadio(RadioServiceCommand::Next);

}

/*!

    Slot for bringing the radio application to foreground.

 */

void RadioHsWidget::changeRadioToForeground()

{

    LOG_SLOT_CALLER;

    // If radio is not running start it to foreground by monitor request.

    if (mFmRadioState == FmRadio::StateNotRunning) {

        bool okToStartRadio = radioStartPermission();

        if (okToStartRadio) {

            handleRadioStateChange(FmRadio::StateStarting);

            mRadioServiceClient->startMonitoring(

                FmRadio::VisibiltyToForeground);

        }

    }

    else {