/*

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

#include <QGraphicsLayout>

#include <hbmainwindow.h>

#include <hbaction.h>

#include <hbtoolbar.h>

#include <hbtoolbarextension.h>

#include <hbtransparentwindow.h>

#include <hblabel.h>

#include <hbslider.h>

#include <hbmenu.h>

#include <hbdialog.h>

#include <hbnotificationdialog.h>

#include <hbfeedbacksettings.h>

#include <hbfeedbacknamespace.h>

#include <hbextendedlocale.h>

#include "cxuivideoprecaptureview.h"

#include "cxeengine.h"

#include "cxeviewfindercontrol.h"

#include "cxevideocapturecontrol.h"

#include "cxecameradevicecontrol.h"

#include "cxenamespace.h"

#include "cxesettings.h"

#include "cxuienums.h"

#include "cxutils.h"

#include "cxuizoomslider.h"

#include "cxuicapturekeyhandler.h"

#include "cxuidocumentloader.h"

#include "cxuiserviceprovider.h"

#ifdef Q_OS_SYMBIAN

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cxuivideoprecaptureviewTraces.h"

#endif

#include <e32keys.h>

#endif  //Q_OS_SYMBIAN

using namespace Cxe;

using namespace CxUiLayout;

using namespace CxUiInternal;

namespace

{

    static const int CXUI_ELAPSED_TIME_TIMEOUT = 1000; // 1 second

    static const int CXUI_RECORD_ANIMATION_DURATION = 3000; // milliseconds

    static const int CXUI_PAUSE_TIMEOUT = 60*1000;   // 60 seconds

    const int POSTCAPTURE_ON = -1;

}

CxuiVideoPrecaptureView::CxuiVideoPrecaptureView(QGraphicsItem *parent) :

    CxuiPrecaptureView(parent),

    mElapsedTimer(this),

    mTimeElapsed(0),

    mTimeRemaining(0),

    mVideoTimeText(NULL),

    mRecordingIcon(NULL),

    mGoToStillAction(NULL),

    mToolbarIdle(NULL),

    mToolbarRec(NULL),

    mToolbarPaused(NULL),

    mVideoScenePopup(NULL),

    mVideoCaptureControl(NULL),

    mMenu(NULL),

    mCapturePending(false)

{

    CX_DEBUG_IN_FUNCTION();

}

CxuiVideoPrecaptureView::~CxuiVideoPrecaptureView()

{

    CX_DEBUG_IN_FUNCTION();

    mElapsedTimer.stop();

    delete mMenu;

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

 * Construct-method handles initialisation tasks for this class.

 * @param mainwindow

 * @param engine

 * @param documentLoader

 * @param keyHandler

 */

