diff -r 8b2d6d0384b0 -r d9aefe59d544 camerauis/cameraxui/cxui/src/cxuipostcaptureview.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/camerauis/cameraxui/cxui/src/cxuipostcaptureview.cpp Fri Apr 16 14:51:30 2010 +0300 @@ -0,0 +1,735 @@ +/* +* 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include + +#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(widget); + CX_DEBUG_ASSERT(mImageLabel); + + // get toolbar pointers from the documentloader + widget = mDocumentLoader->findWidget(STILL_POST_CAPTURE_TOOLBAR); + mStillToolbar = qobject_cast (widget); + CX_DEBUG_ASSERT(mStillToolbar); + + widget = mDocumentLoader->findWidget(VIDEO_POST_CAPTURE_TOOLBAR); + mVideoToolbar = qobject_cast (widget); + CX_DEBUG_ASSERT(mVideoToolbar); + + widget = mDocumentLoader->findWidget(EMBEDDED_POST_CAPTURE_TOOLBAR); + mEmbeddedToolbar = qobject_cast (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); + mStillToolbar->setVisible(true); + mStillToolbar->show(); + } else { + mStillToolbar->setVisible(false); + mVideoToolbar->setVisible(true); + mVideoToolbar->show(); + } + } + + CX_DEBUG_EXIT_FUNCTION(); +} + +/*! + Creates black background item. If snapshot smaller than the screen size, + background is visible. + */ +void CxuiPostcaptureView::createBackground() +{ + CX_DEBUG_ENTER_FUNCTION(); + + if (!mBackgroundItem) { + mBackgroundItem = new QGraphicsRectItem(this); + QBrush blackBrush = QBrush(Qt::black); + mBackgroundItem->setBrush(blackBrush); + mBackgroundItem->setRect(mMainWindow->sceneRect()); + } + + CX_DEBUG_EXIT_FUNCTION(); +} + +// --------------------------------------------------------------------------- +// CxuiPostcaptureView::setImage +// +// --------------------------------------------------------------------------- +// +void CxuiPostcaptureView::updateSnapshotImage() +{ + CX_DEBUG_ENTER_FUNCTION(); + + QPixmap snapshot; + + if (mEngine->mode() == ImageMode) { + if( mEngine->stillCaptureControl().imageCount() > 0 ) { + snapshot = mEngine->stillCaptureControl()[0].snapshot(); + } + } else { + snapshot = mEngine->videoCaptureControl().snapshot(); + } + + if (mImageLabel) { + mImageLabel->setIcon(HbIcon(QIcon(snapshot))); + } else { + // do nothing + } + + CX_DEBUG_EXIT_FUNCTION(); +} + +/*! + Launches "Not supported yet" notification. + */ +void CxuiPostcaptureView::launchNotSupportedNotification() +{ + CX_DEBUG_ENTER_FUNCTION(); + + // Instantiate a popup + HbNotificationDialog note; + note.setTitle("Notification"); + note.setText("Not supported yet"); + note.exec(); + + CX_DEBUG_EXIT_FUNCTION(); +} + +/* ! + * gets the filename of the current file + */ +QString CxuiPostcaptureView::getCurrentFilename() +{ + CX_DEBUG_ENTER_FUNCTION(); + + QString filename; + + if (mEngine->mode() == Cxe::VideoMode) { + filename = mEngine->videoCaptureControl().filename(); + } else { + //!@todo Currently only gets index 0 from the still capture control. + CxeStillCaptureControl& stillCaptureControl = mEngine->stillCaptureControl(); + if (stillCaptureControl.imageCount()) { + filename = stillCaptureControl[0].filename(); + } + } + CX_DEBUG((filename.toAscii())); + + CX_DEBUG_EXIT_FUNCTION(); + + return filename; +} + +/*! + Launches the Photos applications as a separate process +*/ +void CxuiPostcaptureView::launchPhotosApp() +{ + QProcess::startDetached(PhotosAppExe); +} + +/*! + Sends current capture to client app and closes camera +*/ +void CxuiPostcaptureView::select() +{ + CxuiServiceProvider *serviceProvider = CxuiServiceProvider::instance(); + if (!serviceProvider) { + return; + } + + QString filename = getCurrentFilename(); + serviceProvider->sendFilenameToClientAndExit(filename); +} + +/*! + Launches the Videos applications as a separate process +*/ +void CxuiPostcaptureView::launchVideosApp() +{ + //Releasing cameda device in order to free + //graphical memory + releaseCamera(); + QProcess::startDetached(VideosAppExe); +} + +/*! + Handle cases when we loose focus +*/ +void CxuiPostcaptureView::handleFocusLost() +{ + CX_DEBUG_ENTER_FUNCTION(); + + // we have lost focus + releaseCamera(); + stopTimers(); + hideControls(); + + CX_DEBUG_EXIT_FUNCTION(); +} + + +void CxuiPostcaptureView::startTimers() +{ + CX_DEBUG_ENTER_FUNCTION(); + + // we start timers only once in a given postcapture view session + if (!mTimersStarted) { + int postCaptureTimeout = 0; + QString settingId; + + if (mEngine->mode() == ImageMode) { + settingId = CxeSettingIds::STILL_SHOWCAPTURED; + } else { + settingId = CxeSettingIds::VIDEO_SHOWCAPTURED; + } + + if (!CxuiServiceProvider::isCameraEmbedded()) { + CxeError::Id err = mEngine->settings().get(settingId, postCaptureTimeout); + + if (postCaptureTimeout > 0 && err == CxeError::None) { + mPostcaptureTimer.start(postCaptureTimeout); + } else { + // do nothing + } + } + + // start the hide control timer. + mHideControlsTimeout.start(CXUI_HIDE_CONTROLS_TIMEOUT); + + //! @todo Temporarily disabling release timer because of + // graphics memory problems related to releasing and reserving again. + // mReleaseCameraTimer.start(CXUI_RELEASE_CAMERA_TIMEOUT); + // mStopViewfinderTimer.start(CXUI_STOP_VIEWFINDER_TIMEOUT); + + // we make sure that timers are started only once in a given postcaptureview session + mTimersStarted = true; + } + + // show controls when we get back focus + showControls(); + + CX_DEBUG_EXIT_FUNCTION(); +} + +void CxuiPostcaptureView::stopTimers() +{ + CX_DEBUG_ENTER_FUNCTION(); + + // stop all the timers + mHideControlsTimeout.stop(); + mReleaseCameraTimer.stop(); + mPostcaptureTimer.stop(); + mStopViewfinderTimer.stop(); + + mTimersStarted = false; + + CX_DEBUG_EXIT_FUNCTION(); +} + +// end of file