/*

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

#include <QMetaType>

#include <QGraphicsLayout>

#include <hbpushbutton.h>

#include <hblabel.h>

#include <hbtoolbar.h>

#include <hbaction.h>

#include <hbmainwindow.h>

#include <hbtransparentwindow.h>

#include <hbslider.h>

#include <hblistwidget.h>

#include <hbdialog.h>

#include <hblistwidgetitem.h>

#include <hbtoolbarextension.h>

#include <hbtoolbutton.h>

#include <hbdeviceprofile.h> // HbDeviceProfile

#include <hbmenu.h>

#include <hbicon.h>

#include <hbactivitymanager.h>

#include "cxuiselftimer.h"

#include "cxeengine.h"

#include "cxeviewfindercontrol.h"

#include "cxecameradevicecontrol.h"

#include "cxestillcapturecontrol.h"

#include "cxeautofocuscontrol.h"

#include "cxuicapturekeyhandler.h"

#include "cxutils.h"

#include "cxenamespace.h" // CxeSettingIds

#include "cxuienums.h"

#include "cxesettings.h"

#include "cxefeaturemanager.h" // mEngine->featureManager()

#include "cxuidocumentloader.h"

#ifdef Q_OS_SYMBIAN

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cxuistillprecaptureviewTraces.h"

#endif

#endif //Q_OS_SYMBIAN

#include "cxuistillprecaptureview.h"

#include "cxuiserviceprovider.h"

#include "cxuisettingdialog.h"

#include "cxuisettingradiobuttonlist.h"

#include "cxuizoomslider.h"

using namespace Cxe;

using namespace CxUiLayout;

using namespace CxUiInternal;

const int CXUI_CAPTURE_PENDING_TIMEOUT = 5000; // 5 seconds

const int CXUI_IMAGES_LEFT_LIMIT = 99; // images left is shown only if below this limit

CxuiStillPrecaptureView::CxuiStillPrecaptureView( QGraphicsItem *parent) :

    CxuiPrecaptureView(parent),

    mSelfTimer(NULL),

    mFlashSetting(NULL),

    mStillSettingsPopup(NULL),

    mSceneModePopup(NULL),

    mCapturePending(false),

    mImagesLeft(NULL),

    mImagesLeftContainer(NULL),

    mPendingAfCanceling(false)

{

    CX_DEBUG_IN_FUNCTION();

}

CxuiStillPrecaptureView::~CxuiStillPrecaptureView()

{

    CX_DEBUG_IN_FUNCTION();

    delete mSelfTimer;

}

/*!

 * Construct-method handles initialisation tasks for this class. Needs to be called

 * before the instance of this class is used.

 * @param mainwindow

 * @param engine

 * @param documentLoader

 * @param keyHandler

 */

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

                                        CxuiDocumentLoader *documentLoader,

                                        CxuiCaptureKeyHandler *keyHandler,

                                        HbActivityManager *activityManager)

