diff -r 8b2d6d0384b0 -r d9aefe59d544 camerauis/cameraxui/cxui/src/cxuiviewmanager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/camerauis/cameraxui/cxui/src/cxuiviewmanager.cpp Fri Apr 16 14:51:30 2010 +0300 @@ -0,0 +1,809 @@ +/* +* Copyright (c) 2009 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 +#include +#include +#include // keyguard +#include // battery +#include + + +#include "cxuiviewmanager.h" +#include "cxuivideoprecaptureview.h" +#include "cxuivideoprecaptureview2.h" +#include "cxuistillprecaptureview.h" +#include "cxuistillprecaptureview2.h" +#include "cxuipostcaptureview.h" +#include "cxuicapturekeyhandler.h" +#include "cxeengine.h" +#include "cxecameradevicecontrol.h" +#include "cxefeaturemanager.h" // mEngine->featureManager() +#include "cxeviewfindercontrol.h" +#include "cxenamespace.h" +#include "cxuienums.h" +#include "cxutils.h" +#include "xqsettingsmanager.h" // Settings Manager API +#include "cxuidocumentloader.h" +#include "cxuistandby.h" +#include "cxuierrormanager.h" +#include "OstTraceDefinitions.h" +#ifdef OST_TRACE_COMPILER_IN_USE +#include "cxuiviewmanagerTraces.h" +#endif +#include "cxuiserviceprovider.h" + + + +using namespace Cxe; +using namespace CxUiLayout; + + +// --------------------------------------------------------------------------- +// CxuiViewManager::CxuiViewManager +// +// --------------------------------------------------------------------------- +// +CxuiViewManager::CxuiViewManager(HbMainWindow &mainWindow, CxeEngine &engine, CxuiCaptureKeyHandler &keyHandler) : + mMainWindow(mainWindow), + mStillPrecaptureView(NULL), + mVideoPrecaptureView(NULL), + mPostcaptureView(NULL), + mStillPrecaptureView2(NULL), + mVideoPrecaptureView2(NULL), + mEngine(engine), + mKeyHandler(keyHandler), + mSettingsManager(NULL), + mFocused(true), + mCameraDocumentLoader(NULL) +{ + CX_DEBUG_ENTER_FUNCTION(); + + mMainWindow.installEventFilter(this); // in order to filter capture and AF keys + + OstTrace0( camerax_performance, CXUIVIEWMANAGER_CXUIVIEWMANAGER, "msg: e_CX_VIEWMANAGER_CREATE_DOCLOADER 1" ); + mCameraDocumentLoader = new CxuiDocumentLoader; + OstTrace0( camerax_performance, DUP1_CXUIVIEWMANAGER_CXUIVIEWMANAGER, "msg: e_CX_VIEWMANAGER_CREATE_DOCLOADER 0" ); + + // standby functionality and necessary signal connections + mStandbyHandler = new CxuiStandby(keyHandler, mCameraDocumentLoader, &engine); + + connect(mStandbyHandler, SIGNAL(aboutToEnterStandby()),this, SLOT(aboutToLooseFocus())); + connect(mStandbyHandler, SIGNAL(aboutToExitStandby()),this, SLOT(aboutToGainFocus())); + + // error manager, handling errors and notifying users based on their severity + mErrorManager = new CxuiErrorManager(keyHandler, mCameraDocumentLoader); + + // connecting necessary signals from error manager to release and init camera. + connect(mErrorManager, SIGNAL(aboutToRecoverError()), this, SLOT(aboutToLooseFocus())); + connect(mErrorManager, SIGNAL(errorRecovered()), this, SLOT(aboutToGainFocus())); + + if (!CxuiServiceProvider::isCameraEmbedded()) { + // for embedded mode: don't create view yet, create + // when engine inits to correct mode +#ifdef FORCE_SECONDARY_CAMERA + // 2nd camera hack: always use 1st camera view + if (mEngine.mode() == Cxe::VideoMode) { + createVideoPrecaptureView(); + + mMainWindow.blockSignals(true); + mMainWindow.setCurrentView(mVideoPrecaptureView, false); + mMainWindow.blockSignals(false); + } else { + createStillPrecaptureView(); + + mMainWindow.blockSignals(true); + mMainWindow.setCurrentView(mStillPrecaptureView, false); + mMainWindow.blockSignals(false); + } + +#else + if (mEngine.cameraDeviceControl().cameraIndex() == Cxe::PrimaryCameraIndex) { + if (mEngine.mode() == Cxe::VideoMode) { + createVideoPrecaptureView(); + mMainWindow.blockSignals(true); + mMainWindow.setCurrentView(mVideoPrecaptureView, false); + mMainWindow.blockSignals(false); + } else { + createStillPrecaptureView(); + mMainWindow.blockSignals(true); + mMainWindow.setCurrentView(mStillPrecaptureView, false); + mMainWindow.blockSignals(false); + } + } else { + if (mEngine.mode() == Cxe::VideoMode) { + createVideoPrecaptureView2(); + mMainWindow.blockSignals(true); + mMainWindow.setCurrentView(mVideoPrecaptureView2, false); + mMainWindow.blockSignals(false); + } else { + createStillPrecaptureView2(); + mMainWindow.blockSignals(true); + mMainWindow.setCurrentView(mStillPrecaptureView2, false); + mMainWindow.blockSignals(false); + } + } +#endif + connectPreCaptureSignals(); + } + + startEventMonitors(); + + //connecting initmode signals + connect(&mEngine.cameraDeviceControl(), SIGNAL(initModeComplete(CxeError::Id)), + this, SLOT(createPostcaptureView())); + connect(&mEngine.cameraDeviceControl(), SIGNAL(initModeComplete(CxeError::Id)), + mErrorManager, SLOT(analyze(CxeError::Id))); + + if (CxuiServiceProvider::isCameraEmbedded()) { + // connect signals to set up the view after image/video prepare + connect(&mEngine.stillCaptureControl(), SIGNAL(imagePrepareComplete(CxeError::Id)), + this, SLOT(changeToPrecaptureView())); + connect(&mEngine.videoCaptureControl(), SIGNAL(videoPrepareComplete(CxeError::Id)), + this, SLOT(changeToPrecaptureView())); + + // start standby timer now because view will not be ready when viewfinder is started + mStandbyHandler->startTimer(); + } + + CX_DEBUG_EXIT_FUNCTION(); +} + +// --------------------------------------------------------------------------- +// CxuiViewManager::~CxuiViewManager +// +// --------------------------------------------------------------------------- +// +CxuiViewManager::~CxuiViewManager() +{ + CX_DEBUG_ENTER_FUNCTION(); + + delete mCameraDocumentLoader; + delete mSettingsManager; + + CX_DEBUG_EXIT_FUNCTION(); +} + + +// --------------------------------------------------------------------------- +// CxuiViewManager::prepareWindow +// +// --------------------------------------------------------------------------- +// +void CxuiViewManager::prepareWindow() +{ + getPrecaptureView(mEngine.mode(), mEngine.cameraDeviceControl().cameraIndex())->prepareWindow(); +} + + +// --------------------------------------------------------------------------- +// CxuiViewManager::createStillPrecaptureView +// +// --------------------------------------------------------------------------- +// +void CxuiViewManager::createStillPrecaptureView() +{ + CX_DEBUG_ENTER_FUNCTION(); + OstTrace0( camerax_performance, CXUIVIEWMANAGER_CREATESTILLPRECAPTUREVIEW, "msg: e_CX_CREATE_STILLPRECAPTUREVIEW 1" ); + bool ok = false; + CX_DEBUG_ASSERT(mCameraDocumentLoader); + + OstTrace0( camerax_performance, DUP2_CXUIVIEWMANAGER_ADDPRECAPTUREVIEWS, "msg: e_CX_DOCLOADER_LOAD 1" ); + + // Use document loader to create widgets and layouts + // (non-sectioned parts are parsed and loaded) + mCameraDocumentLoader->load(STILL_1ST_XML, &ok); + Q_ASSERT_X(ok, "createStillPrecaptureView", "error in xml file parsing"); + + QGraphicsWidget *widget = NULL; + + OstTrace0( camerax_performance, DUP2_CXUIVIEWMANAGER_CREATESTILLPRECAPTUREVIEW, "msg: e_CX_DOCLOADER_LOAD 0" ); + + + OstTrace0( camerax_performance, DUP4_CXUIVIEWMANAGER_ADDPRECAPTUREVIEWS, "msg: e_CX_DOCLOADER_FINDWIDGET 1" ); + // ask for the still precapture view widget pointer + widget = mCameraDocumentLoader->findWidget(STILL_PRE_CAPTURE_VIEW); + mStillPrecaptureView = qobject_cast (widget); + CX_DEBUG_ASSERT(mStillPrecaptureView); + OstTrace0( camerax_performance, DUP5_CXUIVIEWMANAGER_ADDPRECAPTUREVIEWS, "msg: e_CX_DOCLOADER_FINDWIDGET 0" ); + + // call for needed consturction methods + mStillPrecaptureView->construct(&mMainWindow, &mEngine, mCameraDocumentLoader, &mKeyHandler); + // .. and add to main window (which also takes ownership) + mMainWindow.addView(widget); + + OstTrace0( camerax_performance, DUP1_CXUIVIEWMANAGER_CREATESTILLPRECAPTUREVIEW, "msg: e_CX_CREATE_STILLPRECAPTUREVIEW 0" ); + + CX_DEBUG_EXIT_FUNCTION(); +} + +// --------------------------------------------------------------------------- +// CxuiViewManager::createStillPrecaptureView2 +// +// --------------------------------------------------------------------------- +// +void CxuiViewManager::createStillPrecaptureView2() +{ + CX_DEBUG_ENTER_FUNCTION(); + + bool ok = false; + CX_DEBUG_ASSERT(mCameraDocumentLoader); + + // Use document loader to create widgets and layouts + // (non-sectioned parts are parsed and loaded) + mCameraDocumentLoader->load(STILL_2ND_XML, &ok); + Q_ASSERT_X(ok, "createStillPrecaptureView2", "error in xml file parsing"); + + QGraphicsWidget *widget = NULL; + + // ask for the still precapture view widget pointer + widget = mCameraDocumentLoader->findWidget(STILL_PRE_CAPTURE_VIEW2); + mStillPrecaptureView2 = qobject_cast (widget); + CX_DEBUG_ASSERT(mStillPrecaptureView2); + + // call for needed consturction methods + mStillPrecaptureView2->construct(&mMainWindow, &mEngine, mCameraDocumentLoader, &mKeyHandler); + // .. and add to main window (which also takes ownership) + mMainWindow.addView(widget); + + CX_DEBUG_EXIT_FUNCTION(); +} + +// --------------------------------------------------------------------------- +// CxuiViewManager::createVideoPrecaptureView +// +// --------------------------------------------------------------------------- +// +void CxuiViewManager::createVideoPrecaptureView() +{ + CX_DEBUG_ENTER_FUNCTION(); + OstTrace0( camerax_performance, CXUIVIEWMANAGER_CREATEVIDEOPRECAPTUREVIEW, "msg: e_CX_CREATE_VIDEOPRECAPTUREVIEW 1" ); + + CX_DEBUG_ASSERT(mCameraDocumentLoader); + + bool ok = false; + // load and create the default widgets in video xml + mCameraDocumentLoader->load(VIDEO_1ST_XML, &ok); + CX_DEBUG_ASSERT(ok); + + // get pointer to videoprecaptureview and do some initialisation + QGraphicsWidget *widget = NULL; + widget = mCameraDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_VIEW); + mVideoPrecaptureView = qobject_cast (widget); + CX_DEBUG_ASSERT(mVideoPrecaptureView); + mVideoPrecaptureView->construct(&mMainWindow, &mEngine, mCameraDocumentLoader, &mKeyHandler); + + // add view to main window + mMainWindow.addView(mVideoPrecaptureView); + OstTrace0( camerax_performance, DUP1_CXUIVIEWMANAGER_CREATEVIDEOPRECAPTUREVIEW, "msg: e_CX_CREATE_VIDEOPRECAPTUREVIEW 0" ); + + CX_DEBUG_EXIT_FUNCTION(); +} + +// --------------------------------------------------------------------------- +// CxuiViewManager::createVideoPrecaptureView2 +// +// --------------------------------------------------------------------------- +// +void CxuiViewManager::createVideoPrecaptureView2() +{ + CX_DEBUG_ENTER_FUNCTION(); + CX_DEBUG_ASSERT(mCameraDocumentLoader); + + bool ok = false; + // load and create the default widgets in video xml + mCameraDocumentLoader->load(VIDEO_2ND_XML, &ok); + CX_DEBUG_ASSERT(ok); + + // get pointer to videoprecaptureview and do some initialisation + QGraphicsWidget *widget = NULL; + widget = mCameraDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_VIEW2); + mVideoPrecaptureView2 = qobject_cast (widget); + CX_DEBUG_ASSERT(mVideoPrecaptureView2); + mVideoPrecaptureView2->construct(&mMainWindow, &mEngine, mCameraDocumentLoader); + + // add view to main window + mMainWindow.addView(mVideoPrecaptureView2); + + CX_DEBUG_EXIT_FUNCTION(); +} + +// --------------------------------------------------------------------------- +// CxuiViewManager::createStillPostcaptureView +// +// --------------------------------------------------------------------------- +// +void CxuiViewManager::createPostcaptureView() +{ + CX_DEBUG_ENTER_FUNCTION(); + CX_DEBUG_ASSERT(mCameraDocumentLoader); + OstTrace0( camerax_performance, CXUIVIEWMANAGER_CREATESTILLPOSTCAPTUREVIEW, "msg: e_CX_CREATE_STILLPOSTCAPTUREVIEW 1" ); + + if (!mPostcaptureView) { + bool ok = false; + mCameraDocumentLoader->load(POSTCAPTURE_XML, &ok); + CX_DEBUG_ASSERT(ok); + + // get pointer to videoprecaptureview and do some initialisation + QGraphicsWidget *widget = NULL; + widget = mCameraDocumentLoader->findWidget(POSTCAPTURE_VIEW); + mPostcaptureView = qobject_cast (widget); + CX_DEBUG_ASSERT(mPostcaptureView); + mPostcaptureView->construct(&mMainWindow, &mEngine, mCameraDocumentLoader); + + mMainWindow.addView(mPostcaptureView); + connect(mPostcaptureView, SIGNAL(changeToPrecaptureView()), this, SLOT(changeToPrecaptureView())); + + } + + OstTrace0( camerax_performance, DUP1_CXUIVIEWMANAGER_CREATESTILLPOSTCAPTUREVIEW, "msg: e_CX_CREATE_STILLPOSTCAPTUREVIEW 0" ); + CX_DEBUG_EXIT_FUNCTION(); +} + +// --------------------------------------------------------------------------- +// CxuiViewManager::getPrecaptureView +// +// --------------------------------------------------------------------------- +// +CxuiPrecaptureView* +CxuiViewManager::getPrecaptureView(Cxe::CameraMode mode, Cxe::CameraIndex camera) +{ + CX_DEBUG_ENTER_FUNCTION(); + CX_DEBUG(("CxuiViewManager::getPrecaptureView() mode=%d, camera index=%d", mode, camera)); + +#ifdef FORCE_SECONDARY_CAMERA + // 2nd camera forced: always use 1st camera view + CX_DEBUG(("CxuiViewManager::getPrecaptureView() forcing primary camera view")); + camera = Cxe::PrimaryCameraIndex; +#endif // FORCE_SECONDARY_CAMERA + + if (mode == ImageMode) { + + CX_DEBUG(("CxuiViewManager::getPrecaptureView() image mode")); + if (camera == Cxe::PrimaryCameraIndex) { + CX_DEBUG(("CxuiViewManager::getPrecaptureView() primary camera")); + if(!mStillPrecaptureView) { + createStillPrecaptureView(); + } + return mStillPrecaptureView; + } else { + CX_DEBUG(("CxuiViewManager::getPrecaptureView() secondary camera")); + if(!mStillPrecaptureView2) { + createStillPrecaptureView2(); + } + return mStillPrecaptureView2; + } + } else { + + CX_DEBUG(("CxuiViewManager::getPrecaptureView() video mode")); + if (camera == Cxe::PrimaryCameraIndex) { + CX_DEBUG(("CxuiViewManager::getPrecaptureView() primary camera")); + if(!mVideoPrecaptureView) { + createVideoPrecaptureView(); + } + return mVideoPrecaptureView; + } else { + CX_DEBUG(("CxuiViewManager::getPrecaptureView() secondary camera")); + if(!mVideoPrecaptureView2) { + createVideoPrecaptureView2(); + } + return mVideoPrecaptureView2; + } + } +} + +CxuiDocumentLoader* CxuiViewManager::documentLoader() +{ + return mCameraDocumentLoader; +} + +// --------------------------------------------------------------------------- +// CxuiViewManager::changeToPostcaptureView +// +// --------------------------------------------------------------------------- +// +void CxuiViewManager::changeToPostcaptureView() +{ + CX_DEBUG_ENTER_FUNCTION(); + + if (!mPostcaptureView) { + createPostcaptureView(); + } + + mMainWindow.blockSignals(true); + mMainWindow.setCurrentView(mPostcaptureView, false); + mMainWindow.blockSignals(false); + + // connecting all necessary signals for postcapture view + connectPostCaptureSignals(); + + //@todo: refactor postcapture view to new focus and state handling as agreed with package owner + connect(this, SIGNAL(focusGained()), mPostcaptureView, SLOT(startTimers()), Qt::UniqueConnection); + + CX_DEBUG_EXIT_FUNCTION(); +} + +// --------------------------------------------------------------------------- +// CxuiViewManager::changeToPrecaptureView +// +// --------------------------------------------------------------------------- +// +void CxuiViewManager::changeToPrecaptureView() +{ + CX_DEBUG_ENTER_FUNCTION(); + + if (CxuiServiceProvider::isCameraEmbedded()) { + // disconnect signals, we only want to call this once after the initial prepare + disconnect(&mEngine.stillCaptureControl(), SIGNAL(imagePrepareComplete(CxeError::Id)), + this, SLOT(changeToPrecaptureView())); + disconnect(&mEngine.videoCaptureControl(), SIGNAL(videoPrepareComplete(CxeError::Id)), + this, SLOT(changeToPrecaptureView())); + } + + HbView *view = getPrecaptureView(mEngine.mode(), + mEngine.cameraDeviceControl().cameraIndex()); + + mMainWindow.blockSignals(true); + mMainWindow.setCurrentView(view, false); + mMainWindow.blockSignals(false); + + // connecting necessary pre-capture view signals + connectPreCaptureSignals(); + + CX_DEBUG_EXIT_FUNCTION(); +} + +// --------------------------------------------------------------------------- +// CxuiViewManager::switchCamera +// +// --------------------------------------------------------------------------- +// +void CxuiViewManager::switchCamera() +{ + CX_DEBUG_ENTER_FUNCTION(); + + Cxe::CameraIndex nextCamera; + Qt::Orientation nextViewOrientation; + + if (mEngine.cameraDeviceControl().cameraIndex() == Cxe::PrimaryCameraIndex) { + nextCamera = Cxe::SecondaryCameraIndex; + nextViewOrientation = Qt::Vertical; + } else { + nextCamera = Cxe::PrimaryCameraIndex; + nextViewOrientation = Qt::Horizontal; + } + + CxuiPrecaptureView* view = getPrecaptureView(mEngine.mode(), nextCamera); + + mMainWindow.blockSignals(true); + mMainWindow.setCurrentView(view, false); + mMainWindow.blockSignals(false); + view->updateOrientation(nextViewOrientation); + view->prepareWindow(); + + connectPreCaptureSignals(); + + mEngine.cameraDeviceControl().switchCamera(nextCamera); + + CX_DEBUG_EXIT_FUNCTION(); +} + +// --------------------------------------------------------------------------- +// CxuiViewManager::eventFilter +// +// --------------------------------------------------------------------------- +// +bool CxuiViewManager::eventFilter(QObject *object, QEvent *event) +{ + bool eventWasConsumed = false; + + switch (event->type()) + { + case QEvent::KeyPress: + case QEvent::KeyRelease: + eventWasConsumed = mKeyHandler.handleKeyEvent(event); + break; + case QEvent::WindowActivate: + if (object == &mMainWindow) { + CX_DEBUG(("CxuiViewManager - window activated")); + // If we gained focus and keyguard is off. + if (!mFocused) { + mFocused = true; + if (mKeyLockState == EKeyguardNotActive) { + aboutToGainFocus(); + } + } + } + break; + case QEvent::WindowDeactivate: + if (object == &mMainWindow) + { + CX_DEBUG(("CxuiViewManager - window de-activated")); + if (mFocused) { + mFocused = false; + aboutToLooseFocus(); + } + } + break; + } + + // No need to call base class implementation, because we derive from QObject directly. + // QObject::eventFilter() implementation always returns false. + return eventWasConsumed; +} + +// --------------------------------------------------------------------------- +// CxuiViewManager::startEventMonitors +// +// --------------------------------------------------------------------------- +// +void CxuiViewManager::startEventMonitors() +{ + CX_DEBUG_ENTER_FUNCTION(); + bool ok = false; + + mSettingsManager = new XQSettingsManager(this); + ok = connect(mSettingsManager, SIGNAL(valueChanged(XQSettingsKey, QVariant)), + this, SLOT(eventMonitor(XQSettingsKey, QVariant))); + CX_DEBUG_ASSERT(ok); + + // Keyguard status (locked / unlocked) + XQSettingsKey keyguard(XQSettingsKey::TargetPublishAndSubscribe, + KPSUidAvkonDomain.iUid, + KAknKeyguardStatus); + + QVariant value = mSettingsManager->readItemValue(keyguard); + if (value == QVariant::Int) { + mKeyLockState = value.toInt(); + } + ok = mSettingsManager->startMonitoring(keyguard); + CX_DEBUG_ASSERT(ok); + + // Battery status (ok / low / empty) + XQSettingsKey battery(XQSettingsKey::TargetPublishAndSubscribe, + KPSUidHWRMPowerState.iUid, + KHWRMBatteryStatus); + value = mSettingsManager->readItemValue(battery); + if (value == QVariant::Int) { + mBatteryStatus = value.toInt(); + } + ok = mSettingsManager->startMonitoring(battery); + CX_DEBUG_ASSERT(ok); + + CX_DEBUG_EXIT_FUNCTION(); +} + + + +// --------------------------------------------------------------------------- +// CxuiViewManager::connectCaptureKeySignals +// +// --------------------------------------------------------------------------- +// +void CxuiViewManager::connectCaptureKeySignals() +{ + CX_DEBUG_ENTER_FUNCTION(); + + // Disconnect all existing capture key signals + mKeyHandler.disconnect(); + + QObject *currentView = mMainWindow.currentView(); + + if (currentView) { + // If the view class does not implement the named slot, the connect will fail + // and output some warnings as debug prints. This is by design. + connect(&mKeyHandler, SIGNAL(autofocusKeyPressed()), currentView, SLOT(handleAutofocusKeyPressed())); + connect(&mKeyHandler, SIGNAL(autofocusKeyReleased()), currentView, SLOT(handleAutofocusKeyReleased())); + connect(&mKeyHandler, SIGNAL(captureKeyPressed()), currentView, SLOT(handleCaptureKeyPressed())); + connect(&mKeyHandler, SIGNAL(captureKeyReleased()), currentView, SLOT(handleCaptureKeyReleased())); + } + + CX_DEBUG_EXIT_FUNCTION(); +} + + +// --------------------------------------------------------------------------- +// CxuiViewManager::connectPreCaptureSignals +// +// --------------------------------------------------------------------------- +// +void CxuiViewManager::connectPreCaptureSignals() +{ + CX_DEBUG_ENTER_FUNCTION(); + + disconnectSignals(); + + QObject *currentView = mMainWindow.currentView(); + + if (currentView != mPostcaptureView) { + // connects all capture key signals. + connectCaptureKeySignals(); + + // connecting view manager focus events to pre-capture views + connect(this, SIGNAL(focusGained()), currentView, SLOT(handleFocusGained()), Qt::UniqueConnection); + connect(this, SIGNAL(focusLost()), currentView, SLOT(handleFocusLost()), Qt::UniqueConnection); + connect(this, SIGNAL(batteryEmpty()), currentView, SLOT(handleBatteryEmpty()), Qt::UniqueConnection); + + // in standby mode, we are interested in focus gain events for dismissing standby + connect(this, SIGNAL(focusGained()), mStandbyHandler, SLOT(handleMouseEvent()), Qt::UniqueConnection); + + // connecting key events to standby. + connect(&mKeyHandler, SIGNAL(autofocusKeyPressed()), mStandbyHandler, SLOT(stopTimer()), Qt::UniqueConnection); + connect(&mKeyHandler, SIGNAL(autofocusKeyReleased()), mStandbyHandler, SLOT(startTimer()), Qt::UniqueConnection); + connect(&mKeyHandler, SIGNAL(captureKeyPressed()), mStandbyHandler, SLOT(startTimer()), Qt::UniqueConnection); + connect(&mKeyHandler, SIGNAL(captureKeyReleased()), mStandbyHandler, SLOT(startTimer()), Qt::UniqueConnection); + + // connecting pre-capture view signals to standby. + connect(currentView, SIGNAL(startStandbyTimer()), mStandbyHandler, SLOT(startTimer()), Qt::UniqueConnection); + connect(currentView, SIGNAL(changeToPrecaptureView()), mStandbyHandler, SLOT(startTimer()), Qt::UniqueConnection); + connect(currentView, SIGNAL(stopStandbyTimer()), mStandbyHandler, SLOT(stopTimer()), Qt::UniqueConnection); + connect(currentView, SIGNAL(changeToPostcaptureView()), mStandbyHandler, SLOT(stopTimer()), Qt::UniqueConnection); + + // connecting precapture view signals to viewmanager slots + connect(currentView, SIGNAL(changeToPostcaptureView()), this, SLOT(changeToPostcaptureView()), Qt::UniqueConnection); + connect(currentView, SIGNAL(changeToPrecaptureView()), this, SLOT(changeToPrecaptureView()), Qt::UniqueConnection); + connect(currentView, SIGNAL(switchCamera()), this, SLOT(switchCamera()), Qt::UniqueConnection); + + // connecting error signals from precapture view to errormanager. + connect(currentView, SIGNAL(reportError(CxeError::Id)), mErrorManager, SLOT(analyze(CxeError::Id)), Qt::UniqueConnection); + } + + CX_DEBUG_EXIT_FUNCTION(); +} + + +// --------------------------------------------------------------------------- +// CxuiViewManager::connectPostCaptureSignals +// +// --------------------------------------------------------------------------- +// +void CxuiViewManager::connectPostCaptureSignals() +{ + CX_DEBUG_ENTER_FUNCTION(); + + disconnectSignals(); + QObject *currentView = mMainWindow.currentView(); + if (currentView == mPostcaptureView) { + // connecting view manager focus events to pre-capture views + connect(this, SIGNAL(focusLost()), currentView, SLOT(handleFocusLost()), Qt::UniqueConnection); + connect(currentView, SIGNAL(changeToPrecaptureView()), mStandbyHandler, SLOT(startTimer()), Qt::UniqueConnection); + + // connect necessary capturekey signals + connectCaptureKeySignals(); + } + + CX_DEBUG_EXIT_FUNCTION(); +} + + + +/* +* CxuiViewManager::disconnectPreCaptureSignals +*/ +void CxuiViewManager::disconnectSignals() +{ + CX_DEBUG_ENTER_FUNCTION(); + + // Disconnect all existing capture key signals + mKeyHandler.disconnect(); + + disconnect(SIGNAL(focusGained())); + disconnect(SIGNAL(focusLost())); + disconnect(SIGNAL(batteryEmpty())); + + CX_DEBUG_EXIT_FUNCTION(); +} + + +// --------------------------------------------------------------------------- +// CxuiViewManager::aboutToLooseFocus() +// +// --------------------------------------------------------------------------- +// +void CxuiViewManager::aboutToLooseFocus() +{ + CX_DEBUG_ENTER_FUNCTION(); + + emit focusLost(); + disconnectSignals(); + + CX_DEBUG_EXIT_FUNCTION(); +} + + +// --------------------------------------------------------------------------- +// CxuiViewManager::aboutToGainFocus +// +// --------------------------------------------------------------------------- +// +void CxuiViewManager::aboutToGainFocus() +{ + CX_DEBUG_ENTER_FUNCTION(); + + // we are getting the focus. + if (mMainWindow.currentView() != mPostcaptureView) { + connectPreCaptureSignals(); + } else { + connectPostCaptureSignals(); + } + + emit focusGained(); + + CX_DEBUG_EXIT_FUNCTION(); +} + + +// --------------------------------------------------------------------------- +// CxuiViewManager::eventMonitor +// +// --------------------------------------------------------------------------- +// +void CxuiViewManager::eventMonitor( const XQSettingsKey& key, const QVariant& value ) +{ + CX_DEBUG_ENTER_FUNCTION(); + + if (key.uid() == KPSUidAvkonDomain.iUid && key.key() == KAknKeyguardStatus) { + CX_DEBUG(("new Keyguard value = %d, mKeyLockState = %d", value.toInt(), mKeyLockState)); + if (mSettingsManager->error() == XQSettingsManager::NoError) { + // New key guard state + int newKeyLockState = value.toInt(); + + // Check if the keylock value has actually changed + bool keylockValueChanged = (newKeyLockState != mKeyLockState); + mKeyLockState = newKeyLockState; + + // Ignore unlock events when on background + bool unlockedOnBackground = (!mFocused && newKeyLockState == EKeyguardNotActive); + + if (keylockValueChanged && + !unlockedOnBackground) { + // Key lock value changed and we need to handle it + if (mKeyLockState == EKeyguardNotActive) { + // All other keylock states are handled as a active in S60 code + aboutToGainFocus(); + } else { + mFocused = false; + aboutToLooseFocus(); + } + } + } else { + // Error from settings manager - ignore + CX_DEBUG(("mSettingsManager indicated error %d for key guard status", mSettingsManager->error())); + } + } else if (key.uid() == KPSUidHWRMPowerState.iUid && key.key() == KHWRMBatteryStatus ) { + CX_DEBUG(("new battery status = %d, mBatteryStatus = %d", value.toInt(), mBatteryStatus)); + + if (mSettingsManager->error() == XQSettingsManager::NoError) { + + // If status changed, check if battery is going empty. + const int newState = value.toInt(); + if( newState != mBatteryStatus ) { + mBatteryStatus = newState; + + // Notify that battery is almost empty, + // need to stop any recordings etc. + if( mBatteryStatus == EBatteryStatusEmpty ) { + emit batteryEmpty(); + } + } + } + } + + CX_DEBUG_EXIT_FUNCTION(); +} + +// end of file