diff -r 2922f70fca82 -r 67457b2ffb33 camerauis/cameraxui/cxui/src/cxuiapplicationstate.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/camerauis/cameraxui/cxui/src/cxuiapplicationstate.cpp Thu Jul 15 01:52:14 2010 +0300 @@ -0,0 +1,272 @@ +/* +* 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 + +#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