1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 #include <QDebug>

    18 #include <QPixmap>

    19 #include <QTimer>

    20 #include <QGraphicsSceneEvent>

    21 #include <QFileInfo>

    22 #include <QApplication>

    23 #include <QGraphicsRectItem>

    24 #include <QBrush>

    25 #include <QDir>

    26 #include <QProcess>

    27 

    28 #include <hblabel.h>

    29 #include <hbmainwindow.h>

    30 #include <hbtoolbar.h>

    31 #include <hbaction.h>

    32 #include <hbmessagebox.h>

    33 #include <hbnotificationdialog.h>

    34 

    35 #include <shareuidialog.h>

    36 

    37 #include "cxeviewfindercontrol.h"

    38 #include "cxuienums.h"

    39 #include "cxuipostcaptureview.h"

    40 #include "cxeengine.h"

    41 #include "cxecameradevicecontrol.h"

    42 #include "cxestillcapturecontrol.h"

    43 #include "cxeviewfindercontrol.h"

    44 #include "cxevideocapturecontrol.h"

    45 #include "cxestillimage.h"

    46 #include "cxutils.h"

    47 #include "cxefeaturemanager.h"

    48 #include "cxuidocumentloader.h"

    49 #include "cxesettings.h"

    50 #include "cxenamespace.h"

    51 #include "cxuiserviceprovider.h"

    52 

    53 #include "OstTraceDefinitions.h"

    54 #ifdef OST_TRACE_COMPILER_IN_USE

    55 #include "cxuipostcaptureviewTraces.h"

    56 #endif

    57 

    58 

    59 using namespace CxUiLayout;

    60 using namespace Cxe;

    61 

    62 // CONSTANTS

    63 const int CXUI_HIDE_CONTROLS_TIMEOUT = 6000; // 6 seconds

    64 const QString PhotosAppExe = "photos.exe";

    65 const QString VideosAppExe = "videoplayer.exe";

    66 

    67 //!@todo Temporarily disabled.

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

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

    70 

    71 // ---------------------------------------------------------------------------

    72 // CxuiPostcaptureView::CxuiPostcaptureView

    73 //

    74 // ---------------------------------------------------------------------------

    75 //

    76 CxuiPostcaptureView::CxuiPostcaptureView(QGraphicsItem *parent) :

    77     HbView(parent),

    78     mMainWindow(NULL),

    79     mEngine(NULL),

    80     mStillToolbar(NULL),

    81     mVideoToolbar(NULL),

    82     mEmbeddedToolbar(NULL),

    83     mBackgroundItem(NULL),

    84     mImageLabel(NULL),

    85     mHideControlsTimeout(this),

    86     mStopViewfinderTimer(this),

    87     mReleaseCameraTimer(this),

    88     mPostcaptureTimer(this),

    89     mTimersStarted(false)

    90 {

    91     CX_DEBUG_IN_FUNCTION();

    92 

    93     CX_DEBUG_EXIT_FUNCTION();

    94 }

    95 

    96 // ---------------------------------------------------------------------------

    97 // CxuiPostcaptureView::~CxuiPostcaptureView

    98 //

    99 // ---------------------------------------------------------------------------

   100 //

   101 CxuiPostcaptureView::~CxuiPostcaptureView()

   102 {

   103     CX_DEBUG_ENTER_FUNCTION();

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

   105     stopTimers();

   106     CX_DEBUG_EXIT_FUNCTION();

   107 }

   108 

   109 // ---------------------------------------------------------------------------

   110 // CxuiPostcaptureView::construct

   111 //

   112 // ---------------------------------------------------------------------------

   113 //

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

   115                                     CxuiDocumentLoader *documentLoader)

   116 {

   117     CX_DEBUG_ENTER_FUNCTION();

   118 

   119     mMainWindow = mainwindow;

   120     mEngine = engine;

   121     mDocumentLoader = documentLoader;

   122 

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

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

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

   126     setNavigationAction(backAction);

   127 

   128     // creates black background item

   129     createBackground();

   130 

   131     CX_DEBUG_ASSERT(mDocumentLoader);

   132     QGraphicsWidget *widget = 0;

   133     widget = mDocumentLoader->findWidget(POST_CAPTURE_SNAPSHOT_LABEL);

   134     mImageLabel = qobject_cast<HbLabel *>(widget);

   135     CX_DEBUG_ASSERT(mImageLabel);

   136 

   137     // get toolbar pointers from the documentloader

   138     widget = mDocumentLoader->findWidget(STILL_POST_CAPTURE_TOOLBAR);

   139     mStillToolbar = qobject_cast<HbToolBar *> (widget);

   140     CX_DEBUG_ASSERT(mStillToolbar);

   141 

   142     widget = mDocumentLoader->findWidget(VIDEO_POST_CAPTURE_TOOLBAR);

   143     mVideoToolbar = qobject_cast<HbToolBar *> (widget);

   144     CX_DEBUG_ASSERT(mVideoToolbar);

   145 

   146     widget = mDocumentLoader->findWidget(EMBEDDED_POST_CAPTURE_TOOLBAR);

   147     mEmbeddedToolbar = qobject_cast<HbToolBar *> (widget);

   148     CX_DEBUG_ASSERT(mEmbeddedToolbar);

   149 

   150     mStopViewfinderTimer.setSingleShot(true);

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

   152             this, SLOT(stopViewfinder()));

   153 

   154     mReleaseCameraTimer.setSingleShot(true);

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

   156             this, SLOT(releaseCamera()));

   157 

   158     mHideControlsTimeout.setSingleShot(true);

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

   160             this, SLOT(hideControls()));

   161 

   162     mPostcaptureTimer.setSingleShot(true);

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

   164             this, SLOT(goToPrecaptureView()));

   165 

   166     // set focus flags

   167     setFlag(QGraphicsItem::ItemIsFocusable);

   168     setFocusPolicy(Qt::StrongFocus);

   169 

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

   171     CX_DEBUG_EXIT_FUNCTION();

   172 }

   173 

   174 // ---------------------------------------------------------------------------

   175 // CxuiPostcaptureView::handleCaptureKeyPressed

   176 //

   177 // ---------------------------------------------------------------------------

   178 //

   179 void CxuiPostcaptureView::handleCaptureKeyPressed()

   180 {

   181     CX_DEBUG_ENTER_FUNCTION();

   182 

   183     goToPrecaptureView();

   184 

   185     CX_DEBUG_EXIT_FUNCTION();

   186 }

   187 

   188 // ---------------------------------------------------------------------------

   189 // CxuiPostcaptureView::handleAutofocusKeyPressed

   190 //

   191 // ---------------------------------------------------------------------------

   192 //

   193 void CxuiPostcaptureView::handleAutofocusKeyPressed()

   194 {

   195     CX_DEBUG_ENTER_FUNCTION();

   196 

   197     goToPrecaptureView();

   198 

   199     CX_DEBUG_EXIT_FUNCTION();

   200 }

   201 

   202 /*!

   203     Slot for starting video playing.

   204  */

   205 void CxuiPostcaptureView::playVideo()

   206 {

   207     launchNotSupportedNotification();

   208     //! @todo needs an implementation

   209     CX_DEBUG_IN_FUNCTION();

   210 }

   211 

   212 // ---------------------------------------------------------------------------

   213 // CxuiPostcaptureView::showDeleteNote

   214 //

   215 // ---------------------------------------------------------------------------

   216 //

   217 void CxuiPostcaptureView::showDeleteNote()

   218 {

   219     CX_DEBUG_ENTER_FUNCTION();

   220 

   221     QString filename = getCurrentFilename();

   222     bool ret = false;

   223 

   224     hideControls();

   225 

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

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

   228     } else {

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

   230     }

   231 

   232     if (ret) {

   233         QFileInfo fileInfo(filename);

   234         if (fileInfo.exists()) {

   235             //! @todo

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

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

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

   239             // is being harvested by MdS etc.

   240             QDir dir = fileInfo.absolutePath();

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

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

   243 

   244             // Go back to precapture view

   245             goToPrecaptureView();

   246         }

   247     }

   248 

   249         CX_DEBUG_EXIT_FUNCTION();

   250 }

   251 

   252 

   253 

   254 /*!

   255     Slot for handling image/video sharing.

   256  */

   257 void CxuiPostcaptureView::launchShare()

   258 {

   259     CX_DEBUG_ENTER_FUNCTION();

   260     

   261     stopTimers();

   262     stopViewfinder();

   263     releaseCamera();

   264         

   265     QString filename = getCurrentFilename();

   266     

   267     QVariantList filelist;

   268     filelist.append(QVariant(filename));

   269     

   270     ShareUi dialog;

   271     dialog.init(filelist, true);

   272     

   273     showControls();

   274     

   275     CX_DEBUG_EXIT_FUNCTION();

   276 }

   277 

   278 // ---------------------------------------------------------------------------

   279 // CxuiPostcaptureView::goToPrecaptureView

   280 //

   281 // ---------------------------------------------------------------------------

   282 //

   283 void CxuiPostcaptureView::goToPrecaptureView()

   284 {

   285     CX_DEBUG_ENTER_FUNCTION();

   286 

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

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

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

   290         stopTimers();

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

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

   293 

   294         // enables starting of timers in postcaptureview

   295         mTimersStarted = false;

   296 

   297         // Switch to pre-capture view

   298         emit changeToPrecaptureView();

   299     }

   300 

   301     CX_DEBUG_EXIT_FUNCTION();

   302 }

   303 

   304 // ---------------------------------------------------------------------------

   305 // CxuiPostcaptureView::stopViewfinder

   306 //

   307 // ---------------------------------------------------------------------------

   308 //

   309 void CxuiPostcaptureView::stopViewfinder()

   310 {

   311     CX_DEBUG_ENTER_FUNCTION();

   312 

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

   314         mEngine->viewfinderControl().stop();

   315     }

   316     mStopViewfinderTimer.stop();

   317 

   318     CX_DEBUG_EXIT_FUNCTION();

   319 }

   320 

   321 // ---------------------------------------------------------------------------

   322 // CxuiPostcaptureView::releaseCamera

   323 //

   324 // ---------------------------------------------------------------------------

   325 //

   326 void CxuiPostcaptureView::releaseCamera()

   327 {

   328     CX_DEBUG_ENTER_FUNCTION();

   329 

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

   331         mEngine->cameraDeviceControl().release();

   332     }

   333     mReleaseCameraTimer.stop();

   334 

   335     CX_DEBUG_EXIT_FUNCTION();

   336 }

   337 

   338 // ---------------------------------------------------------------------------

   339 // CxuiPostcaptureView::hideControls

   340 //

   341 // ---------------------------------------------------------------------------

   342 //

   343 void CxuiPostcaptureView::hideControls()

   344 {

   345     CX_DEBUG_ENTER_FUNCTION();

   346 

   347     if (mStillToolbar) {

   348         mStillToolbar->hide();

   349     }

   350     if (mVideoToolbar) {

   351         mVideoToolbar->hide();

   352     }

   353     if (mEmbeddedToolbar) {

   354         mEmbeddedToolbar->hide();

   355     }

   356 

   357     hideItems(Hb::AllItems);

   358 

   359     mControlsVisible = false;

   360 

   361     // stop hiding control timer

   362     mHideControlsTimeout.stop();

   363 

   364 

   365     // give the keyboard focus back to the view

   366     // for the view to receive key events

   367     setFocus();

   368 

   369     CX_DEBUG_EXIT_FUNCTION();

   370 }

   371 

   372 // ---------------------------------------------------------------------------

   373 // CxuiPostcaptureView::showControls

   374 //

   375 // ---------------------------------------------------------------------------

   376 //

   377 void CxuiPostcaptureView::showControls()

   378 {

   379     CX_DEBUG_ENTER_FUNCTION();

   380 

   381     showToolbar();

   382 

   383     showItems(Hb::AllItems);

   384 

   385     mHideControlsTimeout.start(CXUI_HIDE_CONTROLS_TIMEOUT);

   386     mControlsVisible = true;

   387 

   388     CX_DEBUG_EXIT_FUNCTION();

   389 }

   390 

   391 // ---------------------------------------------------------------------------

   392 // CxuiPostcaptureView::toggleControls

   393 //

   394 // ---------------------------------------------------------------------------

   395 //

   396 void CxuiPostcaptureView::toggleControls()

   397 {

   398     CX_DEBUG_ENTER_FUNCTION();

   399 

   400     if (mControlsVisible) {

   401         hideControls();

   402     } else {

   403         showControls();

   404     }

   405 

   406     CX_DEBUG_EXIT_FUNCTION();

   407 }

   408 

   409 // ---------------------------------------------------------------------------

   410 // CxuiPostcaptureView::eventFilter

   411 //

   412 // ---------------------------------------------------------------------------

   413 //

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

   415 {

   416     Q_UNUSED(object)

   417 

   418     bool eventWasConsumed = false;

   419 

   420     switch (event->type())

   421     {

   422     case QEvent::GraphicsSceneMouseRelease:

   423         mHideControlsTimeout.start();

   424         break;

   425     case QEvent::GraphicsSceneMousePress:

   426         mHideControlsTimeout.stop();

   427         // stop the postcapture timer

   428         mPostcaptureTimer.stop();

   429         break;

   430     default:

   431         break;

   432     }

   433 

   434     return eventWasConsumed;

   435 }

   436 

   437 /*!

   438 * Paint event.

   439 * Used for performance tracing (snapshot latency).

   440 */

   441 bool CxuiPostcaptureView::event(QEvent *event)

   442 {

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

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

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

   446     }

   447     return processed;

   448 }

   449 

   450 // ---------------------------------------------------------------------------

   451 // CxuiPostcaptureView::mousePressEvent

   452 //

   453 // ---------------------------------------------------------------------------

   454 //

   455 void CxuiPostcaptureView::mousePressEvent(QGraphicsSceneMouseEvent *event)

   456 {

   457 

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

   459         mPostcaptureTimer.stop();

   460         toggleControls();

   461         event->accept();

   462     }

   463 

   464 }

   465 

   466 // ---------------------------------------------------------------------------

   467 // CxuiPostcaptureView::showEvent

   468 //

   469 // ---------------------------------------------------------------------------

   470 //

   471 void CxuiPostcaptureView::showEvent(QShowEvent *event)

   472 {

   473     CX_DEBUG_ENTER_FUNCTION();

   474 

   475     QGraphicsWidget::showEvent(event);

   476 

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

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

   479 

   480         updateSnapshotImage();

   481         showControls();

   482         startTimers();

   483         event->accept();

   484     }

   485 

   486     CX_DEBUG_EXIT_FUNCTION();

   487 }

   488 

   489 // ---------------------------------------------------------------------------

   490 // CxuiPostcaptureView::hideEvent

   491 //

   492 // ---------------------------------------------------------------------------

   493 //

   494 void CxuiPostcaptureView::hideEvent(QHideEvent *event)

   495 {

   496     CX_DEBUG_ENTER_FUNCTION();

   497 

   498     QGraphicsWidget::hideEvent(event);

   499 

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

   501         // remove event filter to disable unnecessary actions

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

   503 

   504         stopTimers();

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

   506         // when this view is reactivated.

   507         hideControls();

   508         event->accept();

   509     }

   510 

   511     CX_DEBUG_EXIT_FUNCTION();

   512 }

   513 

   514 /*! Shows toolbar.

   515     Toolbar that is shown is selected based on current mode.

   516  */

   517 void CxuiPostcaptureView::showToolbar(){

   518 

   519     CX_DEBUG_ENTER_FUNCTION();

   520 

   521     if (CxuiServiceProvider::isCameraEmbedded()) {

   522         mEmbeddedToolbar->setVisible(true);

   523         mStillToolbar->setVisible(false);

   524         mVideoToolbar->setVisible(false);

   525     } else {

   526         mEmbeddedToolbar->setVisible(false);

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

   528             mVideoToolbar->setVisible(false);

   529             mStillToolbar->setVisible(true);

   530             mStillToolbar->show();

   531         } else {

   532             mStillToolbar->setVisible(false);

   533             mVideoToolbar->setVisible(true);

   534             mVideoToolbar->show();

   535         }

   536     }

   537 

   538     CX_DEBUG_EXIT_FUNCTION();

   539 }

   540 

   541 /*!

   542     Creates black background item. If snapshot smaller than the screen size,

   543     background is visible.

   544  */

   545 void CxuiPostcaptureView::createBackground()

   546 {

   547     CX_DEBUG_ENTER_FUNCTION();

   548 

   549     if (!mBackgroundItem) {

   550         mBackgroundItem = new QGraphicsRectItem(this);

   551         QBrush blackBrush = QBrush(Qt::black);

   552         mBackgroundItem->setBrush(blackBrush);

   553         mBackgroundItem->setRect(mMainWindow->sceneRect());

   554     }

   555 

   556     CX_DEBUG_EXIT_FUNCTION();

   557 }

   558 

   559 // ---------------------------------------------------------------------------

   560 // CxuiPostcaptureView::setImage

   561 //

   562 // ---------------------------------------------------------------------------

   563 //

   564 void CxuiPostcaptureView::updateSnapshotImage()

   565 {

   566     CX_DEBUG_ENTER_FUNCTION();

   567 

   568     QPixmap snapshot;

   569 

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

   571         if( mEngine->stillCaptureControl().imageCount() > 0 ) {

   572             snapshot = mEngine->stillCaptureControl()[0].snapshot();

   573         }

   574     } else {

   575         snapshot = mEngine->videoCaptureControl().snapshot();

   576     }

   577 

   578     if (mImageLabel) {

   579         mImageLabel->setIcon(HbIcon(QIcon(snapshot)));

   580     } else {

   581         // do nothing

   582     }

   583 

   584     CX_DEBUG_EXIT_FUNCTION();

   585 }

   586 

   587 /*!

   588     Launches "Not supported yet" notification.

   589  */

   590 void CxuiPostcaptureView::launchNotSupportedNotification()

   591 {

   592     CX_DEBUG_ENTER_FUNCTION();

   593 

   594     // Instantiate a popup

   595     HbNotificationDialog note;

   596     note.setTitle("Notification");

   597     note.setText("Not supported yet");

   598     note.exec();

   599 

   600     CX_DEBUG_EXIT_FUNCTION();

   601 }

   602 

   603 /* !

   604  * gets the filename of the current file

   605  */

   606 QString CxuiPostcaptureView::getCurrentFilename()

   607 {

   608     CX_DEBUG_ENTER_FUNCTION();

   609 

   610     QString filename;

   611 

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

   613         filename = mEngine->videoCaptureControl().filename();

   614     } else {

   615         //!@todo Currently only gets index 0 from the still capture control.

   616         CxeStillCaptureControl& stillCaptureControl = mEngine->stillCaptureControl();

   617         if (stillCaptureControl.imageCount()) {

   618             filename = stillCaptureControl[0].filename();

   619         }

   620     }

   621     CX_DEBUG((filename.toAscii()));

   622 

   623     CX_DEBUG_EXIT_FUNCTION();

   624 

   625     return filename;

   626 }

   627 

   628 /*!

   629     Launches the Photos applications as a separate process

   630 */

   631 void CxuiPostcaptureView::launchPhotosApp()

   632 {

   633     QProcess::startDetached(PhotosAppExe);

   634 }

   635 

   636 /*!

   637     Sends current capture to client app and closes camera

   638 */

   639 void CxuiPostcaptureView::select()

   640 {

   641     CxuiServiceProvider *serviceProvider = CxuiServiceProvider::instance();

   642     if (!serviceProvider) {

   643         return;

   644     }

   645 

   646     QString filename = getCurrentFilename();

   647     serviceProvider->sendFilenameToClientAndExit(filename);

   648 }

   649 

   650 /*!

   651     Launches the Videos applications as a separate process

   652 */

   653 void CxuiPostcaptureView::launchVideosApp()

   654 {

   655     //Releasing cameda device in order to free

   656     //graphical memory

   657     releaseCamera();

   658     QProcess::startDetached(VideosAppExe);

   659 }

   660 

   661 /*!

   662     Handle cases when we loose focus

   663 */

   664 void CxuiPostcaptureView::handleFocusLost()

   665 {

   666     CX_DEBUG_ENTER_FUNCTION();

   667 

   668     // we have lost focus

   669     releaseCamera();

   670     stopTimers();

   671     hideControls();

   672 

   673     CX_DEBUG_EXIT_FUNCTION();

   674 }

   675 

   676 

   677 void CxuiPostcaptureView::startTimers()

   678 {

   679     CX_DEBUG_ENTER_FUNCTION();

   680 

   681     // we start timers only once in a given postcapture view session

   682     if (!mTimersStarted) {

   683         int postCaptureTimeout = 0;

   684         QString settingId;

   685 

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

   687             settingId = CxeSettingIds::STILL_SHOWCAPTURED;

   688         } else {

   689             settingId = CxeSettingIds::VIDEO_SHOWCAPTURED;

   690         }

   691 

   692         if (!CxuiServiceProvider::isCameraEmbedded()) {

   693             CxeError::Id err = mEngine->settings().get(settingId, postCaptureTimeout);

   694 

   695             if (postCaptureTimeout > 0 && err == CxeError::None) {

   696                 mPostcaptureTimer.start(postCaptureTimeout);

   697             } else {

   698                 // do nothing

   699             }

   700         }

   701 

   702         // start the hide control timer.

   703         mHideControlsTimeout.start(CXUI_HIDE_CONTROLS_TIMEOUT);

   704 

   705         //! @todo Temporarily disabling release timer because of

   706         // graphics memory problems related to releasing and reserving again.

   707         // mReleaseCameraTimer.start(CXUI_RELEASE_CAMERA_TIMEOUT);

   708         // mStopViewfinderTimer.start(CXUI_STOP_VIEWFINDER_TIMEOUT);

   709 

   710         // we make sure that timers are started only once in a given postcaptureview session

   711         mTimersStarted = true;

   712     }

   713 

   714     // show controls when we get back focus

   715     showControls();

   716 

   717     CX_DEBUG_EXIT_FUNCTION();

   718 }

   719 

   720 void CxuiPostcaptureView::stopTimers()

   721 {

   722     CX_DEBUG_ENTER_FUNCTION();

   723 

   724     // stop all the timers

   725     mHideControlsTimeout.stop();

   726     mReleaseCameraTimer.stop();

   727     mPostcaptureTimer.stop();

   728     mStopViewfinderTimer.stop();

   729 

   730     mTimersStarted = false;

   731 

   732     CX_DEBUG_EXIT_FUNCTION();

   733 }

   734 

   735 // end of file