/*

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

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

/** Favorite station count lower boundary including this number. */

const int FAVORITE_STATION_COUNT_LOWER_BOUNDARY(0);

/** Favorite station count upper boundary including this number. */

const int FAVORITE_STATION_COUNT_UPPER_BOUNDARY(100);

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

    switch (informationType) {

    case RadioServiceNotification::FavoriteCount:

        LOG("FavoriteCount");

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

            information.toInt() >= FAVORITE_STATION_COUNT_LOWER_BOUNDARY &&

            information.toInt() <= FAVORITE_STATION_COUNT_UPPER_BOUNDARY) {

            mFavoriteStationCount = information.toInt();

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

            // buttons.

            LOG_FORMAT("mFavoriteStationCount: %d", mFavoriteStationCount);

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

            }

        } else {

            mFavoriteStationCount = FAVORITE_STATION_COUNT_UNDEFINED;

        }

        break;

    case RadioServiceNotification::CurrentIsFavorite:

        LOG("CurrentIsFavorite");

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

            mCurrentStationIsFavorite = information.toBool();

            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:

        LOG("RadioStatus");

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

            const int status = information.toInt();

            switch (status) {

            case RadioStatus::Playing:

                LOG("Playing");

                handleRadioStateChange(FmRadio::StateRunning);

                break;

            case RadioStatus::Muted:

                LOG("Muted");

                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:

        LOG("Frequency");

        // TODO: Should information.toString() be checked for too many characters? What's the limit?

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

            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 (mRadioInformation.contains(Frequency)) {

                // Clear all infromation.

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

                mFmRadioState = FmRadio::StateRunning;

            }

        }

        break;

    case RadioServiceNotification::Name:

        LOG("Name");

        handleSimilarRadioInformation(StationName, information);

        break;

    case RadioServiceNotification::Genre:

        LOG("Genre");

        handleSimilarRadioInformation(Pty, information);

        break;

    case RadioServiceNotification::RadioText:

        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:

        LOG("FmRadio::StateUndefined");

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

        mFmRadioState = FmRadio::StateUndefined;

        break;

    case FmRadio::StateNotRunning:

        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:

        LOG("FmRadio::StateStarting");

        mFmRadioState = FmRadio::StateStarting;

        changePowerButtonOn(true);

        mFavoriteStationCount = FAVORITE_STATION_COUNT_UNDEFINED;

        mCurrentStationIsFavorite = false;

        enableStationButtons();

        changeInformationAreaLayout(Animation);

        break;

    case FmRadio::StateRunning:

        LOG("FmRadio::StateRunning");

        mFmRadioState = FmRadio::StateRunning;

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

        mRadioServiceClient->startMonitoring(

            FmRadio::VisibiltyDoNotChange);

        changeInRadioInformation();

        changePowerButtonOn(true);

        enableStationButtons();

        changeInformationAreaLayout(OneRow);

        break;

    case FmRadio::StateSeeking:

        LOG("FmRadio::StateSeeking");

        mFmRadioState = FmRadio::StateSeeking;

        mCurrentStationIsFavorite = false;

        enableStationButtons();

        changeInformationAreaLayout(Animation);

        break;

    case FmRadio::StateAntennaNotConnected:

        LOG("FmRadio::StateAntennaNotConnected");

        mFmRadioState = FmRadio::StateAntennaNotConnected;

        mCurrentStationIsFavorite = false;

        enableStationButtons();

        mInformationFirstRowLabel->setPlainText("");

        mInformationSecondRowLabel->setPlainText("");

        mInformationLonelyRowLabel->setPlainText(hbTrId(

            "txt_fmradiohswidget_rad_info_connect_wired_headset"));

        changeInformationAreaLayout(OneRow);

        break;

    case FmRadio::StateClosing:

        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_FORMAT("default case at state. State: %d", 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)

{

    LEVEL2(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)

{

    LEVEL2(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 {

        if (mFmRadioState == FmRadio::StateClosing) {

            // Radio is closing but user wants to power it up again.

            mRadioServiceClient->commandFmRadio(RadioServiceCommand::PowerOn);

            // Stop and start monitoring to get refresh.

            mRadioServiceClient->stopMonitoring();

            mRadioServiceClient->startMonitoring(

                FmRadio::VisibiltyToBackground);

            handleRadioStateChange(FmRadio::StateRunning);

        }

        // If radio is running, bring it to the foreground.

        mRadioServiceClient->commandFmRadio(RadioServiceCommand::Foreground);

    }

}

/*!

    Slot for putting the radio application to the background.

 */

void RadioHsWidget::changeRadioToBackground()

{