/*

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

#include <QApplication>

#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 <hbactivitymanager.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 "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cxuivideoprecaptureviewTraces.h"

#endif

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

    //!@todo Localization?

    static const char* VIDEO_TIME_FORMAT = "%02d:%02d";

}

CxuiVideoPrecaptureView::CxuiVideoPrecaptureView(QGraphicsItem *parent) :

    CxuiPrecaptureView(parent),

    mElapsedTimer(this),

    mTimeElapsed(0),

    mTimeRemaining(0),

    mElapsedTimeText(NULL),

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

}

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

                                        CxuiDocumentLoader *documentLoader,

                                        CxuiCaptureKeyHandler *keyHandler,

                                        HbActivityManager *activityManager)

{

    CX_DEBUG_ENTER_FUNCTION();

    CxuiPrecaptureView::construct(mainwindow, engine, documentLoader, keyHandler, activityManager);

    mCaptureKeyHandler = keyHandler;

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

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

    connect(mVideoCaptureControl, SIGNAL(snapshotReady(CxeError::Id, const QImage&, const QString&)),

            this, SLOT(handleSnapshot(CxeError::Id)));

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

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

    connect(&(mEngine->settings()), SIGNAL(sceneChanged(CxeScene&)),

            this, SLOT(handleSceneChanged(CxeScene&)));

    connect(mVideoCaptureControl, SIGNAL(remainingTimeChanged()),

            this, SLOT(updateTimeLabels()));

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

}

void CxuiVideoPrecaptureView::loadDefaultWidgets()

{

    CX_DEBUG_ENTER_FUNCTION();

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

}

void CxuiVideoPrecaptureView::loadWidgets()

{

    CX_DEBUG_ENTER_FUNCTION();

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

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

    }

    // get needed pointers to some of the widgets

    widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_ZOOM_SLIDER);

    mSlider = qobject_cast<CxuiZoomSlider *> (widget);

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

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

    createWidgetBackgroundGraphic(indicatorContainer, TRANSPARENT_BACKGROUND_GRAPHIC);

    widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_ELAPSED_TIME_LABEL);

    mElapsedTimeText = qobject_cast<HbLabel *> (widget);

    widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_REMAINING_TIME_LABEL);

    mRemainingTimeText = qobject_cast<HbLabel *> (widget);

    widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_RECORDING_ICON);

    mRecordingIcon = qobject_cast<HbLabel *> (widget);

    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.

    QString sceneId;

    if (mEngine->settings().get(CxeSettingIds::SCENE_ID, sceneId) == CxeError::None) {

        updateSceneIcon(sceneId);

    }

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

    //@todo: add pre-capture icon as screenshot

    mActivityManager->removeActivity(CxuiActivityIds::VIDEO_PRECAPTURE_ACTIVITY);

    mActivityManager->addActivity(CxuiActivityIds::VIDEO_PRECAPTURE_ACTIVITY, data, params);

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

 * Clear activity from activity manager.

 */

void CxuiVideoPrecaptureView::clearActivity()

{

    CX_DEBUG_ENTER_FUNCTION();

    mActivityManager->removeActivity(CxuiActivityIds::VIDEO_PRECAPTURE_ACTIVITY);

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

    if(mEngine) {

        mEngine->settings().get(CxeSettingIds::VIDEO_SHOWCAPTURED, showPostcapture);

    }

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

                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 = -1;

        mEngine->settings().get(CxeSettingIds::VIDEO_QUALITY, currentValue);

        icon = getSettingItemIcon(CxeSettingIds::VIDEO_QUALITY, currentValue);

        mQualityIcon->setIcon(HbIcon(icon));

    }

    CX_DEBUG_EXIT_FUNCTION();

}

void CxuiVideoPrecaptureView::handleSnapshot(CxeError::Id /*error*/)

{