#include <QTimer>

#include "radiologger.h"

    FmRadioHsWidget implements needed functions for the FM Radio home screen

    widget.

    Constructor should be empty and all the actual construction should be

    done in onInitialize().

      mTunerBackgroundPushButton(NULL),

      mPowerToggleButton(NULL),

      mPreviousPushButton(NULL),

      mNextPushButton(NULL),

      mInformationFirstRowLabel(NULL),

      mInformationSecondRowLabel(NULL),

      mFavoriteStations(false),

      mProfileMonitor(NULL),

      mRadioServiceClient(NULL),

      mRadioStartingCancelTimer(NULL)

    LOG_METHOD_ENTER;

    LOG_METHOD;

}

/*!

    Getter for /r mRootPath property.

*/

QString FmRadioHsWidget::rootPath()const

{

    LOG_METHOD_ENTER;

    return mRootPath;

}

/*!

    Sets the mRoothPath propertry to /a roothPath.

*/

void FmRadioHsWidget::setRootPath(const QString &rootPath)

{

    LOG_METHOD_ENTER;

    mRootPath = rootPath;

}

/*!

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

*/

void FmRadioHsWidget::onInitialize()

{

    LOG_METHOD_ENTER;

    mProfileMonitor = new FmRadioHsWidgetProfileReader(this);

    mRadioServiceClient = new FmRadioHsWidgetRadioServiceClient(this);

    mRadioStartingCancelTimer = new QTimer(this);

    connect(mRadioServiceClient, SIGNAL(radioInformationChanged(int, QVariant)), this,

        SLOT(handleRadioInformationChange(int, QVariant)));

    connect(mRadioServiceClient, SIGNAL(radioStateChanged(QVariant)), this,

        SLOT(handleRadioStateChange(QVariant)));

    connect(mProfileMonitor, SIGNAL(radioRunning(QVariant)), this,

        SLOT(handleRadioStateChange(QVariant)));

    load(KDocml);

    mProfileMonitor->startMonitoringRadioRunningStatus();

    LOG_METHOD_ENTER;

    LOG_METHOD_ENTER;

void FmRadioHsWidget::load(const QString &docml)

    LOG_METHOD_ENTER;

    bool loaded = false;

        // Find mainLayout

        HbWidget *mainLayout = qobject_cast<HbWidget*> (documentLoader->findWidget(

        // For drawing frame backgrounds

        if (mainLayout) {

            // Temporarily use graphics from resources. Change to the system

            // graphics when they are available.

            HbFrameDrawer *drawer = new HbFrameDrawer(

                ":/ui/resource/qtg_graf_hsradio_bg.png",

                HbFrameDrawer::OnePiece);

            //HbFrameDrawer *drawer = new HbFrameDrawer("qtg_fr_hswidget_normal",

            //    HbFrameDrawer::NinePieces);

            frameItem = new HbFrameItem(drawer, mainLayout);

            frameItem->setPreferredSize(mainLayout->preferredSize());

            mWidgetLayout->addItem(mainLayout);

            setLayout(mWidgetLayout);

        // Find stacked layout for tuner area.

        HbWidget *tunerStackedLayout = qobject_cast<HbWidget*> (documentLoader->findWidget(

            KDocmlObjectNameTunerStackedLayout));

        if (tunerStackedLayout) {

            // Find stacked layout for information area.

            HbWidget *tunerInformationStackedLayout = qobject_cast<HbWidget*> (documentLoader->findWidget(

                KDocmlObjectNameTunerInformationStackedLayout));

            if (tunerInformationStackedLayout) {

                // MarqueeItem tests.

                    /*

                    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Vertical, mInformationAreaOneRowLayout);

                    mInformationLonelyRowMarquee = new HbMarqueeItem();

                    mInformationLonelyRowMarquee->setObjectName("marquee3");

                    HbStyle::setItemName(mInformationLonelyRowMarquee, "marquee3");

                    mInformationLonelyRowMarquee->setText(

                        "Long text");

                    mInformationLonelyRowMarquee->setLoopCount(-1);

                    mInformationLonelyRowMarquee->startAnimation();

                    HbFontSpec fs(HbFontSpec::Secondary);

                    mInformationLonelyRowMarquee->setFontSpec(fs);

                    mInformationLonelyRowMarquee->setTextColor(HbColorScheme::color("qtc_hs_list_item_title"));

                    mInformationLonelyRowMarquee->setPreferredSize(layout->preferredSize());

                    layout->addItem(mInformationLonelyRowMarquee);

                    */

                /*

                }

                */

                // Find lonely label

                mInformationLonelyRowLabel = qobject_cast<HbLabel *> (documentLoader->findWidget(

                    KDocmlObjectNameLonelyRowLabel));

                if (mInformationLonelyRowLabel) {

                    QColor color = HbColorScheme::color("qtc_radio_tuner_normal");

                    if (color.isValid()) {

                        mInformationLonelyRowLabel->setTextColor(color);

                    }

                }

                // Find layout for two rows

                mInformationAreaTwoRowsLayout = qobject_cast<QGraphicsWidget *> (

                    documentLoader->findObject(KDocmlObjectNameTwoRowsLayout));

                if (mInformationAreaTwoRowsLayout) {

                    // Find first row

                    mInformationFirstRowLabel = qobject_cast<HbLabel *> (documentLoader->findWidget(

                        KDocmlObjectNameFirstRowLabel));

                    if (mInformationFirstRowLabel) {

                        QColor color = HbColorScheme::color("qtc_radio_tuner_normal");

                        if (color.isValid()) {

                            mInformationFirstRowLabel->setTextColor(color);

                        }

                    }

                    // Find second row

                    mInformationSecondRowLabel = qobject_cast<HbLabel *> (documentLoader->findWidget(

                        KDocmlObjectNameSecondRowLabel));

                    if (mInformationSecondRowLabel) {

                        QColor color = HbColorScheme::color("qtc_radio_tuner_normal");

                        if (color.isValid()) {

                            mInformationSecondRowLabel->setTextColor(color);

                        }

                    }

                }

                mAnimationIcon = qobject_cast<HbLabel *> (documentLoader->findWidget(

                    KDocmlObjectNameAnimationIcon));

                if (mAnimationIcon) {

                    // Use animation manager to define the frame-by-frame animation.

                    HbIconAnimationManager *animationManager = HbIconAnimationManager::global();

                    // Create animation definition.

                    HbIconAnimationDefinition animationDefinition;

                    QList<HbIconAnimationDefinition::AnimationFrame> animationFrameList;

                    // This should be probably done by loading axml instead.

                    HbIconAnimationDefinition::AnimationFrame animationFrame;

                    QString animationFrameIconName;

                    QString animationFrameIconNamePrefix = "qtg_anim_loading_";

                    for (int i = 1; i < 11; i++) {

                        animationFrame.duration = 100;

                        animationFrameIconName.clear();

                        animationFrameIconName.append(animationFrameIconNamePrefix);

                        animationFrameIconName.append(animationFrameIconName.number(i));

                        animationFrame.iconName = animationFrameIconName;

                        animationFrameList.append(animationFrame);

                    }

                    animationDefinition.setPlayMode(HbIconAnimationDefinition::Loop);

                    animationDefinition.setFrameList(animationFrameList);

                    animationManager->addDefinition("animation", animationDefinition);

                    // Construct an icon using the animation definition.

                    HbIcon icon("animation");

                    mAnimationIcon->setIcon(icon);

                }

            }

            // Find push button for tuner area.

            mTunerBackgroundPushButton = qobject_cast<HbPushButton*> (documentLoader->findWidget(

                KDocmlObjectNameTunerBackgroundPushButton));

            if (mTunerBackgroundPushButton) {

                // Test different states.

                //bool p = mTunerBackgroundPushButton->setProperty("state", "normal");

                // Try css for controlling the appearance.

                //bool b = QFile::exists(KCss);

                //bool cssLoaded = HbStyleLoader::registerFilePath(KCss);

                //HbStyle::setItemName(mTunerBackgroundPushButton, KDocmlObjectNameTunerBackgroundPushButton);

                // Use the frame background.

                HbFrameDrawer *tunerBackgroundButtonFrameDrawer = new HbFrameDrawer(

                    "qtg_fr_tuner", HbFrameDrawer::ThreePiecesHorizontal);

                tunerBackgroundButtonFrameDrawer->setFillWholeRect(true);

                mTunerBackgroundPushButton->setFrameBackground(tunerBackgroundButtonFrameDrawer);

                // Connect the button's clicked signal. 

                connect(mTunerBackgroundPushButton, SIGNAL(clicked()), this, SLOT(radioToForeground()));

            }

        // Find layout for control buttons.

        HbWidget *controlButtonsLayout = qobject_cast<HbWidget*> (documentLoader->findWidget(

            KDocmlObjectNameContolButtonsLayout));

        if (controlButtonsLayout) {

            if (frameItem) {

                // Stack widget's background behind it.

                frameItem->stackBefore(controlButtonsLayout);

            }

            // Find power button.

            mPowerToggleButton = qobject_cast<HbPushButton *> (documentLoader->findWidget(

                KDocmlObjectNameowerToggleButton));

            if (mPowerToggleButton) {

                // If power button is lathced type, use this.

                //mPowerToggleButton->setCheckable(true);

                changeControlButtonFrameBackground(false, Left, mPowerToggleButton);

                // Use the graphics from resources until release contains proper graphics. 

                mPowerToggleButton->setIcon(HbIcon(":/ui/resource/mono_power.png"));

                // Connect the button's clicked signal.

                connect(mPowerToggleButton, SIGNAL(clicked()), this, SLOT(radioToBackground()));

            }

            // Find previous button.

            mPreviousPushButton = qobject_cast<HbPushButton *> (documentLoader->findWidget(

                KDocmlObjectNamePreviousPushButton));

            if (mPreviousPushButton) {

                changeControlButtonFrameBackground(false, Center, mPreviousPushButton);

                // Connect the button's clicked signal.

                connect(mPreviousPushButton, SIGNAL(clicked()), this, SLOT(previousChannel()));

            }

            // Find next button.

            mNextPushButton = qobject_cast<HbPushButton *> (documentLoader->findWidget(

                KDocmlObjectNameNextPushButton));

            if (mNextPushButton) {

                changeControlButtonFrameBackground(false, Right, mNextPushButton);

                // Connect the button's clicked signal.

                connect(mNextPushButton, SIGNAL(clicked()), this, SLOT(nextChannel()));

    // Loader is not needed anymore so it is deleted.

 Slot for closing FM Radio application from power button.

void FmRadioHsWidget::closeRadio()

    LOG_SLOT_CALLER;

    mRadioServiceClient->doCloseFmRadio();

    LOG_SLOT_CALLER;

    clearRadioInformation();

    mRadioServiceClient->doChangeFmRadioStation(FmRadioHsWidgetRadioServiceClient::PreviousFavouriteStation);

    LOG_SLOT_CALLER;

    clearRadioInformation();

    mRadioServiceClient->doChangeFmRadioStation(FmRadioHsWidgetRadioServiceClient::NextFavouriteStation);

 Slot for bringing the radio application to foreground.

    LOG_SLOT_CALLER;

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

        //mRadioServiceClient->doPowerOnFmRadio(FmRadioHsWidgetRadioServiceClient::ToForeground);

        if (mFmRadioState == Closing) {

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

            mRadioServiceClient->doPowerOnFmRadio();

            mRadioServiceClient->stopMonitoring();

            mRadioServiceClient->startMonitoring(FmRadioHsWidgetRadioServiceClient::ToBackground);

            handleRadioStateChange(QVariant(Running));

        }

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

 Slot for putting the radio application to the background.

    LOG_SLOT_CALLER;

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

        // Do nothing if radio is starting.

    }

    else if (mFmRadioState == Closing) {

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

        mRadioServiceClient->doPowerOnFmRadio();

        mRadioServiceClient->stopMonitoring();

        mRadioServiceClient->startMonitoring(FmRadioHsWidgetRadioServiceClient::ToBackground);

        handleRadioStateChange(QVariant(Running));

        // If radio is running, put it to the background.

        // This is little bit useless because the radio is in background if

        // user is able to click the widget.

 Handles changes in FM Radio information.

void FmRadioHsWidget::handleRadioInformationChange(const int notificationId,

    const QVariant &value)

    LOG_METHOD;

    LEVEL2(LOG_SLOT_CALLER);

        // Value is not valid so return.

            LEVEL2(LOG("FavoriteCount"));

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

                // buttons.

                mFavoriteStations = favoriteCount > 0 ? true : false;

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

                    favoriteCount, mFavoriteStations));

            changeStationButtonsEnabledState(mFavoriteStations);

            }

            break;

        case RadioServiceNotification::CurrentIsFavorite:

            LEVEL2(LOG("CurrentIsFavorite"));

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

                bool currentIsFavorite = value.toBool();

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

                // If favorite count is 1 and current station is favorite

                // disable next/prev buttons.

                if (currentIsFavorite) {

                    changeStationButtonsEnabledState(false);

                } else {

                    // Else eneble them.

                    changeStationButtonsEnabledState(true);

                }

            LEVEL2(LOG("RadioStatus"));

                    LEVEL2(LOG("Playing"));

                    LEVEL2(LOG("Muted"));

                    LEVEL2(LOG("Seeking"));

                    LEVEL2(LOG("NoAntenna"));

                case RadioStatus::PoweringOff:

                    LEVEL2(LOG("PoweringOff"));

                    handleRadioStateChange(QVariant(Closing));

                    break;