/*

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

#include <QTimer>

#include <QGraphicsSceneEvent>

#include <QFileInfo>

#include <QApplication>

#include <QGraphicsRectItem>

#include <QBrush>

#include <QDir>

#include <QProcess>

#include <hblabel.h>

#include <hbmainwindow.h>

#include <hbtoolbar.h>

#include <hbaction.h>

#include <hbmessagebox.h>

#include <hbnotificationdialog.h>

#include <shareuidialog.h>

#include "cxeviewfindercontrol.h"

#include "cxuienums.h"

#include "cxuipostcaptureview.h"

#include "cxeengine.h"

#include "cxecameradevicecontrol.h"

#include "cxestillcapturecontrol.h"

#include "cxeviewfindercontrol.h"

#include "cxevideocapturecontrol.h"

#include "cxestillimage.h"

#include "cxutils.h"

#include "cxefeaturemanager.h"

#include "cxuidocumentloader.h"

#include "cxesettings.h"

#include "cxenamespace.h"

#include "cxuiserviceprovider.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cxuipostcaptureviewTraces.h"

#endif

using namespace CxUiLayout;

using namespace Cxe;

// CONSTANTS

const int CXUI_HIDE_CONTROLS_TIMEOUT = 6000; // 6 seconds

const QString PhotosAppExe = "photos.exe";

const QString VideosAppExe = "videoplayer.exe";

//!@todo Temporarily disabled.

//const int CXUI_STOP_VIEWFINDER_TIMEOUT = 5000; // 5 seconds

//const int CXUI_RELEASE_CAMERA_TIMEOUT = 10000; // 10 seconds

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

// CxuiPostcaptureView::CxuiPostcaptureView

//

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

//

CxuiPostcaptureView::CxuiPostcaptureView(QGraphicsItem *parent) :

    HbView(parent),

    mMainWindow(NULL),

    mEngine(NULL),

    mStillToolbar(NULL),

    mVideoToolbar(NULL),

    mEmbeddedToolbar(NULL),

    mBackgroundItem(NULL),

    mImageLabel(NULL),

    mHideControlsTimeout(this),

    mStopViewfinderTimer(this),

    mReleaseCameraTimer(this),

    mPostcaptureTimer(this),

    mTimersStarted(false)

{

    CX_DEBUG_IN_FUNCTION();

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPostcaptureView::~CxuiPostcaptureView

//

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

//

CxuiPostcaptureView::~CxuiPostcaptureView()

{

    CX_DEBUG_ENTER_FUNCTION();

    QCoreApplication::instance()->removeEventFilter(this);

    stopTimers();

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPostcaptureView::construct

//

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

//

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

                                    CxuiDocumentLoader *documentLoader)

{

    CX_DEBUG_ENTER_FUNCTION();

    mMainWindow = mainwindow;

    mEngine = engine;

    mDocumentLoader = documentLoader;

    // set back action to go back to pre-capture

    HbAction *backAction = new HbAction(Hb::BackNaviAction, this);

    connect(backAction, SIGNAL(triggered()), this, SLOT(goToPrecaptureView()));

    setNavigationAction(backAction);

    // creates black background item

    createBackground();

    CX_DEBUG_ASSERT(mDocumentLoader);

    QGraphicsWidget *widget = 0;

    widget = mDocumentLoader->findWidget(POST_CAPTURE_SNAPSHOT_LABEL);

    mImageLabel = qobject_cast<HbLabel *>(widget);

    CX_DEBUG_ASSERT(mImageLabel);

    // get toolbar pointers from the documentloader

    widget = mDocumentLoader->findWidget(STILL_POST_CAPTURE_TOOLBAR);

    mStillToolbar = qobject_cast<HbToolBar *> (widget);

    CX_DEBUG_ASSERT(mStillToolbar);

    widget = mDocumentLoader->findWidget(VIDEO_POST_CAPTURE_TOOLBAR);

    mVideoToolbar = qobject_cast<HbToolBar *> (widget);

    CX_DEBUG_ASSERT(mVideoToolbar);

    widget = mDocumentLoader->findWidget(EMBEDDED_POST_CAPTURE_TOOLBAR);

    mEmbeddedToolbar = qobject_cast<HbToolBar *> (widget);

    CX_DEBUG_ASSERT(mEmbeddedToolbar);

    mStopViewfinderTimer.setSingleShot(true);

    connect(&mStopViewfinderTimer, SIGNAL(timeout()),

            this, SLOT(stopViewfinder()));

    mReleaseCameraTimer.setSingleShot(true);

    connect(&mReleaseCameraTimer, SIGNAL(timeout()),

            this, SLOT(releaseCamera()));

    mHideControlsTimeout.setSingleShot(true);

    connect(&mHideControlsTimeout, SIGNAL(timeout()),

            this, SLOT(hideControls()));

    mPostcaptureTimer.setSingleShot(true);

    connect(&mPostcaptureTimer, SIGNAL(timeout()),

            this, SLOT(goToPrecaptureView()));

    // set focus flags

    setFlag(QGraphicsItem::ItemIsFocusable);

    setFocusPolicy(Qt::StrongFocus);

    QCoreApplication::instance()->installEventFilter(this);

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPostcaptureView::handleCaptureKeyPressed

//

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

//

void CxuiPostcaptureView::handleCaptureKeyPressed()

{

    CX_DEBUG_ENTER_FUNCTION();

    goToPrecaptureView();

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPostcaptureView::handleAutofocusKeyPressed

//

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

//

void CxuiPostcaptureView::handleAutofocusKeyPressed()

{

    CX_DEBUG_ENTER_FUNCTION();

    goToPrecaptureView();

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

    Slot for starting video playing.

 */