void CxuiVideoPrecaptureView::construct(HbMainWindow *mainwindow, CxeEngine *engine,

                                        CxuiDocumentLoader *documentLoader,

{

    CX_DEBUG_ENTER_FUNCTION();

    mCaptureKeyHandler = keyHandler;

    mVideoCaptureControl = &(engine->videoCaptureControl());

    connect(&mElapsedTimer, SIGNAL(timeout()), this, SLOT(updateTimeLabels()));

    connect(mVideoCaptureControl, SIGNAL(stateChanged(CxeVideoCaptureControl::State, CxeError::Id)),

            this, SLOT(handleVideoStateChanged(CxeVideoCaptureControl::State,CxeError::Id)));

    connect(mVideoCaptureControl, SIGNAL(remainingTimeChanged()),

            this, SLOT(updateTimeLabels()));

    mEngine->settings().listenForSetting(CxeSettingIds::VIDEO_SCENE, this, SLOT(handleSceneChanged(const QVariant&)));

    mPauseTimer.setSingleShot(true);

    connect(&mPauseTimer, SIGNAL(timeout()), this, SLOT(stop()));

    mPauseTimer.setInterval(CXUI_PAUSE_TIMEOUT);

    HbAction *quitAction = new HbAction(Hb::QuitNaviAction, this);

    setNavigationAction(quitAction);

    connect(quitAction, SIGNAL(triggered()), this, SLOT(handleQuitClicked()));

    loadDefaultWidgets();

    loadWidgets();

    hideControls();

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

 * Loads widgets that are needed right from the start.

 */

void CxuiVideoPrecaptureView::loadDefaultWidgets()

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_ASSERT_ALWAYS(mDocumentLoader);

    // get pointers to ui components from the layout data

    QGraphicsWidget *widget = NULL;

    widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_VIEWFINDER);

    mViewfinder = qobject_cast<HbTransparentWindow *> (widget);

    CX_ASSERT_ALWAYS(mViewfinder);

    reloadIndicatorWidgets();

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

 * Loads default indicators from docml and modifies the visibility

 * according to current settings.

 */

void CxuiVideoPrecaptureView::reloadIndicatorWidgets()

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_ASSERT_ALWAYS(mDocumentLoader);

    bool ok = false;

    mDocumentLoader->load(VIDEO_1ST_XML, VIDEO_PRE_CAPTURE_INDICATORS_SECTION, &ok);

    CX_ASSERT_ALWAYS(ok);

    QGraphicsWidget *widget = NULL;

    widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_QUALITY_ICON);

    mQualityIcon = qobject_cast<HbLabel *> (widget);

    CX_ASSERT_ALWAYS(mQualityIcon);

    widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_VIDEOAUDIOMUTE_INDICATOR_ICON);

    HbLabel *videoaudiomuteIndicatorIcon = qobject_cast<HbLabel *>(widget);

    CX_ASSERT_ALWAYS(videoaudiomuteIndicatorIcon);

    widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_STABILITY_INDICATOR_ICON);

    HbLabel *videoStabilityIndicatorIcon = qobject_cast<HbLabel *>(widget);

    CX_ASSERT_ALWAYS(videoStabilityIndicatorIcon);

    widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_INDICATOR_CONTAINER_TOP);

    mIndicators = qobject_cast<HbWidget *>(widget);

    CX_ASSERT_ALWAYS(mIndicators);

    QGraphicsLayout *layout = mIndicators->layout();

    QGraphicsLayoutItem *graphicsLayoutItem = NULL;

    QGraphicsItem *graphicsItem = NULL;

    QString key = "";

    int currentSettingValue = -1;

    bool isSettingOff = false;

    // Go through the items in the layout to check whether they should be

    // shown or not in the indicator pane. Start from the last towards

    // the first, so that removing items from between works correctly.

    for (int i = layout->count() - 1; i >= 0; i--) {

        graphicsLayoutItem = layout->itemAt(i);

        isSettingOff = false;

        if (graphicsLayoutItem) {

            graphicsItem = graphicsLayoutItem->graphicsItem();

            currentSettingValue = -1;

            if (graphicsItem == videoaudiomuteIndicatorIcon) {

                key = CxeSettingIds::VIDEO_MUTE_SETTING;

                currentSettingValue = mEngine->settings().get(key, currentSettingValue);

                // video mute implementation does not use

                // enum for on/off values but instead

                // 0 for off and 1 for on.

                if (currentSettingValue == 0) {

                    isSettingOff = true;

                }

            } else if (graphicsItem == videoStabilityIndicatorIcon) {

                // remove video stability indicator.

                isSettingOff = true;

            }

            if (isSettingOff) {

                layout->removeAt(i);

            }

        }

    }

    // Create background graphics for indicator container

    createWidgetBackgroundGraphic(mIndicators, TRANSPARENT_BACKGROUND_GRAPHIC);

    mIndicators->setVisible(true);

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

 * Loads widgets that are not part of the default section in layouts xml.

 * Widgets are created at the time they are first loaded.

 */

