/*

* 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:

*

*/

#include <QMetaEnum>

#include "cxutils.h"

#include "cxuieventlog.h"

#include "cxuierrormanager.h"

#include "cxuiapplicationstate.h"

namespace

{

    static const char *EVENT_APPLICATION_STATE = "application state";

}

/*!

* Constructor.

*/

CxuiApplicationState::CxuiApplicationState(CxuiApplication &application,

                                           CxeSettings &settings,

                                           CxuiCaptureKeyHandler &keyHandler,

                                           CxuiDocumentLoader *documentLoader)

    : mState(Background), mApplicationMonitor(NULL), mErrorManager(NULL), mEventLog(NULL)

{

    mApplicationMonitor = new CxuiApplicationFrameworkMonitor(application, settings);

    mErrorManager = new CxuiErrorManager(documentLoader);

    // Foreground state change signals

    connect(mApplicationMonitor, SIGNAL(foregroundStateChanged(CxuiApplicationFrameworkMonitor::ForegroundState)),

            this, SLOT(handleForegroundStateChanged(CxuiApplicationFrameworkMonitor::ForegroundState)));

    // Battery empty signal

    connect(mApplicationMonitor, SIGNAL(batteryEmpty()), this, SLOT(handleBatteryEmpty()));

    // USB mass memory mode signal

    connect(mApplicationMonitor, SIGNAL(usbMassMemoryModeToggled(bool)),

            this, SLOT(handleUsbMassMemoryModeChanged(bool)));

    // Severe error signals

    connect(mErrorManager, SIGNAL(errorPopupShown()), this, SLOT(handleSevereError()));

    connect(mErrorManager, SIGNAL(errorPopupClosed()), this, SLOT(handleErrorCleared()));

#ifdef CX_DEBUG

    mEventLog = new CxuiEventLog("CxuiApplicationState");

#endif

}

/*!

* Destructor.

*/

CxuiApplicationState::~CxuiApplicationState()

{

    delete mErrorManager;

    delete mApplicationMonitor;

    delete mEventLog;

}

/*!

* Get current application state.

*/

CxuiApplicationState::State CxuiApplicationState::currentState() const

{

    return mState;

}

/*!

* Start monitoring the application state.

* Initial state is checked and signal emitted about state change *unless* state is Background.

*/

void CxuiApplicationState::startMonitoring()

{

    CX_DEBUG_ENTER_FUNCTION();

    // Foreground handling checks for errors if needed.

    handleForegroundStateChanged(mApplicationMonitor->foregroundState());

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Handle error from UI or engine.

* Error will be checked and if it is severe, application state will become Error and error note will be shown.

* If error is not severe, a warning note will be shown.

* @param error The error id.

*/

void CxuiApplicationState::handleApplicationError(CxeError::Id error)

{

    CX_DEBUG_ENTER_FUNCTION();

    if (error != CxeError::None) {

        mErrorManager->check(error);

        // If error manager sees this error as severe one, it will signal that back.

        // We will handle updating state in handleSevereError().

        // If only warning note (or nothing) is needed, application state is not changed.

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Handle change in application foreground status.

* @param state New foreground status.

*/

void CxuiApplicationState::handleForegroundStateChanged(CxuiApplicationFrameworkMonitor::ForegroundState state)

{

    CX_DEBUG_ENTER_FUNCTION();

    if (state == CxuiApplicationFrameworkMonitor::ForegroundFullyLost) {

        CX_DEBUG(("CxuiApplicationState - application is in background"));

        // Background overwrites even any error.  We clear any active errors.

        // When returning to background, error situation will be re-checked.

        setState(Background);

        mErrorManager->clear();

    } else {

        CX_DEBUG(("CxuiApplicationState - application is in partial / full foreground"));

        // Check that we were in background. Switching between partial and full background

        // needs no actions.

        if (currentState() == Background) {

           CX_DEBUG(("CxuiApplicationState - application was in background before, moving to foreground"));

            // Check that there's no active errors that have been ignored in background.

            checkErrors();

            if (currentState() != Error) {

                setState(Normal);

            }

        }

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Handle USB mass memory mode (USB MMM) activating or deactivating.

* If USB MMM activates, we enter error state and display error note.

* When USB MMM deactivates, we hide the note and move to standby mode.

* @param active Is the USB mass memory mode active.

*/

void CxuiApplicationState::handleUsbMassMemoryModeChanged(bool active)

{

    CX_DEBUG_ENTER_FUNCTION();

    if (active) {

        // USB error is not handled if:

        // (a) other severe error already active

        // (b) application is in background

        if (currentState() == Normal || currentState() == Standby) {

            // Emulate memory not accessible error.

            handleApplicationError(CxeError::MemoryNotAccessible);

        }

    } else {

        // If we had USB error, clear it now.

        if (currentState() == Error) {

            setState(Standby);

            // Clear memory not accessible error.

            mErrorManager->clear();

        }

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Handle battery emptying. We need to stop all activity and exit the application.

*/

void CxuiApplicationState::handleBatteryEmpty()

{

    CX_DEBUG_ENTER_FUNCTION();

    setState(Background);

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Handle a severe error after Error Manager has analyzed it.

*/

void CxuiApplicationState::handleSevereError()

{

    CX_DEBUG_ENTER_FUNCTION();

    // In background we do not change the state from Background to anything else.

    if (currentState() != Background) {

        setState(Error);

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Severe error has been cleared.

* Check if we should return to normal or background state.

*/

void CxuiApplicationState::handleErrorCleared()

{

    CX_DEBUG_ENTER_FUNCTION();

    // No state change if we are not currently in Error state.

    if (currentState() == Error) {

        setState(Normal);

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Slot for requesting Standby state to be entered.

* Request is accepted only if current state is Normal. Otherwise call has no effect.

*/

void CxuiApplicationState::enterStandby()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (currentState() == Normal) {

        setState(Standby);

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Slot for requesting state change from Standby to Normal state.

* Request is accepted only if current state is Standby. Otherwise call has no effect.

*/

void CxuiApplicationState::exitStandby()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (currentState() == Standby) {

        setState(Normal);

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Set new state.

* If state is actually changing, stateChanged() signal is emitted.

*/

void CxuiApplicationState::setState(State newState)

{

    if (mState != newState) {

#ifdef CX_DEBUG

        if (mEventLog) {

            mEventLog->append(EVENT_APPLICATION_STATE,

                              CxuiApplicationState::staticMetaObject.enumerator(

                                  CxuiApplicationState::staticMetaObject.

                                        indexOfEnumerator("State")).valueToKey(newState));

            mEventLog->print();

        }

#endif // CX_DEBUG

        State oldState = mState;

        mState = newState;

        emit stateChanged(newState, oldState);

    }

}

/*!

* Check if we have known errors active at the moment.

* State is set to CxuiApplicationState::Error, if error is found.

*/

void CxuiApplicationState::checkErrors()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (mApplicationMonitor->isUsbMassMemoryModeActive()) {

        // Force Error state even if Background is still the current state.

        // We use this method to check errors also when returning from background.

        // Normally in Background state we do not enter Error state.

        setState(Error);

        handleApplicationError(CxeError::MemoryNotAccessible);

    }

    CX_DEBUG_EXIT_FUNCTION();

}

// end of file