/*

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

#include <QTimer>

#include <hbmainwindow.h>

#include <coemain.h>

#include <avkondomainpskeys.h>  // keyguard

#include <hwrmpowerstatesdkpskeys.h> // battery

#include <QGraphicsSceneEvent>

#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<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)

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

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

                }