camerauis/cameraxui/cxui/src/cxuiviewmanager.cpp
branchRCL_3
changeset 23 61bc0f252b2b
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraxui/cxui/src/cxuiviewmanager.cpp	Tue Aug 31 15:03:46 2010 +0300
@@ -0,0 +1,786 @@
+/*
+* 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:
+*
+*/
+#include <QDebug>
+#include <QTimer>
+#include <hbmainwindow.h>
+#include <QGraphicsSceneEvent>
+#include <hbstyleloader.h>
+#include <hbactivitymanager.h>
+#include <hbaction.h>
+#include <xqserviceutil.h>
+
+#include "cxuiapplication.h"
+#include "cxuiapplicationstate.h"
+#include "cxuiviewmanager.h"
+#include "cxuivideoprecaptureview.h"
+#include "cxuistillprecaptureview.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 "cxuidocumentloader.h"
+#include "cxesettings.h"
+#include "cxememorymonitor.h"
+#include "cxuiserviceprovider.h"
+#include "cxuiscenemodeview.h"
+
+
+#ifdef Q_OS_SYMBIAN
+#include "OstTraceDefinitions.h"
+
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "cxuiviewmanagerTraces.h"
+#endif
+
+#endif //Q_OS_SYMBIAN
+
+
+using namespace Cxe;
+using namespace CxUiLayout;
+
+namespace
+{
+    static const int CXUI_STANDBY_CAMERA_TIMEOUT = 60000; // 60 seconds
+}
+
+
+/*!
+* Constructor.
+*/
+CxuiViewManager::CxuiViewManager(CxuiApplication &application, HbMainWindow &mainWindow, CxeEngine &engine) :
+    mApplication(application),
+    mMainWindow(mainWindow),
+    mEngine(engine),
+    mKeyHandler(NULL),
+    mCameraDocumentLoader(NULL),
+    mApplicationState(NULL),
+    mErrorManager(NULL)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    // create mappings to map view name to correct docml file
+    mDocmlFilesByView.insert(STILL_PRE_CAPTURE_VIEW, STILL_1ST_XML);
+    mDocmlFilesByView.insert(VIDEO_PRE_CAPTURE_VIEW, VIDEO_1ST_XML);
+    mDocmlFilesByView.insert(POSTCAPTURE_VIEW, POSTCAPTURE_XML);
+    mDocmlFilesByView.insert(SCENE_MODE_VIEW, SCENEMODE_SETTING_XML);
+
+    // Key handler
+    mKeyHandler = new CxuiCaptureKeyHandler(mEngine);
+
+    // Document loader
+    OstTrace0(camerax_performance, CXUIVIEWMANAGER_CXUIVIEWMANAGER_1, "msg: e_CX_VIEWMANAGER_CREATE_DOCLOADER 1");
+    mCameraDocumentLoader = new CxuiDocumentLoader(&engine);
+    OstTrace0(camerax_performance, CXUIVIEWMANAGER_CXUIVIEWMANAGER_2, "msg: e_CX_VIEWMANAGER_CREATE_DOCLOADER 0");
+
+    // Application state
+    mApplicationState = new CxuiApplicationState(mApplication, mEngine.settings(), mCameraDocumentLoader);
+    CX_ASSERT_ALWAYS(mApplicationState);
+    bool ok = connect(mApplicationState, SIGNAL(stateChanged(CxuiApplicationState::State, CxuiApplicationState::State)),
+                      this, SLOT(handleApplicationStateChanged(CxuiApplicationState::State, CxuiApplicationState::State)));
+    Q_ASSERT_X(ok, "CxuiViewManager", "Application state change signal connect failed.");
+    connect(this, SIGNAL(standbyExitRequested()), mApplicationState, SLOT(exitStandby()), Qt::QueuedConnection);
+
+    // Standby timer
+    mStandbyTimer.setInterval(CXUI_STANDBY_CAMERA_TIMEOUT);
+    mStandbyTimer.setSingleShot(true);
+    connect(&mStandbyTimer, SIGNAL(timeout()), mApplicationState, SLOT(enterStandby()));
+
+    // Filter capture and AF keys and follow user activity from mouse events.
+    QCoreApplication::instance()->installEventFilter(this);
+
+    // Monitor memory on normal state, not on standby, error or background.
+    connect(this, SIGNAL(normalStateEntered()), &mEngine.memoryMonitor(), SLOT(startMonitoring()));
+    connect(this, SIGNAL(normalStateExited()), &mEngine.memoryMonitor(), SLOT(stopMonitoring()));
+
+    //connecting initmode signals
+    connect(&mEngine.cameraDeviceControl(), SIGNAL(initModeComplete(CxeError::Id)),
+            mApplicationState, SLOT(handleApplicationError(CxeError::Id)));
+
+    connect(&mEngine.stillCaptureControl(), SIGNAL(imageCaptured(CxeError::Id, int)),
+            mApplicationState, SLOT(handleApplicationError(CxeError::Id)));
+
+    // Register stylesheet. It will be automatically destroyed on application
+    // exit.
+    HbStyleLoader::registerFilePath(":/camerax/cxui.css");
+
+    // Create the view we are starting in, or connect signals so it
+    // will be created once we know the mode we are starting to.
+    initStartupView();
+
+    // For UI startup testing, we need to emit applicationReady signal once UI is ready to be used.
+    connect(mMainWindow.currentView(), SIGNAL(viewReady()), &mApplication, SIGNAL(applicationReady()));
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+
+/*!
+* Destructor.
+*/
+CxuiViewManager::~CxuiViewManager()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    QCoreApplication::instance()->removeEventFilter(this);
+
+    if (!CxuiServiceProvider::isCameraEmbedded()) {
+        currentView()->saveActivity();
+    }
+
+    delete mApplicationState;
+    delete mCameraDocumentLoader;
+    delete mKeyHandler;
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+
+
+/*!
+* Handle change in overall state of application.
+* @param newState The new application state.
+*/
+void CxuiViewManager::handleApplicationStateChanged(CxuiApplicationState::State newState,
+                                                    CxuiApplicationState::State oldState)
+{
+    Q_UNUSED(oldState);
+    CX_DEBUG_ENTER_FUNCTION();
+
+    CxuiView *view = currentView();
+    CX_DEBUG(("CxuiViewManager - current view %d", view));
+
+    switch (newState) {
+    case CxuiApplicationState::Normal:
+        // If camera is in embedded mode, we need to start
+        // listening to key events again
+        if (CxuiServiceProvider::isCameraEmbedded()){
+            mKeyHandler->startListeningKeys();
+        } else {
+            // If in standalone mode, we disable raising to
+            // foreground with capture key.
+            disconnect(mKeyHandler, SIGNAL(captureKeyPressed()),
+                       this, SLOT(toForeground()));
+        }
+        connectSignals(view);
+
+        CX_DEBUG(("CxuiViewManager - emitting normalStateEntered"));
+        emit normalStateEntered();
+        break;
+    case CxuiApplicationState::Standby:
+         if (view && !view->isStandbyModeSupported()) {
+            // If we move to Stanby, and current view does not
+            // support standby mode, move to Normal mode right away.
+            CX_DEBUG(("CxuiViewManager - view does not support stanbdy, exiting standby right away.."));
+            mApplicationState->exitStandby();
+        } else {
+            handleExitingNormalState();
+        }
+        break;
+    case CxuiApplicationState::Error:
+    case CxuiApplicationState::Background:
+        handleExitingNormalState();
+
+        if (newState == CxuiApplicationState::Background) {
+            // Moved to background.
+            // If we're in embedded mode, we should stop listening to camera key
+            // events
+            if (CxuiServiceProvider::isCameraEmbedded()){
+                mKeyHandler->stopListeningKeys();
+            } else {
+                // If not in embedded mode, then we bring application back to
+                // foreground by capture key press
+                connect(mKeyHandler, SIGNAL(captureKeyPressed()),
+                        this, SLOT(toForeground()));
+            }
+        }
+        break;
+    }
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Helper method to handle (possible) exiting from normal state.
+* @param oldState The previous state.
+*/
+void CxuiViewManager::handleExitingNormalState()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    // Store view that is active now.
+    CxuiView *view = currentView();
+    CX_DEBUG(("CxuiViewManager - current view %d", view));
+
+    // Emit signal so current view can enter standby.
+    emit normalStateExited();
+    // Disconnect signals so we don't send key event's etc.
+    // Using the view before normalStateExited() signal was emitted,
+    // just in case it caused view switch.
+    disconnectSignals(view);
+    // Make sure standby timer is not running.
+    stopStandbyTimer();
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Slot for starting standby timer.
+*/
+void CxuiViewManager::startStandbyTimer()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    mStandbyTimer.start();
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Slot for stopping standby timer.
+*/
+void CxuiViewManager::stopStandbyTimer()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    mStandbyTimer.stop();
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+ * Helper function to return current view cast to CxuiView.
+ */
+CxuiView* CxuiViewManager::currentView() const
+{
+    CxuiView *view = qobject_cast<CxuiView*> (mMainWindow.currentView());
+    return view;
+}
+
+/*!
+* Select and initialize the view we need to start into.
+*/
+void CxuiViewManager::initStartupView()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    if (mApplication.activateReason() == Hb::ActivationReasonService ||
+        // @todo: There's a bug in orbit and we never get Hb::ActivationReasonService as
+        // activation reason. Use XQServiceUtil to determine if starting service as
+        // a workaround for now
+        XQServiceUtil::isService()) {
+
+        // For embedded mode: don't create view yet, create when engine inits to correct mode.
+        // 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()));
+
+    } else if (mApplication.activateReason() == Hb::ActivationReasonActivity) {
+        // restoring activity, read startup view from stored activity
+
+        // view to start in
+        QString viewName = STILL_PRE_CAPTURE_VIEW;
+
+        bool preCapture = true;
+        QString activityId = mApplication.activateId();
+        if (activityId == CxuiActivityIds::STILL_PRECAPTURE_ACTIVITY) {
+            viewName = STILL_PRE_CAPTURE_VIEW;
+        } else if (activityId == CxuiActivityIds::STILL_POSTCAPTURE_ACTIVITY) {
+            viewName = POSTCAPTURE_VIEW;
+            preCapture = false;
+        } else if (activityId == CxuiActivityIds::VIDEO_PRECAPTURE_ACTIVITY) {
+            viewName = VIDEO_PRE_CAPTURE_VIEW;
+        } else if (activityId == CxuiActivityIds::VIDEO_POSTCAPTURE_ACTIVITY) {
+            viewName = POSTCAPTURE_VIEW;
+            preCapture = false;
+        }
+
+        CxuiView *view = createView(viewName);
+        if (preCapture) {
+            connectPreCaptureSignals(static_cast<CxuiPrecaptureView *>(view));
+        } else {
+            connectPostCaptureSignals();
+        }
+        mMainWindow.setCurrentView(view, false);
+
+        // restore view from activity
+        bool ok = mApplication.activityManager()->waitActivity();
+
+        view->restoreActivity(activityId,
+                              mApplication.activityManager()->activityData(mApplication.activateId()));
+
+        clearAllActivities();
+    } else {
+        // normal start
+        // no activity id, get default view from engine state
+        CxuiView *view = NULL;
+        if (mEngine.mode() == Cxe::VideoMode) {
+            view = createView(VIDEO_PRE_CAPTURE_VIEW);
+        } else {
+            view = createView(STILL_PRE_CAPTURE_VIEW);
+        }
+        connectPreCaptureSignals(static_cast<CxuiPrecaptureView *>(view));
+        mMainWindow.setCurrentView(view, false);
+
+        clearAllActivities();
+    }
+
+    // Check the current application state, signalled to handleApplicationStateChanged.
+    mApplicationState->startMonitoring();
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Create view and add it to main window.
+*/
+CxuiView* CxuiViewManager::createView(const QString &viewName)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    OstTrace0(camerax_performance, CXUIVIEWMANAGER_CREATEVIEW_IN, "msg: e_CX_CREATE_VIEW 1");
+
+    CX_DEBUG(("View name: %s", viewName.toAscii().data()));
+
+    CxuiView* view = mViews[viewName];
+    if (view == NULL) {
+        CX_DEBUG(("View not loaded yet, loading now"));
+        bool ok = false;
+        // Use document loader to create widgets and layouts
+        // (non-sectioned parts are parsed and loaded)
+        QString docmlFile = mDocmlFilesByView[viewName];
+        CX_ASSERT_ALWAYS(mCameraDocumentLoader);
+        CX_ASSERT_ALWAYS(!docmlFile.isNull());
+
+        OstTrace0(camerax_performance, CXUIVIEWMANAGER_CREATEVIEW_2, "msg: e_CX_DOCUMENTLOADER_LOAD 1");
+        mCameraDocumentLoader->load(docmlFile, &ok);
+        OstTrace0(camerax_performance, CXUIVIEWMANAGER_CREATEVIEW_4, "msg: e_CX_DOCUMENTLOADER_LOAD 0");
+        Q_ASSERT_X(ok, "createView", "error in xml file parsing");
+
+        OstTrace0(camerax_performance, CXUIVIEWMANAGER_CREATEVIEW_6, "msg: e_CX_DOCUMENTLOADER_FINDWIDGET 1");
+        QGraphicsWidget *widget = NULL;
+        // ask for the view widget pointer
+        widget = mCameraDocumentLoader->findWidget(viewName);
+        view = qobject_cast<CxuiView *> (widget);
+        CX_ASSERT_ALWAYS(view);
+        OstTrace0(camerax_performance, CXUIVIEWMANAGER_CREATEVIEW_8, "msg: e_CX_DOCUMENTLOADER_FINDWIDGET 1");
+
+        // call for needed consturction methods
+        view->construct(&mMainWindow, &mEngine, mCameraDocumentLoader, mKeyHandler, mApplication.activityManager());
+        // .. and add to main window (which also takes ownership)
+        OstTrace0(camerax_performance, CXUIVIEWMANAGER_CREATEVIEW_10, "msg: e_CX_MAINWINDOW_ADDVIEW 1");
+        mMainWindow.addView(view);
+        mViews.insert(viewName, view);
+        OstTrace0(camerax_performance, CXUIVIEWMANAGER_CREATEVIEW_12, "msg: e_CX_MAINWINDOW_ADDVIEW 0");
+    }
+
+    OstTrace0(camerax_performance, CXUIVIEWMANAGER_CREATEVIEW_OUT, "msg: e_CX_CREATE_VIEW 0");
+
+    CX_DEBUG_EXIT_FUNCTION();
+    return view;
+}
+
+/*!
+* CxuiViewManager::showScenesView
+* A private method for displaying Scene Modes selection view
+*/
+void CxuiViewManager::showScenesView()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    // Disconnect signals from old view.
+    disconnectSignals();
+
+    CxuiSceneModeView *view = qobject_cast<CxuiSceneModeView*>(createView(SCENE_MODE_VIEW));
+    CX_ASSERT_ALWAYS(view);
+    view->loadBackgroundImages();
+
+    stopStandbyTimer();
+    connectSceneModeSignals();
+    mMainWindow.setCurrentView(view, false);
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Get the precapture view appropriate for given camera mode and index.
+* If the view does not exist, it is created.
+* @param mode Which camera mode the view should match.
+* @param index Which camera index the view should match.
+*/
+CxuiPrecaptureView*
+CxuiViewManager::getPrecaptureView(Cxe::CameraMode mode, Cxe::CameraIndex camera)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    CX_DEBUG(("CxuiViewManager::getPrecaptureView - mode=%d, camera index=%d", mode, camera));
+
+    CX_DEBUG_ASSERT(camera == Cxe::PrimaryCameraIndex);
+
+    if (mode == ImageMode) {
+        CX_DEBUG(("CxuiViewManager::getPrecaptureView - image mode"));
+        return qobject_cast<CxuiPrecaptureView*>(createView(STILL_PRE_CAPTURE_VIEW));
+
+    } else {
+        CX_DEBUG(("CxuiViewManager::getPrecaptureView - video mode"));
+        return qobject_cast<CxuiPrecaptureView*>(createView(VIDEO_PRE_CAPTURE_VIEW));
+    }
+}
+
+/*!
+* Move to post-capture view.
+*/
+void CxuiViewManager::changeToPostcaptureView()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    // Disconnect signals from old view.
+    disconnectSignals();
+
+    CxuiView *postCaptureView = createView(POSTCAPTURE_VIEW);
+
+    // Connecting all necessary signals for postcapture view.
+    // Not connected yet if not in normal state. We connect the signals
+    // once we enter normal state again.
+    if (mApplicationState->currentState() == CxuiApplicationState::Normal) {
+        connectPostCaptureSignals();
+    }
+
+    // Connect signals before we set the post-capture view as current view.
+    // We need to have signals connected if post-capture view for example
+    // needs to move back to pre-capture view already in showEvent.
+    mMainWindow.setCurrentView(postCaptureView, false);
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Move to pre-capture view.
+*/
+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()));
+    }
+
+    // If normal mode is not active, don't switch to precapture view and reserve camera now.
+    if (mApplicationState->currentState() != CxuiApplicationState::Normal) {
+        CX_DEBUG(("CxuiViewManager - Change to precapture blocked as not normal mode (error, standby, background)."));
+    } else {
+
+        // Disconnect signals from old view.
+        disconnectSignals();
+
+        CxuiPrecaptureView *view =
+            getPrecaptureView(mEngine.mode(), mEngine.cameraDeviceControl().cameraIndex());
+
+        // Connect necessary pre-capture view signals.
+        connectPreCaptureSignals(view);
+
+        mMainWindow.setCurrentView(view, false);
+
+        // Release resources needed by scene view.
+        HbView *sceneView = mViews.take(SCENE_MODE_VIEW);
+        if (sceneView) {
+            // This will not delete the view.
+            mMainWindow.removeView(sceneView);
+            // We can get to this slot from scene view, so don't delete the object too early.
+            sceneView->deleteLater();
+            sceneView = NULL;
+        }
+
+        // Make sure engine prepares for new image/video if necessary
+        mEngine.initMode(mEngine.mode());
+
+        startStandbyTimer();
+
+    }
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Switch between cameras.
+*/
+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);
+    connectPreCaptureSignals(view);
+    mMainWindow.setCurrentView(view, false);
+    view->updateOrientation(nextViewOrientation);
+
+    mEngine.cameraDeviceControl().switchCamera(nextCamera);
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Event filter function.
+* Used to get mouse and key events for standby and capture key handling.
+* @param object Target object.
+* @param event Event to be checked.
+*/
+bool CxuiViewManager::eventFilter(QObject *object, QEvent *event)
+{
+    Q_UNUSED(object)
+
+    bool eventWasConsumed = false;
+    bool userActivity = false;
+
+    switch (event->type()) {
+    case QEvent::KeyPress:
+    case QEvent::KeyRelease:
+        userActivity = true;
+        eventWasConsumed = mKeyHandler->handleKeyEvent(event);
+        if (eventWasConsumed && mApplicationState->currentState() == CxuiApplicationState::Standby) {
+            // Queued exit from standby.
+            emit standbyExitRequested();
+        }
+        break;
+
+    case QEvent::GraphicsSceneMouseMove:
+    case QEvent::GraphicsSceneMousePress:
+        userActivity = true;
+        break;
+    case QEvent::GraphicsSceneMouseRelease:
+        userActivity = true;
+        if (mApplicationState->currentState() == CxuiApplicationState::Standby) {
+            // Queued exit from standby.
+            // Standby popup in view can receive mouse event before it is dismissed.
+            emit standbyExitRequested();
+        }
+        break;
+    }
+
+    // Restart standby timer if there is user activity.
+    // Only restart the timer if it is running, do not set it running here.
+    if (userActivity && mStandbyTimer.isActive()) {
+        startStandbyTimer();
+    }
+
+    // No need to call base class implementation, because we derive from QObject directly.
+    // QObject::eventFilter() implementation always returns false.
+    return eventWasConsumed;
+}
+
+/*!
+* Connect signals specific to given view.
+*/
+void CxuiViewManager::connectSignals(CxuiView *view)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    OstTrace0(camerax_performance, CXUIVIEWMANAGER_CONNECTSIGNALS_1, "msg: e_CX_VIEWMANAGER_CONNECT_SIGNALS 1");
+
+    if (view) {
+        if (view == mViews[POSTCAPTURE_VIEW]) {
+            connectPostCaptureSignals();
+        } else if (view == mViews[SCENE_MODE_VIEW]) {
+            connectSceneModeSignals();
+        } else {
+            connectPreCaptureSignals(static_cast<CxuiPrecaptureView *>(view));
+        }
+    }
+
+    OstTrace0(camerax_performance, CXUIVIEWMANAGER_CONNECTSIGNALS_2, "msg: e_CX_VIEWMANAGER_CONNECT_SIGNALS 0");
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Disconnect signals.
+* We don't want to send or receive signals with inactive views, so this is done every time changing a view.
+* @param view View object from which signals are disconnected. If NULL is given, current view is used.
+*/
+void CxuiViewManager::disconnectSignals(CxuiView *view)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    OstTrace0(camerax_performance, CXUIVIEWMANAGER_DISCONNECT_1, "msg: e_CX_VIEWMANAGER_DISCONNECT_SIGNALS 1");
+
+    // Disconnect all existing capture key signals
+    mKeyHandler->disconnect();
+
+    if (!view) {
+        // If view is not given, take current view.
+        view = currentView();
+    }
+
+    CX_DEBUG(("CxuiViewManager - disconnecting from view %d", view));
+    if (view) {
+        // Disconnect all signals from current view to us.
+        disconnect(view, 0, this, 0);
+        // Disconnect all signals from us to current view.
+        disconnect(this, 0, view, 0);
+    }
+
+    OstTrace0(camerax_performance, CXUIVIEWMANAGER_DISCONNECT_2, "msg: e_CX_VIEWMANAGER_DISCONNECT_SIGNALS 0");
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Connect signals to pre-capture view.
+*/
+void CxuiViewManager::connectPreCaptureSignals(CxuiPrecaptureView *view)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    // Disconnect from the current, "old" view
+    disconnectSignals();
+
+    // connecting pre-capture view signals to standby timer.
+    connect(view, SIGNAL(startStandbyTimer()),       this, SLOT(startStandbyTimer()), Qt::UniqueConnection);
+    connect(view, SIGNAL(stopStandbyTimer()),        this, SLOT(stopStandbyTimer()),  Qt::UniqueConnection);
+    connect(view, SIGNAL(changeToPrecaptureView()),  this, SLOT(startStandbyTimer()), Qt::UniqueConnection);
+    connect(view, SIGNAL(changeToPostcaptureView()), this, SLOT(stopStandbyTimer()),  Qt::UniqueConnection);
+
+    // connecting pre-capture view signals to viewmanager slots
+    connect(view, SIGNAL(changeToPostcaptureView()), this, SLOT(changeToPostcaptureView()), Qt::UniqueConnection);
+    connect(view, SIGNAL(changeToPrecaptureView()),  this, SLOT(changeToPrecaptureView()),  Qt::UniqueConnection);
+
+    //connecting scene modes signal
+    connect(view, SIGNAL(showScenesView()), this, SLOT(showScenesView()), Qt::UniqueConnection);
+
+    connect(view, SIGNAL(switchCamera()), this, SLOT(switchCamera()), Qt::UniqueConnection);
+
+    // connecting error signals from precapture view to application state.
+    connect(view, SIGNAL(errorEncountered(CxeError::Id)),
+            mApplicationState, SLOT(handleApplicationError(CxeError::Id)),
+            Qt::UniqueConnection);
+
+    // Standby signals
+    connect(this, SIGNAL(normalStateEntered()), view, SLOT(exitStandby()), Qt::UniqueConnection);
+    connect(this, SIGNAL(normalStateExited()), view, SLOT(enterStandby()), Qt::UniqueConnection);
+
+    // connects all capture key signals.
+    connectCaptureKeySignals(view);
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Connect signals to post-capture view.
+*/
+void CxuiViewManager::connectPostCaptureSignals()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    // Disconnect from the current, "old" view
+    disconnectSignals();
+
+    CxuiView *view = mViews[POSTCAPTURE_VIEW];
+    if (view) {
+        connect(view, SIGNAL(changeToPrecaptureView()), this, SLOT(changeToPrecaptureView()), Qt::UniqueConnection);
+
+        // Standby signals
+        connect(this, SIGNAL(normalStateEntered()), view, SLOT(exitStandby()), Qt::UniqueConnection);
+        connect(this, SIGNAL(normalStateExited()), view, SLOT(enterStandby()), Qt::UniqueConnection);
+
+        // connect necessary capturekey signals
+        connectCaptureKeySignals(view);
+    }
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Connect signals to scene mode view.
+*/
+void CxuiViewManager::connectSceneModeSignals()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    // Disconnect from the current, "old" view
+    disconnectSignals();
+
+    CxuiView *view = mViews[SCENE_MODE_VIEW];
+    if (view) {
+        // Standby signals for releasing camera
+        connect(this, SIGNAL(normalStateEntered()), view, SLOT(exitStandby()));
+        connect(this, SIGNAL(normalStateExited()), view, SLOT(enterStandby()));
+
+        // Moving back to pre-capture view
+        connect(view, SIGNAL(viewCloseEvent()), this, SLOT(changeToPrecaptureView()));
+
+        connectCaptureKeySignals(view);
+    }
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Connect key handler capture key signals.
+*/
+void CxuiViewManager::connectCaptureKeySignals(CxuiView *view)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    // Disconnect all existing capture key signals
+    mKeyHandler->disconnect();
+
+    if (view) {
+        // 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()),  view, SLOT(handleAutofocusKeyPressed()));
+        connect(mKeyHandler, SIGNAL(autofocusKeyReleased()), view, SLOT(handleAutofocusKeyReleased()));
+        connect(mKeyHandler, SIGNAL(captureKeyPressed()),    view, SLOT(handleCaptureKeyPressed()));
+        connect(mKeyHandler, SIGNAL(captureKeyReleased()),   view, SLOT(handleCaptureKeyReleased()));
+    }
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+ * Clears all camera activities from activity manager.
+ */
+void CxuiViewManager::clearAllActivities()
+{
+    HbActivityManager *activityManager = mApplication.activityManager();
+    activityManager->removeActivity(CxuiActivityIds::STILL_PRECAPTURE_ACTIVITY);
+    activityManager->removeActivity(CxuiActivityIds::STILL_POSTCAPTURE_ACTIVITY);
+    activityManager->removeActivity(CxuiActivityIds::VIDEO_PRECAPTURE_ACTIVITY);
+    activityManager->removeActivity(CxuiActivityIds::VIDEO_POSTCAPTURE_ACTIVITY);
+}
+
+/*!
+* Raise application to foreground if it's currently (fully) in background.
+*/
+void CxuiViewManager::toForeground()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    if (mApplicationState->currentState() == CxuiApplicationState::Background) {
+        // Bring to foreground and gain focus.
+        CX_DEBUG(("CxuiViewManager - in background, bringing to foreground now."));
+        mMainWindow.raise();
+        mMainWindow.activateWindow();
+    }
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+// end of file