/*

* Copyright (c) 2009 - 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: Big clock Screensaver.

*

*/

#include "snsrbigclockscreensaver.h"

#ifdef Q_OS_SYMBIAN

#include <XQSettingsManager> 

#include <screensaverdomaincrkeys.h>

#include <clockdomaincrkeys.h>

#endif // Q_OS_SYMBIAN

#include <QDebug>

#include <QTime>

#include <QTimer>

#include <HbInstance>

#include <HbMainWindow>

#include "snsranalogclockcontainer.h"

#include "snsrdigitalclockcontainer.h"

#include "snsroledanalogclockcontainer.h"

#include "snsroleddigitalclockcontainer.h"

#include "snsrblankcontainer.h"

#include "snsrindicatormodel.h"

/*!

    \class SnsrBigClockScreensaver

    \ingroup group_snsrbigclockscreensaverplugin

    \brief Screensaver with big digital clock.

 */

/*!

    Constructs a new SnsrBigClockScreensaver.

 */

SnsrBigClockScreensaver::SnsrBigClockScreensaver() :

    mMainWindow(0),

    mCurrentContainer(0),

    mIndicatorModel(0)

{

    mMainWindow = HbInstance::instance()->allMainWindows().at(0);

    // for nice looking clock hand transformations

    mMainWindow->setRenderHint(QPainter::SmoothPixmapTransform);

    // This model holds indicator status information and must exist as

    // long as screensaver does.

    mIndicatorModel = new SnsrIndicatorModel(this);

    // connect timer for time updates

    connect( &mTimer, SIGNAL(timeout()), SLOT(updateTime()) );

}

/*!

    Destructs the class.

 */

SnsrBigClockScreensaver::~SnsrBigClockScreensaver()

{

    // TODO: unlock orientation once the locking mechanism is available and used

    // mCurrentContainer, mIndicatorModel - deleted by the parent

}

/*!

    @copydoc Screensaver::onInitialize()

*/

bool SnsrBigClockScreensaver::onInitialize()

{

    qDebug() << "SnsrBigClockScreensaver::onInitialize()";

    return true;

}

/*!

    @copydoc Screensaver::onForeground()

 */

bool SnsrBigClockScreensaver::onForeground()

{

    SCREENSAVER_TEST_FUNC_ENTRY("SnsrBigClockScreensaver::onForeground")

    qDebug() << "SnsrBigClockScreensaver::onForeground()";

    removeCurrentContainer();

    SnsrBigClockContainer* newContainer( 0 );

    if (clockFormat() == ClockFormatAnalog) {

        newContainer = new SnsrAnalogClockContainer();

    }

    else {

        newContainer = new SnsrDigitalClockContainer();

    }

    setCurrentContainer( newContainer );

    SCREENSAVER_TEST_FUNC_EXIT("SnsrBigClockScreensaver::onForeground")

    return true;

}

/*!

    @copydoc Screensaver::onPartialForeground()

 */

bool SnsrBigClockScreensaver::onPartialForeground()

{

    SCREENSAVER_TEST_FUNC_ENTRY("SnsrBigClockScreensaver::onPartialForeground")

    qDebug() << "SnsrBigClockScreensaver::onPartialForeground()";

    removeCurrentContainer();

    SnsrBigClockContainer* newContainer( 0 );

#ifdef Q_OS_SYMBIAN  

    // Check ScreensaverStatus from repository

    XQSettingsManager::Error error;

    XQCentralRepositorySettingsKey settingsKey(

            KCRUidValueScreensaverSettings, KScreensaverStatus ); 

    XQSettingsManager setManager;

    int screensaverOn = setManager.readItemValue(settingsKey, XQSettingsManager::TypeInt).toInt();

    error = setManager.error();

    if (error != XQSettingsManager::NoError) {

        qDebug("Error reading screensaver status from XQSettingsManager.. error = %d", error);

    }

#else

    int screensaverOn = 1;

#endif // Q_OS_SYMBIAN

    if (screensaverOn) {

        if (clockFormat() == ClockFormatAnalog) {

            newContainer = new SnsrOledAnalogClockContainer();

        }

        else {

            newContainer = new SnsrOledDigitalClockContainer();

        }

    }

    else {

        newContainer = new SnsrBlankContainer();

    }

    setCurrentContainer( newContainer );

    SCREENSAVER_TEST_FUNC_EXIT("SnsrBigClockScreensaver::onPartialForeground")

    return true;

}

/*!

    @copydoc Screensaver::onBackground()

 */

bool SnsrBigClockScreensaver::onBackground()

{

    SCREENSAVER_TEST_FUNC_ENTRY("SnsrBigClockScreensaver::onBackground")

    qDebug() << "SnsrBigClockScreensaver::onBackground()";

    removeCurrentContainer();

    SCREENSAVER_TEST_FUNC_EXIT("SnsrBigClockScreensaver::onBackground")

    return true;

}

/*!

    @copydoc Screensaver::onPowerSave()

 */

bool SnsrBigClockScreensaver::onPowerSave()

{

    SCREENSAVER_TEST_FUNC_ENTRY("SnsrBigClockScreensaver::onPowerSave")

    qDebug() << "SnsrBigClockScreensaver::onPowerSave()";

    SCREENSAVER_TEST_FUNC_EXIT("SnsrBigClockScreensaver::onPowerSave")

    return false;

}

/*!

    @copydoc Screensaver::onClose()

 */

bool SnsrBigClockScreensaver::onClose()