void CxuiVideoPrecaptureView::loadWidgets()

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_ASSERT_ALWAYS(mDocumentLoader);

    if (mWidgetsLoaded) {

        CX_DEBUG(("Widgets already loaded"));

        CX_DEBUG_EXIT_FUNCTION();

        return;

    }

    // get pointers to ui components from the layout data

    QGraphicsWidget *widget = NULL;

    // load the "secondary" widgets

    bool ok = false;

    // load widgets section (creates the widgets)

    mDocumentLoader->load(VIDEO_1ST_XML, VIDEO_PRE_CAPTURE_WIDGETS_SECTION, &ok);

    CX_ASSERT_ALWAYS(ok);

    if (CxuiServiceProvider::isCameraEmbedded()) {

        mDocumentLoader->load(VIDEO_1ST_XML, VIDEO_PRE_CAPTURE_EMBEDDED_SECTION, &ok);

    } else {

        mDocumentLoader->load(VIDEO_1ST_XML, VIDEO_PRE_CAPTURE_STANDALONE_SECTION, &ok);

    }

    CX_ASSERT_ALWAYS(ok);

    // get needed pointers to some of the widgets

    widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_ZOOM_SLIDER);

    mSlider = qobject_cast<CxuiZoomSlider *> (widget);

    CX_ASSERT_ALWAYS(mSlider);

    //Let's add a plus and minus buttons to the slider

    mSlider->addZoomButtons();

    createWidgetBackgroundGraphic(mSlider, TRANSPARENT_BACKGROUND_GRAPHIC);

    widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_TOOLBAR);

    mToolbarIdle = qobject_cast<HbToolBar *> (widget);

    widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_TOOLBAR_REC);

    mToolbarRec = qobject_cast<HbToolBar *> (widget);

    widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_TOOLBAR_PAUSED);

    mToolbarPaused = qobject_cast<HbToolBar *> (widget);

    mToolbar = mToolbarIdle;

    CX_ASSERT_ALWAYS(mToolbarIdle);

    CX_ASSERT_ALWAYS(mToolbarRec);

    CX_ASSERT_ALWAYS(mToolbarPaused);

    hideControls();

    if (CxuiServiceProvider::isCameraEmbedded()) {

        CX_DEBUG(("EMBEDDED: camera in embedded mode"));

        if (!CxuiServiceProvider::instance()->allowQualityChange()) {

            CX_DEBUG(("EMBEDDED: don't allow quality change"));

            HbAction* vq = qobject_cast<HbAction*> (mDocumentLoader->findObject(VIDEO_PRE_CAPTURE_VIDEO_QUALITY_ACTION));

            if (vq) {

                CX_DEBUG(("EMBEDDED: setting image quality setting to disabled"));

                vq->setEnabled(false);

            }

        }

        if (!CxuiServiceProvider::instance()->allowModeSwitching()) {

            CX_DEBUG(("EMBEDDED: don't allow mode switching"));

            HbAction *still = qobject_cast<HbAction*> (mDocumentLoader->findObject(VIDEO_PRE_CAPTURE_GOTO_STILL_ACTION));

            if (still) {

                CX_DEBUG(("EMBEDDED: setting mode switch to disabled"));

                still->setEnabled(false);

            }

        }

        if (!CxuiServiceProvider::instance()->allowCameraSwitching()) {

            CX_DEBUG(("EMBEDDED: don't allow camera switching"));

        }

    }

    // Create background graphic for indicator container

    HbWidget *indicatorContainer;

    widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_INDICATOR_CONTAINER_BOTTOM);

    indicatorContainer = qobject_cast<HbWidget *>(widget);

    CX_ASSERT_ALWAYS(indicatorContainer);

    createWidgetBackgroundGraphic(indicatorContainer, TRANSPARENT_BACKGROUND_GRAPHIC);

    widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_VIDEO_TIME_LABEL);

    mVideoTimeText = qobject_cast<HbLabel *> (widget);

    CX_ASSERT_ALWAYS(mVideoTimeText);

    widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_RECORDING_ICON);

    mRecordingIcon = qobject_cast<HbLabel *> (widget);

    CX_ASSERT_ALWAYS(mRecordingIcon);

    mWidgetsLoaded = true;

    // Initializing recording indicator animation

    mRecordingAnimation = new QPropertyAnimation(mRecordingIcon, "opacity");

    mRecordingAnimation->setStartValue(0.2);

    mRecordingAnimation->setKeyValueAt(0.5, 1.0);

    mRecordingAnimation->setEndValue(0.2);

    mRecordingAnimation->setDuration(CXUI_RECORD_ANIMATION_DURATION);

    mRecordingAnimation->setLoopCount(-1);

    mRecordingAnimation->setEasingCurve(QEasingCurve::OutInQuad);

    // Update toolbar scene mode icon.

    try {

        updateSceneIcon(mEngine->settings().get<QString>(CxeSettingIds::VIDEO_SCENE));

    } catch (CxeException &e) {

        // ignore error

    }

    // Initialize the video time counters.

    updateTimeLabels();

    // View is ready. Needed for startup performance automated testing.

    emit viewReady();

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

 * Restore view state from activity.

 */

void CxuiVideoPrecaptureView::restoreActivity(const QString &activityId, const QVariant &data)

{

    Q_UNUSED(activityId);

    Q_UNUSED(data);

    CX_DEBUG_ENTER_FUNCTION();

    // no need to restore any state

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

 * Save view state to activity.

 */

void CxuiVideoPrecaptureView::saveActivity()

{

    CX_DEBUG_ENTER_FUNCTION();

    QVariantMap data;

    QVariantHash params;

    HbIcon activityScreenshot("qtg_graf_taskswitcher_camcorder");

    QPixmap screenshot = activityScreenshot.pixmap();

    params.insert("screenshot", screenshot);

            CxuiActivityIds::VIDEO_PRECAPTURE_ACTIVITY);

                                  data, params);

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

 */

