/*

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

#include <QGraphicsSceneEvent>

#include "cxuiapplication.h"

#include "cxuiapplicationframeworkmonitor.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 "cxuistandby.h"

#include "cxuierrormanager.h"

#include "cxesettings.h"

#include "cxememorymonitor.h"

#include "cxuiserviceprovider.h"

#include "cxuiscenemodeview.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cxuiviewmanagerTraces.h"

#endif

using namespace Cxe;

using namespace CxUiLayout;

// ---------------------------------------------------------------------------

// CxuiViewManager::CxuiViewManager

//

// ---------------------------------------------------------------------------

//

CxuiViewManager::CxuiViewManager(CxuiApplication &application, HbMainWindow &mainWindow, CxeEngine &engine) :

    mApplication(application),

    mMainWindow(mainWindow),

    mStillPrecaptureView(NULL),

    mVideoPrecaptureView(NULL),

    mPostcaptureView(NULL),

    mEngine(engine),

    mKeyHandler(NULL),

    mApplicationMonitor(NULL),

    mCameraDocumentLoader(NULL),

    mSceneModeView(NULL)

{

    CX_DEBUG_ENTER_FUNCTION();

    // Application monitor

    mApplicationMonitor = new CxuiApplicationFrameworkMonitor(mApplication, mEngine.settings());

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

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

    connect(mApplicationMonitor, SIGNAL(batteryEmpty()),

            this, SLOT(handleBatteryEmpty()));

    // Connect memory monitor start / stop to focused status

    connect(this, SIGNAL(focusGained()), &mEngine.memoryMonitor(), SLOT(startMonitoring()));

    connect(this, SIGNAL(focusLost()),   &mEngine.memoryMonitor(), SLOT(stopMonitoring()));

    // Key handler

    mKeyHandler = new CxuiCaptureKeyHandler(mEngine);

    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(&engine);

    OstTrace0( camerax_performance, DUP1_CXUIVIEWMANAGER_CXUIVIEWMANAGER, "msg: e_CX_VIEWMANAGER_CREATE_DOCLOADER 0" );

    // standby functionality and necessary signal connections

    mStandbyHandler = new CxuiStandby(*mKeyHandler, mCameraDocumentLoader, &mEngine);

    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(*mKeyHandler, 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

        CX_DEBUG_ASSERT(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);

        }

        connectPreCaptureSignals();

    }

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

    connect(&mEngine.stillCaptureControl(), SIGNAL(imageCaptured(CxeError::Id, int)),

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

    delete mApplicationMonitor;

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

    // Use document loader to create widgets and layouts

    // (non-sectioned parts are parsed and loaded)

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

    bool ok = false;

    CX_DEBUG_ASSERT(mCameraDocumentLoader);

    mCameraDocumentLoader->load(STILL_1ST_XML, &ok);

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

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

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

    QGraphicsWidget *widget = NULL;

    // ask for the still precapture view widget pointer

    widget = mCameraDocumentLoader->findWidget(STILL_PRE_CAPTURE_VIEW);

    mStillPrecaptureView = qobject_cast<CxuiStillPrecaptureView *> (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)

    OstTrace0( camerax_performance, DUP1_CXUIVIEWMANAGER_MAINWINDOW_ADDVIEW, "msg: e_CX_MAINWINDOW_ADDVIEW 1" );

    mMainWindow.addView(widget);

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

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

    CX_DEBUG_EXIT_FUNCTION();

}

// ---------------------------------------------------------------------------

// CxuiViewManager::createStillScenesView

//

// ---------------------------------------------------------------------------

//

void CxuiViewManager::createSceneModesView()

{

    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)

    QGraphicsWidget *widget = NULL;

    // ask for the scenes mode view widget pointer

    Q_ASSERT_X(ok && (widget != 0), "camerax ui", "invalid xml file");

    mSceneModeView = qobject_cast<CxuiSceneModeView *> (widget);

    // call for needed construction methods

    // .. and add to main window (which also takes ownership)

    mMainWindow.addView(widget);

    mSceneModeView->loadBackgroundImages();

    connect(mSceneModeView, SIGNAL(viewCloseEvent()), this, SLOT(changeToPrecaptureView()));

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* CxuiViewManager::showScenesView

* A private method for displaying Scene Modes selection view

*/

void CxuiViewManager::showScenesView()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (!mSceneModeView) {

        createSceneModesView();

    }

    else {

        mSceneModeView->loadBackgroundImages();

    }

    CX_DEBUG_ASSERT(mSceneModeView);

    mMainWindow.blockSignals(true);

    mMainWindow.setCurrentView(mSceneModeView, false);

    emit disableStandbyTimer();

    connectCaptureKeySignals();

    mMainWindow.blockSignals(false);

    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<CxuiVideoPrecaptureView *> (widget);

    CX_DEBUG_ASSERT(mVideoPrecaptureView);

    mVideoPrecaptureView->construct(&mMainWindow, &mEngine, mCameraDocumentLoader, mKeyHandler);

    // add view to main window

    OstTrace0( camerax_performance, DUP3_CXUIVIEWMANAGER_MAINWINDOW_ADDVIEW, "msg: e_CX_MAINWINDOW_ADDVIEW 1" );

    mMainWindow.addView(mVideoPrecaptureView);

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

    OstTrace0( camerax_performance, DUP1_CXUIVIEWMANAGER_CREATEVIDEOPRECAPTUREVIEW, "msg: e_CX_CREATE_VIDEOPRECAPTUREVIEW 0" );

    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<CxuiPostcaptureView *> (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));

    CX_DEBUG_ASSERT(camera == Cxe::PrimaryCameraIndex);

    if (mode == ImageMode) {

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

        if(!mStillPrecaptureView) {

            createStillPrecaptureView();

        }

        return mStillPrecaptureView;

    } else {

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

        if(!mVideoPrecaptureView) {

            createVideoPrecaptureView();

        }

        return mVideoPrecaptureView;

    }

}

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

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

    emit startStandbyTimer();

    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)

{

    Q_UNUSED(object)

    bool eventWasConsumed = false;

    switch (event->type())

    {

    case QEvent::KeyPress:

    case QEvent::KeyRelease:

        eventWasConsumed = mKeyHandler->handleKeyEvent(event);

        break;

    }

    // No need to call base class implementation, because we derive from QObject directly.

    // QObject::eventFilter() implementation always returns false.

    return eventWasConsumed;

}

// ---------------------------------------------------------------------------

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