{

    SCREENSAVER_TEST_FUNC_ENTRY("SnsrBigClockScreensaver::onClose")

    qDebug() << "SnsrBigClockScreensaver::onClose()";

    bool ret(false);

    if (onBackground()) {

        delete mCurrentContainer;

        mCurrentContainer = 0;

        ret = true;

    }

    SCREENSAVER_TEST_FUNC_EXIT("SnsrBigClockScreensaver::onClose")

    return ret;

}

/*!

    @copydoc Screensaver::onHandleActiveIndicators

 */

void SnsrBigClockScreensaver::onHandleActiveIndicators(

        const QList<HbIndicatorInterface*> &activeIndicators)

{

    mIndicatorModel->handleActiveIndicators(activeIndicators);

}

/*!

    @copydoc Screensaver::onHandleActivatedIndicator

 */

void SnsrBigClockScreensaver::onHandleActivatedIndicator(

        HbIndicatorInterface *activatedIndicator)

{

    mIndicatorModel->handleActivatedIndicator(activatedIndicator);

}

/*!

    @copydoc Screensaver::onHandleDeactivatedIndicator

 */

void SnsrBigClockScreensaver::onHandleDeactivatedIndicator(

        HbIndicatorInterface *deactivatedIndicator)

{

    mIndicatorModel->handleDeactivatedIndicator(deactivatedIndicator);

}

/*!

    @copydoc Screensaver::currentPowerMode

 */

Screensaver::ScreenPowerMode SnsrBigClockScreensaver::currentPowerMode()

{

    Screensaver::ScreenPowerMode mode( Screensaver::ScreenModeFullPower );

    if ( mCurrentContainer ) {

        mode = mCurrentContainer->displayPowerMode();

    }

    else {

        qWarning() << "No current container when current power mode queried.";

    }

    return mode;

}

/*!

    @copydoc Screensaver::getActiveScreenRows

 */

void SnsrBigClockScreensaver::getActiveScreenRows(int *firstActiveRow, int *lastActiveRow)

{

    if ( mCurrentContainer ) {

        mCurrentContainer->getActiveScreenRows( firstActiveRow, lastActiveRow );

    }

    else {

        qWarning() << "No current container when active rows queried.";

    }

}

/*!

    @copydoc Screensaver::updateLayout

 */

void SnsrBigClockScreensaver::updateLayout()

{

    if ( mCurrentContainer ) {

        if ( mCurrentContainer->isOrientationLocked() ) {

            // TODO: There is currently no way for device dialog to lock the display orientation.

            // Orbit team has a backlog item about "global orientation lock" which could be

            // used here when it is available.

        }

        else {

            // TODO: There is currently no way for device dialog to lock the display orientation.

            // Orbit team has a backlog item about "global orientation lock" which could be

            // used here when it is available.

        }

        mCurrentContainer->changeLayout( mMainWindow->orientation() );

    }

    else {

        qWarning() << "No current container when updateLayout called.";

    }

}

/*!

    Update clock time when timer is triggered

 */

void SnsrBigClockScreensaver::updateTime()

{

    if ( mCurrentContainer ) {

        mCurrentContainer->update();

        // Move the active area of display device if current container uses the power save mode.

        if ( mCurrentContainer->displayPowerMode() == Screensaver::ScreenModeLowPower ) {

            emit activeAreaMoved();

        }

        // Ensure correct update interval is used. First timed update may be done

        // with timeout differing from the normal update rate.

        int updateInterval = mCurrentContainer->updateIntervalInMilliseconds();

        if ( updateInterval > 0 ) {

            mTimer.setInterval( updateInterval );

        }

    }

}

/*!

    Determines the curent clock format settings.

    \retval ClockFormat.

 */

SnsrBigClockScreensaver::ClockFormat SnsrBigClockScreensaver::clockFormat()

{

#ifdef Q_OS_SYMBIAN

    XQSettingsManager::Error error;

    XQCentralRepositorySettingsKey settingsKey(

        KCRUidClockApp, KClockType ); 

    XQSettingsManager setManager;

    int useDigital = setManager.readItemValue(settingsKey, XQSettingsManager::TypeInt).toInt();

    error = setManager.error();

    if (error != XQSettingsManager::NoError) {

        qDebug("Error reading clock format from XQSettingsManager.. error = %d", error);

    }

    return ( useDigital ? ClockFormatDigital : ClockFormatAnalog );

#else

    // windows build - change the format every 30 seconds for testing purposes

    if (QTime::currentTime().second() < 30) {

        return ClockFormatAnalog;

    } else {

        return ClockFormatDigital;

    }

#endif // Q_OS_SYMBIAN

}

void SnsrBigClockScreensaver::removeCurrentContainer()

{

    if ( mCurrentContainer ) {

        if (mTimer.timerId()!= -1) {

            mTimer.stop();

        }

        emit viewChanged(0);

        delete mCurrentContainer;

        mCurrentContainer = 0;

    }

}

void SnsrBigClockScreensaver::setCurrentContainer( SnsrBigClockContainer* newContainer )

{

    mCurrentContainer = newContainer;

    mCurrentContainer->setParent(this);

    connect( mCurrentContainer, SIGNAL(unlockRequested()), SIGNAL(unlockRequested()) );

    mCurrentContainer->setIndicatorModel(*mIndicatorModel);

    int updateInterval = mCurrentContainer->updateIntervalInMilliseconds(); 

    // In case the container needs an update seldomly (at maximum once per minute),

    // align these updates with the even minutes by doing the first update on the

    // next even minute.

    const int minute = 60*1000;

    if ( updateInterval >= minute ) {

        updateInterval = minute - QTime::currentTime().second()*1000;

    }

    // container can use negative updateInteval value to indicate that no recurring

    // updates are needed

    if ( updateInterval > 0 ) {

        mTimer.start(updateInterval);

    }

    emit viewChanged(mCurrentContainer);

}