{

    CX_DEBUG_ENTER_FUNCTION();

    OstTrace0( camerax_performance, CXUISTILLPRECAPTUREVIEW_CONSTRUCT, "msg: e_CX_STILLPRECAPVIEW_CONSTRUCT 1" );

    // constuct base class

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

    connect(&mEngine->autoFocusControl(), SIGNAL(stateChanged(CxeAutoFocusControl::State,CxeError::Id)),

            this, SLOT(handleAutoFocusStateChanged(CxeAutoFocusControl::State,CxeError::Id)));

    connect(&mEngine->stillCaptureControl(), SIGNAL(snapshotReady(CxeError::Id, const QImage&, int)),

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

    connect(&mEngine->stillCaptureControl(), SIGNAL(stateChanged(CxeStillCaptureControl::State, CxeError::Id)),

            this, SLOT(handleStillCaptureStateChanged(CxeStillCaptureControl::State, CxeError::Id)));

    connect(&mEngine->viewfinderControl(), SIGNAL(stateChanged(CxeViewfinderControl::State, CxeError::Id)),

            this, SLOT(handleViewfinderStateChanged(CxeViewfinderControl::State, CxeError::Id)));

    connect(&mEngine->stillCaptureControl(), SIGNAL(availableImagesChanged()),

            this, SLOT(updateImagesLeftLabel()));

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

    loadDefaultWidgets();

    hideControls();

    OstTrace0( camerax_performance, DUP1_CXUISTILLPRECAPTUREVIEW_CONSTRUCT, "msg: e_CX_STILLPRECAPVIEW_CONSTRUCT 0" );

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

 * Loads default widgets in layouts xml.

 */

void CxuiStillPrecaptureView::loadDefaultWidgets()

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_ASSERT_ALWAYS(mDocumentLoader);

    // get pointer to the viewfinder

    QGraphicsWidget *widget = NULL;

    widget = mDocumentLoader->findWidget(STILL_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 CxuiStillPrecaptureView::reloadIndicatorWidgets()

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_ASSERT_ALWAYS(mDocumentLoader);

    bool ok = false;

    mDocumentLoader->load(STILL_1ST_XML, STILL_PRE_CAPTURE_INDICATORS_SECTION, &ok);

    CX_ASSERT_ALWAYS(ok);

    QGraphicsWidget *widget = NULL;

    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_QUALITY_ICON);

    mQualityIcon = qobject_cast<HbLabel *>(widget);

    CX_ASSERT_ALWAYS(mQualityIcon);

    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_FLASHBLINK_INDICATOR_ICON);

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

    CX_ASSERT_ALWAYS(flashBlinkingIcon);

    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_GEOTAGGING_INDICATOR_ICON);

    mGeoTaggingIndicatorIcon = qobject_cast<HbLabel *>(widget);

    CX_ASSERT_ALWAYS(mGeoTaggingIndicatorIcon);

    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_FACE_TRACKING_ICON);

    mFaceTrackingIcon = qobject_cast<HbLabel *>(widget);

    CX_ASSERT_ALWAYS(mFaceTrackingIcon);

    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_INDICATOR_CONTAINER);

    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 == mGeoTaggingIndicatorIcon) {

                key = CxeSettingIds::GEOTAGGING;

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

                if (currentSettingValue == Cxe::GeoTaggingOff) {

                    isSettingOff = true;

                }

            } else if (graphicsItem == mFaceTrackingIcon) {

                key = CxeSettingIds::FACE_TRACKING;

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

                // facetracking 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 == flashBlinkingIcon) {

                //remove flash indicator

                isSettingOff = true;

            }

            if (isSettingOff) {

                layout->removeAt(i);

            }

        }

    }

    // create background 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 CxuiStillPrecaptureView::loadWidgets()

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_ASSERT_ALWAYS(mDocumentLoader);

    if (mWidgetsLoaded) {

        CX_DEBUG(("Widgets already loaded"));

        CX_DEBUG_EXIT_FUNCTION();

        return;

    }

    OstTrace0( camerax_performance, CXUISTILLPRECAPTUREVIEW_LOADWIDGETS, "msg: e_CX_STILLPRECAPTUREVIEW_LOADWIDGETS 1" );

    bool ok = false;

    OstTrace0( camerax_performance, DUP4_CXUISTILLPRECAPTUREVIEW_LOADWIDGETS, "msg: e_CX_DOCUMENTLOADER_LOAD 1" );

    mDocumentLoader->load(STILL_1ST_XML, STILL_PRE_CAPTURE_WIDGETS_SECTION, &ok);

    CX_ASSERT_ALWAYS(ok);

    if (CxuiServiceProvider::isCameraEmbedded()) {

        mDocumentLoader->load(STILL_1ST_XML, STILL_PRE_CAPTURE_EMBEDDED_SECTION, &ok);

    } else {

        mDocumentLoader->load(STILL_1ST_XML, STILL_PRE_CAPTURE_STANDALONE_SECTION, &ok);

    }

    OstTrace0( camerax_performance, DUP5_CXUISTILLPRECAPTUREVIEW_LOADWIDGETS, "msg: e_CX_DOCUMENTLOADER_LOAD 0" );

    CX_ASSERT_ALWAYS(ok);

    // get pointers to ui components from the layout data

    QGraphicsWidget *widget = NULL;

    QObject *object = NULL;

    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_ZOOM_SLIDER);

    mSlider = qobject_cast<CxuiZoomSlider *>(widget);

    CX_ASSERT_ALWAYS(mSlider);

    mSlider->addZoomButtons();

    createWidgetBackgroundGraphic(mSlider, TRANSPARENT_BACKGROUND_GRAPHIC);

    // create background for selftimer containers

    HbWidget *container = NULL;

    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_CONTAINER);

    container = qobject_cast<HbWidget *>(widget);

    CX_ASSERT_ALWAYS(container);

    createWidgetBackgroundGraphic(container, TRANSPARENT_BACKGROUND_GRAPHIC);

    // connect selftimer start button to hide controls

    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_START_BUTTON);

    HbPushButton *startButton = qobject_cast<HbPushButton *>(widget);

    CX_ASSERT_ALWAYS(startButton);

    connect(startButton, SIGNAL(released()), this, SLOT(hideControls()));

    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_TOOLBAR);

    mToolbar = qobject_cast<HbToolBar *>(widget);

    CX_ASSERT_ALWAYS(mToolbar);

    object = mDocumentLoader->findObject(STILL_PRE_CAPTURE_FLASH_ACTION);

    mFlashSetting = qobject_cast<HbAction *>(object);

    CX_ASSERT_ALWAYS(mFlashSetting);

    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_IMAGES_LEFT_LABEL);

    mImagesLeft = qobject_cast<HbLabel *>(widget);

    CX_ASSERT_ALWAYS(mImagesLeft);

    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_IMAGES_LEFT_CONTAINER);

    mImagesLeftContainer = qobject_cast<HbWidget *>(widget);

    CX_ASSERT_ALWAYS(mImagesLeftContainer);

    createWidgetBackgroundGraphic(mImagesLeftContainer, TRANSPARENT_BACKGROUND_GRAPHIC);

    updateImagesLeftLabel();

    // Create self timer.

    // Let selftimer class get needed selftimer related widgets from the documentloader

    mSelfTimer = new CxuiSelfTimer(mEngine->settings());

    CX_ASSERT_ALWAYS(mSelfTimer);

    connect(mSelfTimer, SIGNAL(timerFinished()), this, SLOT(focusAndCapture()));

    mSelfTimer->loadSelftimerWidgets(mDocumentLoader);

    if (CxuiServiceProvider::isCameraEmbedded()) {

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

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

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

            HbAction* iq = qobject_cast<HbAction*>(mDocumentLoader->findObject(STILL_PRE_CAPTURE_IMAGE_QUALITY_ACTION));

            if (iq) {

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

                iq->setEnabled(false);

            }

        }

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

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

            HbAction *video = qobject_cast<HbAction*>(mDocumentLoader->findObject(STILL_PRE_CAPTURE_GOTO_VIDEO_ACTION));

            if (video) {

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

                video->setEnabled(false);

            }

        }

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

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

        }

    }

    // Setting widgets loaded here so updating icons works.

    mWidgetsLoaded = true;

    // Update toolbar flash mode icon

    int flash = mEngine->settings().get<int>(CxeSettingIds::FLASH_MODE);

    handleSettingValueChanged(CxeSettingIds::FLASH_MODE, flash);

    // Update toolbar scene mode icon

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

    hideControls();

    // Check if we need to show the geotagging disclaimer for first time use.

    Cxe::GeoTaggingDisclaimer value = mEngine->settings().get<Cxe::GeoTaggingDisclaimer>(CxeSettingIds::GEOTAGGING_DISCLAIMER, Cxe::GeoTaggingDisclaimerDisabled);

    if (value == Cxe::GeoTaggingDisclaimerEnabled) {

        launchGeoTaggingDisclaimerDialog();

    }

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

    emit viewReady();

    OstTrace0( camerax_performance, DUP1_CXUISTILLPRECAPTUREVIEW_LOADWIDGETS, "msg: e_CX_STILLPRECAPTUREVIEW_LOADWIDGETS 0" );

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

 * Restore view state from activity.

 */