void CxuiVideoPrecaptureView::clearActivity()

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Initialize settings grid.

*/

void CxuiVideoPrecaptureView::initializeSettingsGrid()

{

    if(!mSettingsGrid) {

        HbAction* action(NULL);

        mSettingsGrid = new HbToolBarExtension;

        action = mSettingsGrid->addAction(HbIcon("qtg_mono_exposure"), hbTrId("txt_cam_button_exposure_compensation"), this, SLOT(launchSliderSetting()));

        action->setProperty(PROPERTY_KEY_SETTING_ID, CxeSettingIds::EV_COMPENSATION_VALUE);

        action->setProperty(PROPERTY_KEY_SETTING_GRID, PROPERTY_KEY_TRUE);

        action = mSettingsGrid->addAction(HbIcon("qtg_small_rgb"), hbTrId("txt_cam_button_color_tone"), this, SLOT(launchSetting()));

        action->setProperty(PROPERTY_KEY_SETTING_ID, CxeSettingIds::COLOR_TONE);

        action->setProperty(PROPERTY_KEY_SETTING_GRID, PROPERTY_KEY_TRUE);

        action = mSettingsGrid->addAction(HbIcon("qtg_mono_white_balance"), hbTrId("txt_cam_button_white_balance"), this, SLOT(launchSetting()));

        action->setProperty(PROPERTY_KEY_SETTING_ID, CxeSettingIds::WHITE_BALANCE);

        action->setProperty(PROPERTY_KEY_SETTING_GRID, PROPERTY_KEY_TRUE);

        connect(mCaptureKeyHandler, SIGNAL(autofocusKeyPressed()), mSettingsGrid, SLOT(close()));

    }

}

/**

* Get if postcapture view should be shown or not.

* Postcapture view may be shown for a predefined time or

* until user dismisses it, or it may be completely disabled.

*/

bool CxuiVideoPrecaptureView::isPostcaptureOn() const

{

    CX_DEBUG_ENTER_FUNCTION();

    if (CxuiServiceProvider::isCameraEmbedded()) {

        // always show post capture in embedded mode

        CX_DEBUG_EXIT_FUNCTION();

        return true;

    }

    // Read the value from settings. Ignoring reading error.

    // On error (missing settings) default to "postcapture on".

    int showPostcapture(POSTCAPTURE_ON);

    if(mEngine) {

        showPostcapture = mEngine->settings().get<int>(CxeSettingIds::VIDEO_SHOWCAPTURED, POSTCAPTURE_ON);

    }

    CX_DEBUG_EXIT_FUNCTION();

    return showPostcapture != 0; // 0 == no postcapture

}

/*!

* Update the scene mode icon.

* @param sceneId The new scene id.

*/

void CxuiVideoPrecaptureView::updateSceneIcon(const QString& sceneId)

{

    CX_DEBUG_ENTER_FUNCTION();

    if (mEngine->mode() == Cxe::VideoMode) {

        CX_DEBUG(("CxuiPrecaptureView - scene: %s", sceneId.toAscii().constData()));

        // No need to update icon, if widgets are not even loaded yet.

        // We'll update the icon once the widgets are loaded.

        if (mWidgetsLoaded) {

            QString iconObjectName = VIDEO_PRE_CAPTURE_SCENE_MODE_ACTION;

            QString icon = getSettingItemIcon(CxeSettingIds::VIDEO_SCENE, sceneId);

            CX_DEBUG(("CxuiVideoPrecaptureView - icon: %s", icon.toAscii().constData()));

            if (mDocumentLoader) {

                QObject *obj = mDocumentLoader->findObject(iconObjectName);

                CX_ASSERT_ALWAYS(obj);

                qobject_cast<HbAction *>(obj)->setIcon(HbIcon(icon));

            }

        } else {

            CX_DEBUG(("CxuiVideoPrecaptureView - widgets not loaded yet, ignored!"));

        }

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

    Update the quality indicator

*/

void CxuiVideoPrecaptureView::updateQualityIcon()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (mQualityIcon && mEngine) {

        QString icon = "";

        int currentValue = mEngine->settings().get<int>(CxeSettingIds::VIDEO_QUALITY, -1);