diff -r 3075d9b614e6 -r 0e652f8f1fbd camerauis/cameraxui/cxui/src/cxuipostcaptureview.cpp --- a/camerauis/cameraxui/cxui/src/cxuipostcaptureview.cpp Thu May 13 21:30:19 2010 +0300 +++ b/camerauis/cameraxui/cxui/src/cxuipostcaptureview.cpp Thu Jul 15 01:55:05 2010 +0300 @@ -1,5 +1,5 @@ /* -* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). +* 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" @@ -17,7 +17,6 @@ #include #include #include -#include #include #include #include @@ -30,9 +29,10 @@ #include #include #include -#include +#include #include +#include #include "cxeviewfindercontrol.h" #include "cxuienums.h" @@ -40,7 +40,6 @@ #include "cxeengine.h" #include "cxecameradevicecontrol.h" #include "cxestillcapturecontrol.h" -#include "cxeviewfindercontrol.h" #include "cxevideocapturecontrol.h" #include "cxestillimage.h" #include "cxutils.h" @@ -50,75 +49,74 @@ #include "cxenamespace.h" #include "cxuiserviceprovider.h" +#ifdef Q_OS_SYMBIAN #include "OstTraceDefinitions.h" #ifdef OST_TRACE_COMPILER_IN_USE #include "cxuipostcaptureviewTraces.h" #endif +#endif //Q_OS_SYMBIAN 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 +namespace { + const QString FILENAME_KEY = "filename"; + const int CXUI_STOP_VIEWFINDER_TIMEOUT = 5000; // 5 seconds + const int CXUI_RELEASE_CAMERA_TIMEOUT = 60000; // 60 seconds +} -// --------------------------------------------------------------------------- -// CxuiPostcaptureView::CxuiPostcaptureView -// -// --------------------------------------------------------------------------- -// + +/*! +* Constructor. +*/ CxuiPostcaptureView::CxuiPostcaptureView(QGraphicsItem *parent) : - HbView(parent), - mMainWindow(NULL), - mEngine(NULL), + CxuiView(parent), mStillToolbar(NULL), mVideoToolbar(NULL), mEmbeddedToolbar(NULL), mBackgroundItem(NULL), mImageLabel(NULL), - mHideControlsTimeout(this), + mShareUi(NULL), mStopViewfinderTimer(this), mReleaseCameraTimer(this), mPostcaptureTimer(this), - mTimersStarted(false) + mTimersStarted(false), + mDeleteNoteOpen(false), + mFilename(QString::null), + mThumbnailManager(NULL) { CX_DEBUG_IN_FUNCTION(); CX_DEBUG_EXIT_FUNCTION(); } -// --------------------------------------------------------------------------- -// CxuiPostcaptureView::~CxuiPostcaptureView -// -// --------------------------------------------------------------------------- -// +/*! +* Destructor. +*/ CxuiPostcaptureView::~CxuiPostcaptureView() { CX_DEBUG_ENTER_FUNCTION(); QCoreApplication::instance()->removeEventFilter(this); stopTimers(); + delete mThumbnailManager; + delete mShareUi; CX_DEBUG_EXIT_FUNCTION(); } -// --------------------------------------------------------------------------- -// CxuiPostcaptureView::construct -// -// --------------------------------------------------------------------------- -// +/*! +* Second phase construction. +*/ void CxuiPostcaptureView::construct(HbMainWindow *mainwindow, CxeEngine *engine, - CxuiDocumentLoader *documentLoader) + CxuiDocumentLoader *documentLoader, + CxuiCaptureKeyHandler *keyHandler, + HbActivityManager *activityManager) { + Q_UNUSED(keyHandler); CX_DEBUG_ENTER_FUNCTION(); - mMainWindow = mainwindow; - mEngine = engine; - mDocumentLoader = documentLoader; + CxuiView::construct(mainwindow, engine, documentLoader, NULL, activityManager); // set back action to go back to pre-capture HbAction *backAction = new HbAction(Hb::BackNaviAction, this); @@ -134,6 +132,8 @@ mImageLabel = qobject_cast(widget); CX_DEBUG_ASSERT(mImageLabel); + mShareUi = new ShareUi(); + // get toolbar pointers from the documentloader widget = mDocumentLoader->findWidget(STILL_POST_CAPTURE_TOOLBAR); // This resize is a workaround to get toolbar shown correctly. @@ -177,30 +177,30 @@ CX_DEBUG_EXIT_FUNCTION(); } -// --------------------------------------------------------------------------- -// CxuiPostcaptureView::handleCaptureKeyPressed -// -// --------------------------------------------------------------------------- -// +/*! +* Handle pressing capture key. +*/ void CxuiPostcaptureView::handleCaptureKeyPressed() { CX_DEBUG_ENTER_FUNCTION(); - goToPrecaptureView(); + if (!mDeleteNoteOpen) { + goToPrecaptureView(); + } CX_DEBUG_EXIT_FUNCTION(); } -// --------------------------------------------------------------------------- -// CxuiPostcaptureView::handleAutofocusKeyPressed -// -// --------------------------------------------------------------------------- -// +/*! +* Handle pressing auto focus key. +*/ void CxuiPostcaptureView::handleAutofocusKeyPressed() { CX_DEBUG_ENTER_FUNCTION(); - goToPrecaptureView(); + if (!mDeleteNoteOpen) { + goToPrecaptureView(); + } CX_DEBUG_EXIT_FUNCTION(); } @@ -210,53 +210,74 @@ */ void CxuiPostcaptureView::playVideo() { + CX_DEBUG_ENTER_FUNCTION(); - launchNotSupportedNotification(); - //! @todo needs an implementation - CX_DEBUG_IN_FUNCTION(); + stopTimers(); + releaseCamera(); + + QString videoFile(getCurrentFilename()); + + XQAiwRequest *videoRequest = mAppManager.create( + "com.nokia.symbian.IVideoView","playMedia(QString)", true); + + if (videoRequest) { + QVariantList fileList; + fileList.append(QVariant(videoFile)); + videoRequest->setArguments(fileList); + + CX_DEBUG(("CxuiPostcaptureView: sending request")); + QVariant result; + bool res = videoRequest->send(result); + if (res) { + CX_DEBUG(("CxuiPostcaptureView: request sent, received \"%s\"", + result.toString().toAscii().constData())); + } else { + CX_DEBUG(("CxuiPostcaptureView: request sending failed, error=%d", + videoRequest->lastError())); + } + delete videoRequest; + videoRequest = NULL; + } + + CX_DEBUG_EXIT_FUNCTION(); } -// --------------------------------------------------------------------------- -// CxuiPostcaptureView::showDeleteNote -// -// --------------------------------------------------------------------------- -// +/*! +* Show delete query. +*/ void CxuiPostcaptureView::showDeleteNote() { CX_DEBUG_ENTER_FUNCTION(); hideControls(); - if (mEngine->mode() == Cxe::VideoMode) { - HbMessageBox::question(hbTrId("txt_cam_other_delete_video_clip"), - this, - SLOT(handleDeleteDialogClosed(HbAction*))); - } else { - HbMessageBox::question(hbTrId("txt_cam_other_delete_image"), - this, - SLOT(handleDeleteDialogClosed(HbAction*))); - } + QString text(mEngine->mode() == Cxe::VideoMode + ? hbTrId("txt_cam_other_delete_video_clip") + : hbTrId("txt_cam_other_delete_image")); + HbMessageBox::question(text, + this, + SLOT(handleDeleteDialogClosed(int)), + HbMessageBox::Yes | HbMessageBox::No); + + mDeleteNoteOpen = true; CX_DEBUG_EXIT_FUNCTION(); } -// --------------------------------------------------------------------------- -// CxuiPostcaptureView::handleDeleteDialogClosed -// -// --------------------------------------------------------------------------- -// -void CxuiPostcaptureView::handleDeleteDialogClosed(HbAction *action) +/*! +* Handle closing delete query dialog. +* @param action HbMessageBox::Yes if user accepted the delete query, HbMessageBox::No if not. +*/ +void CxuiPostcaptureView::handleDeleteDialogClosed(int action) { CX_DEBUG_ENTER_FUNCTION(); hideControls(); - - HbMessageBox *dlg = qobject_cast(sender()); + mDeleteNoteOpen = false; - // check that it was "primary action" that closed the dialog - if (dlg && dlg->actions().at(0) == action) { - // User confirmed delete + // Check that user confirmed delete + if (action == HbMessageBox::Yes) { QString filename = getCurrentFilename(); QFileInfo fileInfo(filename); if (fileInfo.exists()) { @@ -267,7 +288,7 @@ // 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)); + CX_DEBUG(("Delete file [%s], status %d", qPrintable(fileInfo.fileName()), ok)); // Go back to precapture view goToPrecaptureView(); @@ -287,25 +308,19 @@ stopTimers(); releaseCamera(); - + hideControls(); QString filename = getCurrentFilename(); - QStringList filelist; filelist.append(filename); - ShareUi dialog; - dialog.send(filelist, true); - - showControls(); + mShareUi->send(filelist, true); CX_DEBUG_EXIT_FUNCTION(); } -// --------------------------------------------------------------------------- -// CxuiPostcaptureView::goToPrecaptureView -// -// --------------------------------------------------------------------------- -// +/*! +* Go to pre-capture view. +*/ void CxuiPostcaptureView::goToPrecaptureView() { CX_DEBUG_ENTER_FUNCTION(); @@ -317,8 +332,8 @@ // Re-enabling starting timers the next time we enter post capture view. mTimersStarted = false; - // Make sure engine prepares for new image/video if necessary - mEngine->initMode(mEngine->mode()); + // reset saved filename + mFilename = QString::null; // Switch to pre-capture view emit changeToPrecaptureView(); @@ -327,11 +342,9 @@ CX_DEBUG_EXIT_FUNCTION(); } -// --------------------------------------------------------------------------- -// CxuiPostcaptureView::stopViewfinder -// -// --------------------------------------------------------------------------- -// +/*! +* Stop viewfinder. +*/ void CxuiPostcaptureView::stopViewfinder() { CX_DEBUG_ENTER_FUNCTION(); @@ -344,32 +357,12 @@ CX_DEBUG_EXIT_FUNCTION(); } -// --------------------------------------------------------------------------- -// CxuiPostcaptureView::releaseCamera -// -// --------------------------------------------------------------------------- -// -void CxuiPostcaptureView::releaseCamera() +/*! +* Hides toolbar. +*/ +void CxuiPostcaptureView::hideToolbar() { 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(); } @@ -379,64 +372,13 @@ 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 -// -// --------------------------------------------------------------------------- -// +/*! +* Handle events. +* Needed for restarting timers. +*/ bool CxuiPostcaptureView::eventFilter(QObject *object, QEvent *event) { Q_UNUSED(object) @@ -465,31 +407,73 @@ */ void CxuiPostcaptureView::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { - OstTrace0(camerax_performance, CXUIPOSTCAPTUREVIEW_SNAPSHOT_DRAW, "msg: e_CX_SHOT_TO_SNAPSHOT 0"); - QGraphicsWidget::paint(painter, option, widget); + OstTrace0(camerax_performance, CXUIPOSTCAPTUREVIEW_SNAPSHOT_DRAW, "msg: e_CX_SHOT_TO_SNAPSHOT 0"); + QGraphicsWidget::paint(painter, option, widget); +} + +/*! + * Restore view state from activity. + * @param activityId Activity id + * @param data Activity data + */ +void CxuiPostcaptureView::restoreActivity(const QString &activityId, const QVariant &data) +{ + Q_UNUSED(activityId); + CX_DEBUG_ENTER_FUNCTION(); + + // get filename. if filename is not found (toString() returns empty string) + // we will go back to pre-capture in updateSnapshotImage() + mFilename = data.toMap()[FILENAME_KEY].toString(); + CX_DEBUG(("Got filename %s from activity", mFilename.toAscii().data())); + + CX_DEBUG_EXIT_FUNCTION(); } -// --------------------------------------------------------------------------- -// CxuiPostcaptureView::mousePressEvent -// -// --------------------------------------------------------------------------- -// -void CxuiPostcaptureView::mousePressEvent(QGraphicsSceneMouseEvent *event) +/*! + * Save view state to activity. + */ +void CxuiPostcaptureView::saveActivity() { - //! @todo temporary workaround for title bar mouse event handling bug - if (event->type() == QEvent::GraphicsSceneMousePress && event->scenePos().y() > 70) { - mPostcaptureTimer.stop(); - toggleControls(); - event->accept(); + CX_DEBUG_ENTER_FUNCTION(); + QVariantMap data; + QVariantHash params; + + QString filename = getCurrentFilename(); + CX_DEBUG(("Saving filename %s", filename.toAscii().data())); + data.insert(FILENAME_KEY, filename); + + QImage img(mMainWindow->rect().size(), QImage::Format_ARGB32_Premultiplied); + QPainter p(&img); + mMainWindow->render(&p, mMainWindow->rect(), mMainWindow->rect()); + + QPixmap screenshot = QPixmap::fromImage(img); + + params.insert("screenshot", screenshot); + if (mEngine->mode() == Cxe::ImageMode) { + mActivityManager->removeActivity(CxuiActivityIds::STILL_POSTCAPTURE_ACTIVITY); + mActivityManager->addActivity(CxuiActivityIds::STILL_POSTCAPTURE_ACTIVITY, data, params); + } else { + mActivityManager->removeActivity(CxuiActivityIds::VIDEO_POSTCAPTURE_ACTIVITY); + mActivityManager->addActivity(CxuiActivityIds::VIDEO_POSTCAPTURE_ACTIVITY, data, params); } - + CX_DEBUG_EXIT_FUNCTION(); } -// --------------------------------------------------------------------------- -// CxuiPostcaptureView::showEvent -// -// --------------------------------------------------------------------------- -// +/*! + * Clear activity from activity manager. + */ +void CxuiPostcaptureView::clearActivity() +{ + CX_DEBUG_ENTER_FUNCTION(); + mActivityManager->removeActivity(CxuiActivityIds::STILL_POSTCAPTURE_ACTIVITY); + mActivityManager->removeActivity(CxuiActivityIds::VIDEO_POSTCAPTURE_ACTIVITY); + CX_DEBUG_EXIT_FUNCTION(); +} + +/*! +* Show event for this view. +* Update snapshot and start timers. +*/ void CxuiPostcaptureView::showEvent(QShowEvent *event) { CX_DEBUG_ENTER_FUNCTION(); @@ -508,11 +492,10 @@ CX_DEBUG_EXIT_FUNCTION(); } -// --------------------------------------------------------------------------- -// CxuiPostcaptureView::hideEvent -// -// --------------------------------------------------------------------------- -// +/*! +* Hide event. +* Release snapshot and stop timers. +*/ void CxuiPostcaptureView::hideEvent(QHideEvent *event) { CX_DEBUG_ENTER_FUNCTION(); @@ -581,41 +564,50 @@ CX_DEBUG_EXIT_FUNCTION(); } -// --------------------------------------------------------------------------- -// CxuiPostcaptureView::setImage -// -// --------------------------------------------------------------------------- -// +/*! + * Updates snapshot image. In normal case snapshot is retrieved from engine + * but if we are restoring camera to post-capture through activity, then + * we get snapshot from thumbnail manager. + */ void CxuiPostcaptureView::updateSnapshotImage() { CX_DEBUG_ENTER_FUNCTION(); - QPixmap snapshot; + if (!mFilename.isNull()) { + CX_DEBUG(("CxuiPostcaptureView::updateSnapshot restoring activity")); + // filename set, we are restoring activity + if (QFile::exists(mFilename)) { + CX_DEBUG(("Filename ok, requesting thumbnail from TNM")); + if (!mThumbnailManager) { + mThumbnailManager = new ThumbnailManager(); + connect(mThumbnailManager, SIGNAL(thumbnailReady(QPixmap, void *, int, int)), + this, SLOT(handleThumbnailReady(QPixmap, void*, int, int))); + mThumbnailManager->setThumbnailSize(ThumbnailManager::ThumbnailLarge); + } + mThumbnailManager->getThumbnail(mFilename); + CX_DEBUG(("Thumbnail requested")); - if (mEngine->mode() == ImageMode) { - if( mEngine->stillCaptureControl().imageCount() > 0 ) { - snapshot = mEngine->stillCaptureControl()[0].snapshot(); + } else { + // file deleted + CX_DEBUG(("File %s has been deleted, going back to pre-capture", mFilename.toAscii().data())); + goToPrecaptureView(); } } else { - snapshot = mEngine->videoCaptureControl().snapshot(); + 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 + } } - 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(); - HbNotificationDialog::launchDialog("Notification", "Not supported yet"); CX_DEBUG_EXIT_FUNCTION(); } @@ -626,6 +618,15 @@ { CX_DEBUG_ENTER_FUNCTION(); + if (!mFilename.isNull()) { + // post-capture started by activity, engine doesn't contain correct + // filename anymore so use the stored one + CX_DEBUG(("Using filename saved in activity")); + CX_DEBUG_EXIT_FUNCTION(); + return mFilename; + } + + CX_DEBUG(("Getting filename from engine")); QString filename; if (mEngine->mode() == Cxe::VideoMode) { @@ -645,14 +646,6 @@ } /*! - 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() @@ -667,71 +660,126 @@ } /*! - Launches the Videos applications as a separate process +* Handle exiting standby. */ -void CxuiPostcaptureView::launchVideosApp() +void CxuiPostcaptureView::exitStandby() { - //Releasing cameda device in order to free - //graphical memory - releaseCamera(); - QProcess::startDetached(VideosAppExe); + CX_DEBUG_ENTER_FUNCTION(); + + // Common functionality first. + CxuiView::exitStandby(); + + //!@note We should not start timers until we receive the ShowEvent + showControls(); + + CX_DEBUG_EXIT_FUNCTION(); } /*! - Handle cases when we loose focus +* Handle entering standby. */ -void CxuiPostcaptureView::handleFocusLost() +void CxuiPostcaptureView::enterStandby() { CX_DEBUG_ENTER_FUNCTION(); - // we have lost focus - releaseCamera(); + // Common functionality (release camera). + CxuiView::enterStandby(); + stopTimers(); hideControls(); CX_DEBUG_EXIT_FUNCTION(); } +/*! + * Handle thumbnail received from ThumbnailManager. + * + * @param thumbnail Thumbnail as QPixmap + * @param clientData Not used + * @param id Thumbnail manager request id + * @param errorCode Error code + */ +void CxuiPostcaptureView::handleThumbnailReady(QPixmap thumbnail, void *clientData, int id, int errorCode) +{ + CX_DEBUG_ENTER_FUNCTION(); + Q_UNUSED(clientData); + Q_UNUSED(id); + + if (thumbnail.isNull()) { + CX_DEBUG(("Received null thumbnail from TNM, going to pre-capture. Error=%d", errorCode)); + // null thumbnail, go to precapture + goToPrecaptureView(); + } else if (mImageLabel) { + mImageLabel->setIcon(HbIcon(QIcon(thumbnail))); + } + + CX_DEBUG_EXIT_FUNCTION(); +} + +/*! + Start the timers +*/ 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 + if(!mTimersStarted) { + startPostcaptureTimer(); + startReleaseTimers(); mTimersStarted = true; } - // show controls when we get back focus - showControls(); + CX_DEBUG_EXIT_FUNCTION(); +} + +/*! + Start the timer to return to pre-capture view +*/ +void CxuiPostcaptureView::startPostcaptureTimer() +{ + CX_DEBUG_ENTER_FUNCTION(); + + if (!mFilename.isNull()) { + // restored from activity, don't do post-capture timeout + CX_DEBUG_EXIT_FUNCTION(); + return; + } + + 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 + } + } + + CX_DEBUG_EXIT_FUNCTION(); +} + +/*! + Start the timers to stop viewfinder and release the camera +*/ +void CxuiPostcaptureView::startReleaseTimers() +{ + CX_DEBUG_ENTER_FUNCTION(); + + // Release camera and stop viewfinder if user stays in postcapture long enough. + // Battery could otherwise drain fast. + mReleaseCameraTimer.start(CXUI_RELEASE_CAMERA_TIMEOUT); + mStopViewfinderTimer.start(CXUI_STOP_VIEWFINDER_TIMEOUT); CX_DEBUG_EXIT_FUNCTION(); } @@ -746,7 +794,7 @@ mPostcaptureTimer.stop(); mStopViewfinderTimer.stop(); - // Note: mTimersStarted is intentionally not reset here. + //!@note mTimersStarted is intentionally not reset here. // Once the timers are stopped, they are not to be started again until // we come from precapture view again. // E.g. returning from background could otherwise restart the timers and