void CxuiPostcaptureView::playVideo()

{

    launchNotSupportedNotification();

    //! @todo needs an implementation

    CX_DEBUG_IN_FUNCTION();

}

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

// CxuiPostcaptureView::showDeleteNote

//

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

//

void CxuiPostcaptureView::showDeleteNote()

{

    CX_DEBUG_ENTER_FUNCTION();

    QString filename = getCurrentFilename();

    bool ret = false;

    hideControls();

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

        ret = HbMessageBox::question(hbTrId("txt_cam_other_delete_video_clip"));

    } else {

        ret = HbMessageBox::question(hbTrId("txt_cam_other_delete_image"));

    }

    if (ret) {

        QFileInfo fileInfo(filename);

        if (fileInfo.exists()) {

            //! @todo

            // We can retry deletion if file deletion does'nt succeed,

            // but this is left out for the time being since the user

            // can't delete it so early that it's not saved yet or

            // is being harvested by MdS etc.

            QDir dir = fileInfo.absolutePath();

            bool ok = dir.remove(fileInfo.fileName());

            CX_DEBUG(("Delete file [%s], status %d", fileInfo.fileName().toAscii().constData(), ok));

            // Go back to precapture view

            goToPrecaptureView();

        }

    }

        CX_DEBUG_EXIT_FUNCTION();

}

/*!

    Slot for handling image/video sharing.

 */

void CxuiPostcaptureView::launchShare()