void CxuiStillPrecaptureView::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 CxuiStillPrecaptureView::saveActivity()

{

    CX_DEBUG_ENTER_FUNCTION();

    QVariantMap data;

    QVariantHash params;

    HbIcon activityScreenshot("qtg_graf_taskswitcher_camera");

    QPixmap screenshot = activityScreenshot.pixmap();

    params.insert("screenshot", screenshot);

    mActivityManager->removeActivity(

            CxuiActivityIds::STILL_PRECAPTURE_ACTIVITY);

    mActivityManager->addActivity(CxuiActivityIds::STILL_PRECAPTURE_ACTIVITY,

                                  data, params);

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

 * Clear activity from activity manager.

 */

void CxuiStillPrecaptureView::clearActivity()

{

    CX_DEBUG_ENTER_FUNCTION();

    mActivityManager->removeActivity(CxuiActivityIds::STILL_PRECAPTURE_ACTIVITY);

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Initializing settings grid

*/

void CxuiStillPrecaptureView::initializeSettingsGrid()

{

    if(!mSettingsGrid) {

        HbAction* action(NULL);

        // Initialize settings grid

        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_mono_iso"), hbTrId("txt_cam_button_iso"), this, SLOT(launchSetting()));

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

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

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

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

        action->setProperty(PROPERTY_KEY_SETTING_GRID, PROPERTY_KEY_TRUE);

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

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

        action->setProperty(PROPERTY_KEY_SETTING_GRID, PROPERTY_KEY_TRUE);

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

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

        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 CxuiStillPrecaptureView::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) {

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

    }

    CX_DEBUG_EXIT_FUNCTION();

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

}

/*!

* Update the scene mode icon.

* @param sceneId The new scene id.

*/

void CxuiStillPrecaptureView::updateSceneIcon(const QString& sceneId)

{

    CX_DEBUG_ENTER_FUNCTION();

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

        CX_DEBUG(("CxuiStillPrecaptureView - 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 = STILL_PRE_CAPTURE_SCENE_MODE_ACTION;

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

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