#include <hbactivitymanager.h>

#include <hbaction.h>

#include "cxuiapplicationstate.h"

namespace

{

    static const int CXUI_STANDBY_CAMERA_TIMEOUT = 60000; // 60 seconds

}

/*!

* Constructor.

*/

    mApplicationState(NULL),

    mErrorManager(NULL),

    // 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(STILL_SCENES_VIEW, SCENEMODE_SETTING_XML);

    // Document loader

    // Application state

    mApplicationState = new CxuiApplicationState(mApplication, mEngine.settings(), *mKeyHandler, 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()));

            mApplicationState, SLOT(handleApplicationError(CxeError::Id)));

            mApplicationState, SLOT(handleApplicationError(CxeError::Id)));

    // 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;

/*!

* 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 = qobject_cast<CxuiView *>(mMainWindow.currentView());

    CX_DEBUG(("CxuiViewManager - current view %d", view));

    switch (newState) {

    case CxuiApplicationState::Normal:

        // 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.

            // 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()

    // Store view that is active now.

    CxuiView *view = qobject_cast<CxuiView *>(mMainWindow.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();

 * Init engine to correct mode based on activity being restored.

 */

void CxuiViewManager::initEngine()

    Cxe::CameraMode mode = Cxe::ImageMode;

    QString activityId = mApplication.activateId();

    if (activityId == CxuiActivityIds::VIDEO_PRECAPTURE_ACTIVITY ||

        activityId == CxuiActivityIds::VIDEO_POSTCAPTURE_ACTIVITY) {

        mode = Cxe::VideoMode;

    }

    if (activityId == CxuiActivityIds::STILL_PRECAPTURE_ACTIVITY ||

        activityId == CxuiActivityIds::VIDEO_PRECAPTURE_ACTIVITY) {

        // init engine only if going to pre-capture

        mEngine.initMode(mode);

    } else {

        // in post-capture don't init but set the correct mode to engine

        // so init can be done later

        mEngine.setMode(mode);

    }

 * Helper function to return current view cast to CxuiView.

 */

CxuiView* CxuiViewManager::currentView() const

    CxuiView *view = qobject_cast<CxuiView*> (mMainWindow.currentView());

    CX_ASSERT_ALWAYS(view);

    return view;

    if (mApplication.activateReason() == Hb::ActivationReasonService) {

    } 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);

        mMainWindow.setCurrentView(view, false);

        if (preCapture) {

            connectPreCaptureSignals();

        } else {

            connectPostCaptureSignals();

        }

        // Check the current application state, signalled to handleApplicationStateChanged.

        mApplicationState->startMonitoring();

        // 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);

        }

        mMainWindow.setCurrentView(view, false);

        connectPreCaptureSignals();

        // Check the current application state, signalled to handleApplicationStateChanged.

        mApplicationState->startMonitoring();

        clearAllActivities();

/*!

* Create view and add it to main window.

*/

CxuiView* CxuiViewManager::createView(const QString &viewName)

    OstTrace0( camerax_performance, CXUIVIEWMANAGER_CREATEVIEW, "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_DEBUG_ASSERT(mCameraDocumentLoader);

        CX_ASSERT_ALWAYS(!docmlFile.isNull());

        OstTrace0( camerax_performance, DUP2_CXUIVIEWMANAGER_ADDPRECAPTUREVIEWS, "msg: e_CX_DOCLOADER_LOAD 1" );

        mCameraDocumentLoader->load(docmlFile, &ok);

        Q_ASSERT_X(ok, "createView", "error in xml file parsing");

        OstTrace0( camerax_performance, DUP2_CXUIVIEWMANAGER_CREATEVIEW, "msg: e_CX_DOCLOADER_LOAD 0" );

        OstTrace0( camerax_performance, DUP4_CXUIVIEWMANAGER_ADDVIEWS, "msg: e_CX_DOCLOADER_FINDWIDGET 1" );

        QGraphicsWidget *widget = NULL;

        // ask for the view widget pointer

        widget = mCameraDocumentLoader->findWidget(viewName);

        view = qobject_cast<CxuiView *> (widget);

        CX_DEBUG_ASSERT(view);

        OstTrace0( camerax_performance, DUP5_CXUIVIEWMANAGER_ADDVIEWS, "msg: e_CX_DOCLOADER_FINDWIDGET 0" );

        // 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, DUP1_CXUIVIEWMANAGER_MAINWINDOW_ADDVIEW, "msg: e_CX_MAINWINDOW_ADDVIEW 1" );

        mMainWindow.addView(view);

        mViews.insert(viewName, view);

        OstTrace0( camerax_performance, DUP2_CXUIVIEWMANAGER_MAINWINDOW_ADDVIEW, "msg: e_CX_MAINWINDOW_ADDVIEW 0" );

        OstTrace0( camerax_performance, DUP1_CXUIVIEWMANAGER_CREATEVIEW, "msg: e_CX_CREATE_STILLPRECAPTUREVIEW 0" );

    }

    CX_DEBUG_EXIT_FUNCTION();

    return view;

}

/*!

* Create scene mode view.

*/

CxuiView* CxuiViewManager::createSceneModesView()

{

    CX_DEBUG_ENTER_FUNCTION();

    mSceneModeView = qobject_cast<CxuiSceneModeView*>(createView(STILL_SCENES_VIEW));

    return mSceneModeView;

    // Disconnect signals from old view.

    disconnectSignals();

    stopStandbyTimer();

    connectSceneModeSignals();

/*!

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

*/

    CX_DEBUG(("CxuiViewManager::getPrecaptureView - mode=%d, camera index=%d", mode, camera));

        CX_DEBUG(("CxuiViewManager::getPrecaptureView - image mode"));

        return qobject_cast<CxuiPrecaptureView*>(createView(STILL_PRE_CAPTURE_VIEW));

        CX_DEBUG(("CxuiViewManager::getPrecaptureView - video mode"));

        return qobject_cast<CxuiPrecaptureView*>(createView(VIDEO_PRE_CAPTURE_VIEW));

/*!

* Get a pointer to the document loader instance.

*/

CxuiDocumentLoader *CxuiViewManager::documentLoader()

/*!

* Get reference to application state instance.

*/

CxuiApplicationState &CxuiViewManager::applicationState()

{

    return *mApplicationState;

}

/*!

* Move to post-capture view.

*/

    // Disconnect signals from old view.

    disconnectSignals();

    CxuiView *postCaptureView = createView(POSTCAPTURE_VIEW);

    mMainWindow.setCurrentView(postCaptureView, false);