{

    CX_DEBUG_ENTER_FUNCTION();

    stopTimers();

    stopViewfinder();

    releaseCamera();

    QString filename = getCurrentFilename();

    QVariantList filelist;

    filelist.append(QVariant(filename));

    ShareUi dialog;

    dialog.init(filelist, true);

    showControls();

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPostcaptureView::goToPrecaptureView

//

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

//

void CxuiPostcaptureView::goToPrecaptureView()

{

    CX_DEBUG_ENTER_FUNCTION();

    // Cannot return to post-capture while stopping in video mode

    if (mEngine->mode() != Cxe::VideoMode ||

        mEngine->videoCaptureControl().state() != CxeVideoCaptureControl::Stopping) {

        stopTimers();

        // Make sure engine prepares for new image/video if necessary

        mEngine->initMode(mEngine->mode());

        // enables starting of timers in postcaptureview

        mTimersStarted = false;

        // Switch to pre-capture view

        emit changeToPrecaptureView();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPostcaptureView::stopViewfinder

//

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

//

void CxuiPostcaptureView::stopViewfinder()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (mMainWindow->currentView() == this) {

        mEngine->viewfinderControl().stop();

    }

    mStopViewfinderTimer.stop();

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPostcaptureView::releaseCamera

//

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

//

void CxuiPostcaptureView::releaseCamera()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (mMainWindow->currentView() == this) {

        mEngine->cameraDeviceControl().release();

    }

    mReleaseCameraTimer.stop();

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPostcaptureView::hideControls

//

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

//

void CxuiPostcaptureView::hideControls()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (mStillToolbar) {

        mStillToolbar->hide();

    }

    if (mVideoToolbar) {

        mVideoToolbar->hide();

    }

    if (mEmbeddedToolbar) {

        mEmbeddedToolbar->hide();

    }

    hideItems(Hb::AllItems);

    mControlsVisible = false;

    // stop hiding control timer

    mHideControlsTimeout.stop();

    // give the keyboard focus back to the view

    // for the view to receive key events

    setFocus();

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPostcaptureView::showControls

//

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

//

void CxuiPostcaptureView::showControls()

{

    CX_DEBUG_ENTER_FUNCTION();

    showToolbar();

    showItems(Hb::AllItems);

    mHideControlsTimeout.start(CXUI_HIDE_CONTROLS_TIMEOUT);

    mControlsVisible = true;

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPostcaptureView::toggleControls

//

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

//

void CxuiPostcaptureView::toggleControls()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (mControlsVisible) {

        hideControls();

    } else {

        showControls();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPostcaptureView::eventFilter

//

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

//

bool CxuiPostcaptureView::eventFilter(QObject *object, QEvent *event)

{

    Q_UNUSED(object)

    bool eventWasConsumed = false;

    switch (event->type())

    {

    case QEvent::GraphicsSceneMouseRelease:

        mHideControlsTimeout.start();

        break;

    case QEvent::GraphicsSceneMousePress:

        mHideControlsTimeout.stop();

        // stop the postcapture timer

        mPostcaptureTimer.stop();

        break;

    default:

        break;

    }

    return eventWasConsumed;

}

/*!

* Paint event.

* Used for performance tracing (snapshot latency).

*/

bool CxuiPostcaptureView::event(QEvent *event)

{

    bool processed(HbView::event(event));

    if (event && event->type() == QEvent::Paint) {

        OstTrace0(camerax_performance, CXUIPOSTCAPTUREVIEW_SNAPSHOT_DRAW, "msg: e_CX_SHOT_TO_SNAPSHOT 0");

    }

    return processed;

}

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

// CxuiPostcaptureView::mousePressEvent

//

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

//

void CxuiPostcaptureView::mousePressEvent(QGraphicsSceneMouseEvent *event)

{

    if (event->type() == QEvent::GraphicsSceneMousePress) {

        mPostcaptureTimer.stop();

        toggleControls();

        event->accept();

    }

}

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

// CxuiPostcaptureView::showEvent

//

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

//

void CxuiPostcaptureView::showEvent(QShowEvent *event)

{

    CX_DEBUG_ENTER_FUNCTION();

    QGraphicsWidget::showEvent(event);

    if (event->type() == QEvent::Show) {

        QCoreApplication::instance()->installEventFilter(this);

        updateSnapshotImage();

        showControls();

        startTimers();

        event->accept();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPostcaptureView::hideEvent

//

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

//

void CxuiPostcaptureView::hideEvent(QHideEvent *event)

{

    CX_DEBUG_ENTER_FUNCTION();

    QGraphicsWidget::hideEvent(event);

    if (event->type() == QEvent::Hide) {

        // remove event filter to disable unnecessary actions

        QCoreApplication::instance()->removeEventFilter(this);

        stopTimers();

        // Hide controls to make sure title bar reacts to show()

        // when this view is reactivated.

        hideControls();

        event->accept();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*! Shows toolbar.

    Toolbar that is shown is selected based on current mode.

 */

void CxuiPostcaptureView::showToolbar(){

    CX_DEBUG_ENTER_FUNCTION();

    if (CxuiServiceProvider::isCameraEmbedded()) {

        mEmbeddedToolbar->setVisible(true);

        mStillToolbar->setVisible(false);

        mVideoToolbar->setVisible(false);

    } else {

        mEmbeddedToolbar->setVisible(false);

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

            mVideoToolbar->setVisible(false);