1 /*

     2 * Copyright (c) 2009-2010 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 

    18 

    19 

    20 #include <QApplication>

    21 #include <QGraphicsLayout>

    22 

    23 #include <hbmainwindow.h>

    24 #include <hbaction.h>

    25 #include <hbtoolbar.h>

    26 #include <hbtoolbarextension.h>

    27 #include <hbtransparentwindow.h>

    28 #include <hblabel.h>

    29 #include <hbslider.h>

    30 #include <hbmenu.h>

    31 #include <hbdialog.h>

    32 #include <hbnotificationdialog.h>

    33 #include <hbfeedbacksettings.h>

    34 #include <hbfeedbacknamespace.h>

    35 #include <hbactivitymanager.h>

    36 

    37 #include "cxuivideoprecaptureview.h"

    38 #include "cxeengine.h"

    39 #include "cxeviewfindercontrol.h"

    40 #include "cxevideocapturecontrol.h"

    41 #include "cxecameradevicecontrol.h"

    42 #include "cxenamespace.h"

    43 #include "cxesettings.h"

    44 #include "cxuienums.h"

    45 #include "cxutils.h"

    46 #include "cxuizoomslider.h"

    47 #include "cxuicapturekeyhandler.h"

    48 #include "cxuidocumentloader.h"

    49 #include "cxuiserviceprovider.h"

    50 

    51 #ifdef Q_OS_SYMBIAN

    52 #include "OstTraceDefinitions.h"

    53 

    54 #ifdef OST_TRACE_COMPILER_IN_USE

    55 #include "cxuivideoprecaptureviewTraces.h"

    56 #endif

    57 

    58 #include <e32keys.h>

    59 #endif  //Q_OS_SYMBIAN

    60 

    61 using namespace Cxe;

    62 using namespace CxUiLayout;

    63 using namespace CxUiInternal;

    64 

    65 namespace

    66 {

    67     static const int CXUI_ELAPSED_TIME_TIMEOUT = 1000; // 1 second

    68     static const int CXUI_RECORD_ANIMATION_DURATION = 3000; // milliseconds

    69     static const int CXUI_PAUSE_TIMEOUT = 60*1000;   // 60 seconds

    70 

    71     //!@todo Localization?

    72     static const char* VIDEO_TIME_FORMAT = "%02d:%02d";

    73     const int POSTCAPTURE_ON = -1;

    74 }

    75 

    76 

    77 CxuiVideoPrecaptureView::CxuiVideoPrecaptureView(QGraphicsItem *parent) :

    78     CxuiPrecaptureView(parent),

    79     mElapsedTimer(this),

    80     mTimeElapsed(0),

    81     mTimeRemaining(0),

    82     mVideoTimeText(NULL),

    83     mRecordingIcon(NULL),

    84     mGoToStillAction(NULL),

    85     mToolbarIdle(NULL),

    86     mToolbarRec(NULL),

    87     mToolbarPaused(NULL),

    88     mVideoScenePopup(NULL),

    89     mVideoCaptureControl(NULL),

    90     mMenu(NULL),

    91     mCapturePending(false)

    92 {

    93     CX_DEBUG_IN_FUNCTION();

    94 }

    95 

    96 CxuiVideoPrecaptureView::~CxuiVideoPrecaptureView()

    97 {

    98     CX_DEBUG_IN_FUNCTION();

    99     mElapsedTimer.stop();

   100     delete mMenu;

   101     CX_DEBUG_EXIT_FUNCTION();

   102 }

   103 

   104 /*!

   105  * Construct-method handles initialisation tasks for this class.

   106  * @param mainwindow

   107  * @param engine

   108  * @param documentLoader

   109  * @param keyHandler

   110  */

   111 void CxuiVideoPrecaptureView::construct(HbMainWindow *mainwindow, CxeEngine *engine,

   112                                         CxuiDocumentLoader *documentLoader,

   113                                         CxuiCaptureKeyHandler *keyHandler,

   114                                         HbActivityManager *activityManager)

   115 {

   116     CX_DEBUG_ENTER_FUNCTION();

   117 

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

   119     mCaptureKeyHandler = keyHandler;

   120 

   121     mVideoCaptureControl = &(engine->videoCaptureControl());

   122 

   123     connect(&mElapsedTimer, SIGNAL(timeout()), this, SLOT(updateTimeLabels()));

   124     connect(mVideoCaptureControl, SIGNAL(stateChanged(CxeVideoCaptureControl::State, CxeError::Id)),

   125             this, SLOT(handleVideoStateChanged(CxeVideoCaptureControl::State,CxeError::Id)));

   126     connect(mVideoCaptureControl, SIGNAL(remainingTimeChanged()),

   127             this, SLOT(updateTimeLabels()));

   128 

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

   130 

   131     mPauseTimer.setSingleShot(true);

   132     connect(&mPauseTimer, SIGNAL(timeout()), this, SLOT(stop()));

   133     mPauseTimer.setInterval(CXUI_PAUSE_TIMEOUT);

   134 

   135     HbAction *quitAction = new HbAction(Hb::QuitNaviAction, this);

   136     setNavigationAction(quitAction);

   137     connect(quitAction, SIGNAL(triggered()), this, SLOT(handleQuitClicked()));

   138 

   139     loadDefaultWidgets();

   140     loadWidgets();

   141     hideControls();

   142 

   143     CX_DEBUG_EXIT_FUNCTION();

   144 

   145 }

   146 

   147 /*!

   148  * Loads widgets that are needed right from the start.

   149  */

   150 void CxuiVideoPrecaptureView::loadDefaultWidgets()

   151 {

   152     CX_DEBUG_ENTER_FUNCTION();

   153     CX_ASSERT_ALWAYS(mDocumentLoader);

   154 

   155     // get pointers to ui components from the layout data

   156     QGraphicsWidget *widget = NULL;

   157     widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_VIEWFINDER);

   158     mViewfinder = qobject_cast<HbTransparentWindow *> (widget);

   159     CX_ASSERT_ALWAYS(mViewfinder);

   160 

   161     reloadIndicatorWidgets();

   162 

   163     CX_DEBUG_EXIT_FUNCTION();

   164 }

   165 

   166 /*!

   167  * Loads default indicators from docml and modifies the visibility

   168  * according to current settings.

   169  */

   170 void CxuiVideoPrecaptureView::reloadIndicatorWidgets()

   171 {

   172     CX_DEBUG_ENTER_FUNCTION();

   173     CX_ASSERT_ALWAYS(mDocumentLoader);

   174 

   175     bool ok = false;

   176     mDocumentLoader->load(VIDEO_1ST_XML, VIDEO_PRE_CAPTURE_INDICATORS_SECTION, &ok);

   177     CX_ASSERT_ALWAYS(ok);

   178 

   179     QGraphicsWidget *widget = NULL;

   180     widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_QUALITY_ICON);

   181     mQualityIcon = qobject_cast<HbLabel *> (widget);

   182     CX_ASSERT_ALWAYS(mQualityIcon);

   183 

   184     widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_VIDEOAUDIOMUTE_INDICATOR_ICON);

   185     HbLabel *videoaudiomuteIndicatorIcon = qobject_cast<HbLabel *>(widget);

   186     CX_ASSERT_ALWAYS(videoaudiomuteIndicatorIcon);

   187 

   188     widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_STABILITY_INDICATOR_ICON);

   189     HbLabel *videoStabilityIndicatorIcon = qobject_cast<HbLabel *>(widget);

   190     CX_ASSERT_ALWAYS(videoStabilityIndicatorIcon);

   191 

   192     widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_INDICATOR_CONTAINER_TOP);

   193     mIndicators = qobject_cast<HbWidget *>(widget);

   194     CX_ASSERT_ALWAYS(mIndicators);

   195 

   196     QGraphicsLayout *layout = mIndicators->layout();

   197     QGraphicsLayoutItem *graphicsLayoutItem = NULL;

   198     QGraphicsItem *graphicsItem = NULL;

   199     QString key = "";

   200     int currentSettingValue = -1;

   201     bool isSettingOff = false;

   202     // Go through the items in the layout to check whether they should be

   203     // shown or not in the indicator pane. Start from the last towards

   204     // the first, so that removing items from between works correctly.

   205     for (int i = layout->count() - 1; i >= 0; i--) {

   206         graphicsLayoutItem = layout->itemAt(i);

   207         isSettingOff = false;

   208         if (graphicsLayoutItem) {

   209             graphicsItem = graphicsLayoutItem->graphicsItem();

   210             currentSettingValue = -1;

   211             if (graphicsItem == videoaudiomuteIndicatorIcon) {

   212                 key = CxeSettingIds::VIDEO_MUTE_SETTING;

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

   214                 // video mute implementation does not use

   215                 // enum for on/off values but instead

   216                 // 0 for off and 1 for on.

   217                 if (currentSettingValue == 0) {

   218                     isSettingOff = true;

   219                 }

   220             } else if (graphicsItem == videoStabilityIndicatorIcon) {

   221                 // remove video stability indicator.

   222                 isSettingOff = true;

   223             }

   224             if (isSettingOff) {

   225                 layout->removeAt(i);

   226             }

   227         }

   228     }

   229 

   230     // Create background graphics for indicator container

   231     createWidgetBackgroundGraphic(mIndicators, TRANSPARENT_BACKGROUND_GRAPHIC);

   232 

   233     mIndicators->setVisible(true);

   234 

   235     CX_DEBUG_EXIT_FUNCTION();

   236 }

   237 

   238 /*!

   239  * Loads widgets that are not part of the default section in layouts xml.

   240  * Widgets are created at the time they are first loaded.

   241  */

   242 void CxuiVideoPrecaptureView::loadWidgets()

   243 {

   244     CX_DEBUG_ENTER_FUNCTION();

   245     CX_ASSERT_ALWAYS(mDocumentLoader);

   246 

   247     if (mWidgetsLoaded) {

   248         CX_DEBUG(("Widgets already loaded"));

   249         CX_DEBUG_EXIT_FUNCTION();

   250         return;

   251     }

   252 

   253     // get pointers to ui components from the layout data

   254     QGraphicsWidget *widget = NULL;

   255 

   256     // load the "secondary" widgets

   257     bool ok = false;

   258 

   259     // load widgets section (creates the widgets)

   260     mDocumentLoader->load(VIDEO_1ST_XML, VIDEO_PRE_CAPTURE_WIDGETS_SECTION, &ok);

   261     CX_ASSERT_ALWAYS(ok);

   262     if (CxuiServiceProvider::isCameraEmbedded()) {

   263         mDocumentLoader->load(VIDEO_1ST_XML, VIDEO_PRE_CAPTURE_EMBEDDED_SECTION, &ok);

   264     } else {

   265         mDocumentLoader->load(VIDEO_1ST_XML, VIDEO_PRE_CAPTURE_STANDALONE_SECTION, &ok);

   266     }

   267     CX_ASSERT_ALWAYS(ok);

   268     // get needed pointers to some of the widgets

   269     widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_ZOOM_SLIDER);

   270     mSlider = qobject_cast<CxuiZoomSlider *> (widget);

   271     CX_ASSERT_ALWAYS(mSlider);

   272 

   273     //Let's add a plus and minus buttons to the slider

   274     mSlider->addZoomButtons();

   275     createWidgetBackgroundGraphic(mSlider, TRANSPARENT_BACKGROUND_GRAPHIC);

   276 

   277     widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_TOOLBAR);

   278     mToolbarIdle = qobject_cast<HbToolBar *> (widget);

   279     widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_TOOLBAR_REC);

   280     mToolbarRec = qobject_cast<HbToolBar *> (widget);

   281     widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_TOOLBAR_PAUSED);

   282     mToolbarPaused = qobject_cast<HbToolBar *> (widget);

   283 

   284     mToolbar = mToolbarIdle;

   285 

   286     CX_ASSERT_ALWAYS(mToolbarIdle);

   287     CX_ASSERT_ALWAYS(mToolbarRec);

   288     CX_ASSERT_ALWAYS(mToolbarPaused);

   289 

   290     hideControls();

   291 

   292     if (CxuiServiceProvider::isCameraEmbedded()) {

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

   294 

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

   296 

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

   298             HbAction* vq = qobject_cast<HbAction*> (mDocumentLoader->findObject(VIDEO_PRE_CAPTURE_VIDEO_QUALITY_ACTION));

   299             if (vq) {

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

   301                 vq->setEnabled(false);

   302             }

   303         }

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

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

   306 

   307             HbAction *still = qobject_cast<HbAction*> (mDocumentLoader->findObject(VIDEO_PRE_CAPTURE_GOTO_STILL_ACTION));

   308             if (still) {

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

   310                 still->setEnabled(false);

   311             }

   312         }

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

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

   315 

   316         }

   317 

   318     }

   319 

   320 

   321     // Create background graphic for indicator container

   322     HbWidget *indicatorContainer;

   323     widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_INDICATOR_CONTAINER_BOTTOM);

   324     indicatorContainer = qobject_cast<HbWidget *>(widget);

   325     CX_ASSERT_ALWAYS(indicatorContainer);

   326     createWidgetBackgroundGraphic(indicatorContainer, TRANSPARENT_BACKGROUND_GRAPHIC);

   327 

   328     widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_VIDEO_TIME_LABEL);

   329     mVideoTimeText = qobject_cast<HbLabel *> (widget);

   330     CX_ASSERT_ALWAYS(mVideoTimeText);

   331 

   332     widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_RECORDING_ICON);

   333     mRecordingIcon = qobject_cast<HbLabel *> (widget);

   334     CX_ASSERT_ALWAYS(mRecordingIcon);

   335 

   336     mWidgetsLoaded = true;

   337 

   338     // Initializing recording indicator animation

   339     mRecordingAnimation = new QPropertyAnimation(mRecordingIcon, "opacity");

   340     mRecordingAnimation->setStartValue(0.2);

   341     mRecordingAnimation->setKeyValueAt(0.5, 1.0);

   342     mRecordingAnimation->setEndValue(0.2);

   343     mRecordingAnimation->setDuration(CXUI_RECORD_ANIMATION_DURATION);

   344     mRecordingAnimation->setLoopCount(-1);

   345     mRecordingAnimation->setEasingCurve(QEasingCurve::OutInQuad);

   346 

   347 

   348     // Update toolbar scene mode icon.

   349     try {

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

   351     } catch (CxeException &e) {

   352         // ignore error

   353     }

   354 

   355     // Initialize the video time counters.

   356     updateTimeLabels();

   357 

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

   359     emit viewReady();

   360 

   361     CX_DEBUG_EXIT_FUNCTION();

   362 }

   363 

   364 /*!

   365  * Restore view state from activity.

   366  */

   367 void CxuiVideoPrecaptureView::restoreActivity(const QString &activityId, const QVariant &data)

   368 {

   369     Q_UNUSED(activityId);

   370     Q_UNUSED(data);

   371 

   372     CX_DEBUG_ENTER_FUNCTION();

   373     // no need to restore any state

   374     CX_DEBUG_EXIT_FUNCTION();

   375 }

   376 

   377 /*!

   378  * Save view state to activity.

   379  */

   380 void CxuiVideoPrecaptureView::saveActivity()

   381 {

   382     CX_DEBUG_ENTER_FUNCTION();

   383     QVariantMap data;

   384     QVariantHash params;

   385 

   386     HbIcon activityScreenshot("qtg_graf_taskswitcher_camcorder");

   387     QPixmap screenshot = activityScreenshot.pixmap();

   388     params.insert("screenshot", screenshot);

   389 

   390     mActivityManager->removeActivity(

   391             CxuiActivityIds::VIDEO_PRECAPTURE_ACTIVITY);

   392     mActivityManager->addActivity(CxuiActivityIds::VIDEO_PRECAPTURE_ACTIVITY,

   393                                   data, params);

   394     CX_DEBUG_EXIT_FUNCTION();

   395 }

   396 

   397 /*!

   398  * Clear activity from activity manager.

   399  */

   400 void CxuiVideoPrecaptureView::clearActivity()

   401 {

   402     CX_DEBUG_ENTER_FUNCTION();

   403     mActivityManager->removeActivity(CxuiActivityIds::VIDEO_PRECAPTURE_ACTIVITY);

   404     CX_DEBUG_EXIT_FUNCTION();

   405 }

   406 

   407 /*!

   408 * Initialize settings grid.

   409 */

   410 void CxuiVideoPrecaptureView::initializeSettingsGrid()

   411 {

   412     if(!mSettingsGrid) {

   413         HbAction* action(NULL);

   414 

   415         mSettingsGrid = new HbToolBarExtension;

   416 

   417         action = mSettingsGrid->addAction(HbIcon("qtg_mono_exposure"), hbTrId("txt_cam_button_exposure_compensation"), this, SLOT(launchSliderSetting()));

   418         action->setProperty(PROPERTY_KEY_SETTING_ID, CxeSettingIds::EV_COMPENSATION_VALUE);

   419         action->setProperty(PROPERTY_KEY_SETTING_GRID, PROPERTY_KEY_TRUE);

   420 

   421         action = mSettingsGrid->addAction(HbIcon("qtg_small_rgb"), hbTrId("txt_cam_button_color_tone"), this, SLOT(launchSetting()));

   422         action->setProperty(PROPERTY_KEY_SETTING_ID, CxeSettingIds::COLOR_TONE);

   423         action->setProperty(PROPERTY_KEY_SETTING_GRID, PROPERTY_KEY_TRUE);

   424 

   425         action = mSettingsGrid->addAction(HbIcon("qtg_mono_white_balance"), hbTrId("txt_cam_button_white_balance"), this, SLOT(launchSetting()));

   426         action->setProperty(PROPERTY_KEY_SETTING_ID, CxeSettingIds::WHITE_BALANCE);

   427         action->setProperty(PROPERTY_KEY_SETTING_GRID, PROPERTY_KEY_TRUE);

   428 

   429         connect(mCaptureKeyHandler, SIGNAL(autofocusKeyPressed()), mSettingsGrid, SLOT(close()));

   430     }

   431 }

   432 

   433 

   434 /**

   435 * Get if postcapture view should be shown or not.

   436 * Postcapture view may be shown for a predefined time or

   437 * until user dismisses it, or it may be completely disabled.

   438 */

   439 bool CxuiVideoPrecaptureView::isPostcaptureOn() const

   440 {

   441     CX_DEBUG_ENTER_FUNCTION();

   442     if (CxuiServiceProvider::isCameraEmbedded()) {

   443         // always show post capture in embedded mode

   444         CX_DEBUG_EXIT_FUNCTION();

   445         return true;

   446     }

   447 

   448     // Read the value from settings. Ignoring reading error.

   449     // On error (missing settings) default to "postcapture on".

   450     int showPostcapture(POSTCAPTURE_ON);

   451     if(mEngine) {

   452         showPostcapture = mEngine->settings().get<int>(CxeSettingIds::VIDEO_SHOWCAPTURED, POSTCAPTURE_ON);

   453     }

   454 

   455     CX_DEBUG_EXIT_FUNCTION();

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

   457 }

   458 

   459 /*!

   460 * Update the scene mode icon.

   461 * @param sceneId The new scene id.

   462 */

   463 void CxuiVideoPrecaptureView::updateSceneIcon(const QString& sceneId)

   464 {

   465     CX_DEBUG_ENTER_FUNCTION();

   466 

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

   468         CX_DEBUG(("CxuiPrecaptureView - scene: %s", sceneId.toAscii().constData()));

   469 

   470         // No need to update icon, if widgets are not even loaded yet.

   471         // We'll update the icon once the widgets are loaded.

   472         if (mWidgetsLoaded) {

   473             QString iconObjectName = VIDEO_PRE_CAPTURE_SCENE_MODE_ACTION;

   474             QString icon = getSettingItemIcon(CxeSettingIds::VIDEO_SCENE, sceneId);

   475 

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

   477 

   478             if (mDocumentLoader) {

   479                 QObject *obj = mDocumentLoader->findObject(iconObjectName);

   480                 CX_ASSERT_ALWAYS(obj);

   481                 qobject_cast<HbAction *>(obj)->setIcon(HbIcon(icon));

   482             }

   483         } else {

   484             CX_DEBUG(("CxuiVideoPrecaptureView - widgets not loaded yet, ignored!"));

   485         }

   486     }

   487     CX_DEBUG_EXIT_FUNCTION();

   488 }

   489 

   490 /*!

   491     Update the quality indicator

   492 */

   493 void CxuiVideoPrecaptureView::updateQualityIcon()

   494 {

   495     CX_DEBUG_ENTER_FUNCTION();

   496 

   497     if (mQualityIcon && mEngine) {

   498         QString icon = "";

   499 

   500         int currentValue = mEngine->settings().get<int>(CxeSettingIds::VIDEO_QUALITY, -1);

   501         icon = getSettingItemIcon(CxeSettingIds::VIDEO_QUALITY, currentValue);

   502 

   503         mQualityIcon->setIcon(HbIcon(icon));

   504     }

   505 

   506     CX_DEBUG_EXIT_FUNCTION();

   507 }

   508 

   509 void CxuiVideoPrecaptureView::record()

   510 {

   511     CX_DEBUG_ENTER_FUNCTION();

   512 

   513     int time(0);

   514     mVideoCaptureControl->remainingTime(time);

   515 

   516     if (time) {

   517         if (!mMenu){ // Only take out menu, if we have not already done it

   518             mMenu = takeMenu();

   519         }

   520         mVideoCaptureControl->record();

   521     } else {

   522         emit errorEncountered(CxeError::DiskFull);

   523     }

   524 

   525     CX_DEBUG_EXIT_FUNCTION();

   526 }

   527 

   528 void CxuiVideoPrecaptureView::pause()

   529 {

   530     CX_DEBUG_ENTER_FUNCTION();

   531 

   532     CxeVideoCaptureControl::State state = mVideoCaptureControl->state();

   533     if (state == CxeVideoCaptureControl::Recording) {

   534         mVideoCaptureControl->pause();

   535     } else if (state == CxeVideoCaptureControl::Paused) {

   536         mVideoCaptureControl->record();

   537     }

   538 

   539     CX_DEBUG_EXIT_FUNCTION();

   540 }

   541 

   542 void CxuiVideoPrecaptureView::stop()

   543 {

   544     CX_DEBUG_ENTER_FUNCTION();

   545 

   546     CxeVideoCaptureControl::State state = mVideoCaptureControl->state();

   547     if (state == CxeVideoCaptureControl::Recording ||

   548         state == CxeVideoCaptureControl::Paused) {

   549         mVideoCaptureControl->stop();

   550         // Continue in handleVideoStateChanged().

   551     }

   552 

   553     CX_DEBUG_EXIT_FUNCTION();

   554 }

   555 

   556 

   557 /*!

   558 * Allow showing UI controls?

   559 */

   560 bool CxuiVideoPrecaptureView::allowShowControls() const

   561 {

   562     bool show(false);

   563     if (mEngine) {

   564         CxeVideoCaptureControl::State state(mEngine->videoCaptureControl().state());

   565 

   566         show = (mEngine->isEngineReady()

   567              || state == CxeVideoCaptureControl::Recording

   568              || state == CxeVideoCaptureControl::Paused);

   569     }

   570     return show;

   571 }

   572 

   573 /*!

   574  * Play feedback when touching view outside of any widget?

   575  * If video is paused feedback is off.  Otherwise on.

   576  */

   577 bool CxuiVideoPrecaptureView::isFeedbackEnabled() const

   578 {

   579     CxeVideoCaptureControl::State state(mEngine->videoCaptureControl().state());

   580     if (state == CxeVideoCaptureControl::Paused) {

   581         return false;

   582     } else {

   583         return true;

   584     }

   585 }

   586 

   587 // CxuiPrecaptureView::showToolbar()

   588 // Shows toolbar. Calls the base class implementation if not recording

   589 // since toolbar is not shown during recording

   590 void CxuiVideoPrecaptureView::showToolbar()

   591 {

   592     CxeVideoCaptureControl::State state = mVideoCaptureControl->state();

   593     if (state == CxeVideoCaptureControl::Recording) {

   594         if (mToolbar != mToolbarRec) {

   595             mToolbar->hide();

   596             mToolbar = mToolbarRec;

   597         }

   598     } else if (state ==CxeVideoCaptureControl::Ready) {

   599         if (mToolbar != mToolbarIdle) {

   600             mToolbar->hide();

   601             mToolbar = mToolbarIdle;

   602         }

   603     } else if (state == CxeVideoCaptureControl::Paused) {

   604         if (mToolbar != mToolbarPaused) {

   605             mToolbar->hide();

   606             mToolbar = mToolbarPaused;

   607         }

   608     }

   609 

   610     CxuiPrecaptureView::showToolbar();

   611 }

   612 

   613 void CxuiVideoPrecaptureView::disableFeedback()

   614 {

   615     CX_DEBUG_ENTER_FUNCTION();

   616 

   617     HbFeedbackSettings settings;

   618     settings.disableFeedback();

   619 

   620 

   621     CX_DEBUG_EXIT_FUNCTION();

   622 }

   623 

   624 void CxuiVideoPrecaptureView::enableFeedback()

   625 {

   626     CX_DEBUG_ENTER_FUNCTION();

   627 

   628     HbFeedbackSettings settings;

   629     settings.enableFeedback();

   630 

   631 

   632     CX_DEBUG_EXIT_FUNCTION();

   633 }

   634 

   635 

   636 void CxuiVideoPrecaptureView::goToStill()

   637 {

   638     CX_DEBUG_ENTER_FUNCTION();

   639     OstTrace0( camerax_performance, CXUIVIDEOPRECAPTUREVIEW_GOTOSTILL, "msg: e_CX_GO_TO_STILL_MODE 1" );

   640 

   641     hideControls();

   642     mEngine->initMode(ImageMode);

   643     emit changeToPrecaptureView();

   644 

   645     CX_DEBUG_EXIT_FUNCTION();

   646 }

   647 

   648 /*!

   649 * Update the remaining and elapsed time labels.

   650 */

   651 void CxuiVideoPrecaptureView::updateTimeLabels()

   652 {

   653     CX_DEBUG_IN_FUNCTION();

   654 

   655     if (!mVideoTimeText) {

   656         // Section not loaded yet. Skip update until created.

   657         CX_DEBUG(("CxuiVideoPrecaptureView: video time labels not loaded yet!"));

   658         CX_DEBUG_EXIT_FUNCTION();

   659         return;

   660     }

   661 

   662     CxeVideoCaptureControl::State state = mVideoCaptureControl->state();

   663     switch (state) {

   664         case CxeVideoCaptureControl::Ready:

   665             getRemainingTime();

   666             // Not recording => elapsed time is zero

   667             mTimeElapsed = 0;

   668             break;

   669 

   670         case CxeVideoCaptureControl::Recording:

   671         case CxeVideoCaptureControl::Paused:

   672             getRemainingTime();

   673             getElapsedTime();

   674             break;

   675 

   676         case CxeVideoCaptureControl::Idle:

   677         case CxeVideoCaptureControl::Initialized:

   678         case CxeVideoCaptureControl::Preparing:

   679         default:

   680             // Minimize processing during initialization phase.

   681             // Calculating remaining time involves checking disk space, avoiding that.

   682             // which

   683             mTimeRemaining = 0;

   684             mTimeElapsed = 0;

   685             break;

   686     }

   687 

   688     setVideoTime(mVideoTimeText, mTimeElapsed, mTimeRemaining);

   689 

   690     CX_DEBUG_EXIT_FUNCTION();

   691 }

   692 

   693 /*!

   694   Overridded version of hideControls() that doesn't hide the controls when video recording

   695   is paused.

   696  */

   697 void CxuiVideoPrecaptureView::hideControls()

   698 {

   699     if (mVideoCaptureControl && mVideoCaptureControl->state() == CxeVideoCaptureControl::Paused) {

   700         // never hide controls in paused state

   701         return;

   702     }

   703 

   704     CxuiPrecaptureView::hideControls();

   705 

   706 }

   707 

   708 /*!

   709 * Helper method for formatting video time to requested label.

   710 * @param label Text label to show the time.

   711 * @param elapsedTime Elapsed time in seconds to be formatted to the label text.

   712 * @param remainingTime Remaining time in seconds to be formatted to the label text.

   713 */

   714 void CxuiVideoPrecaptureView::setVideoTime(HbLabel* label,

   715                                            int elapsedTime,

   716                                            int remainingTime)

   717 {

   718     // Convert time (seconds) into mm:ss

   719     // HbExtendedLocale wraps minutes at 60 so we can't use that.

   720     // We need to show times over 1 hour, e.g. "90:00".

   721     QString elapsed, remaining;

   722     elapsed.sprintf(VIDEO_TIME_FORMAT, elapsedTime/60, elapsedTime%60);

   723     remaining.sprintf(VIDEO_TIME_FORMAT, remainingTime/60, remainingTime%60);

   724 

   725     label->setPlainText(hbTrId("txt_cam_info_redorcding_time").arg(elapsed).arg(remaining));

   726 }

   727 

   728 bool CxuiVideoPrecaptureView::getElapsedTime()

   729 {

   730     CX_DEBUG_ENTER_FUNCTION();

   731 

   732     bool status = mVideoCaptureControl->elapsedTime(mTimeElapsed);

   733     CX_DEBUG(("Elapsed time: %d", mTimeElapsed));

   734     CX_DEBUG(("status: %d", status));

   735 

   736     CX_DEBUG_EXIT_FUNCTION();

   737     return status;

   738 }

   739 

   740 void CxuiVideoPrecaptureView::getRemainingTime()

   741 {

   742     CX_DEBUG_ENTER_FUNCTION();

   743 

   744     mVideoCaptureControl->remainingTime(mTimeRemaining);

   745     CX_DEBUG(("getRemainingTime time: %d", mTimeRemaining));

   746 

   747     CX_DEBUG_EXIT_FUNCTION();

   748 }

   749 

   750 void CxuiVideoPrecaptureView::showEvent(QShowEvent *event)

   751 {

   752     CxuiPrecaptureView::showEvent(event);

   753 

   754     updateQualityIcon();

   755 

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

   757         event->accept();

   758     }

   759 }

   760 

   761 /*!

   762 * Slot to handle video capture control state change.

   763 * Update visible items and stop / start timers.

   764 */

   765 void CxuiVideoPrecaptureView::handleVideoStateChanged(CxeVideoCaptureControl::State newState,

   766         CxeError::Id error)

   767 {

   768     CX_DEBUG_ENTER_FUNCTION();

   769     Q_UNUSED(error);

   770 

   771     updateTimeLabels();

   772 

   773     mPauseTimer.stop();

   774 

   775     switch (newState) {

   776     case CxeVideoCaptureControl::Ready:

   777         if (mDocumentLoader){

   778             mDocumentLoader->load(VIDEO_1ST_XML, VIDEO_PRE_CAPTURE_IDLE);

   779         }

   780         if (mCapturePending) {

   781             mCapturePending = false;

   782             record();

   783         }

   784         break;

   785     case CxeVideoCaptureControl::Recording:

   786         hideControls();

   787         emit stopStandbyTimer();

   788         if (mDocumentLoader){

   789             mDocumentLoader->load(VIDEO_1ST_XML, VIDEO_PRE_CAPTURE_RECORDING);

   790         }

   791 

   792         mElapsedTimer.start(CXUI_ELAPSED_TIME_TIMEOUT);

   793         disableFeedback();

   794 

   795         // commented out the activation of the recording animation because

   796         // it is causing issues when using SW rendering

   797         //if (mRecordingAnimation && mRecordingIcon) {

   798         //  mRecordingAnimation->start();

   799         //}

   800 

   801         break;

   802     case CxeVideoCaptureControl::Paused:

   803         mElapsedTimer.stop();

   804         if (mDocumentLoader){

   805             mDocumentLoader->load(VIDEO_1ST_XML, VIDEO_PRE_CAPTURE_PAUSED);

   806         }

   807         showControls();

   808         enableFeedback();

   809         mPauseTimer.start();

   810         break;

   811     case CxeVideoCaptureControl::Stopping:

   812         if (mDocumentLoader){

   813             mDocumentLoader->load(VIDEO_1ST_XML, VIDEO_PRE_CAPTURE_PAUSED);

   814         }

   815 

   816         // commented out the stopping of the recording animation since the activation

   817         // is commented out also couple lines earlier

   818         //if (mRecordingAnimation && mRecordingIcon) {

   819         //    mRecordingAnimation->stop();

   820         //}

   821 

   822         enableFeedback();

   823         emit startStandbyTimer();

   824         mElapsedTimer.stop();

   825         hideControls();

   826 

   827         if (mMenu) {

   828             setMenu(mMenu);

   829             mMenu = NULL;

   830         }

   831 

   832         if (isPostcaptureOn()) {

   833             emit changeToPostcaptureView();

   834         } else {

   835             // post capture off, we need prepare new video

   836             // do the prepare when the previous video is ready

   837             connect(mVideoCaptureControl, SIGNAL(videoComposed(CxeError::Id, const QString&)),

   838                     this, SLOT(prepareNewVideo(CxeError::Id)));

   839         }

   840         break;

   841     case CxeVideoCaptureControl::PlayingStartSound:

   842         // don't change anything

   843         break;

   844     default:

   845         // don't change anything

   846         break;

   847     }

   848 

   849     CX_DEBUG_EXIT_FUNCTION();

   850 }

   851 

   852 void CxuiVideoPrecaptureView::handleCaptureKeyPressed()

   853 {

   854     CX_DEBUG_ENTER_FUNCTION();

   855     CxeVideoCaptureControl::State state = mVideoCaptureControl->state();

   856 

   857     switch (state) {

   858         case CxeVideoCaptureControl::Ready:

   859             record();

   860             break;

   861         case CxeVideoCaptureControl::Recording:

   862         case CxeVideoCaptureControl::Paused:

   863             stop();

   864             break;

   865         case CxeVideoCaptureControl::Idle:

   866         case CxeVideoCaptureControl::Initialized:

   867         case CxeVideoCaptureControl::Preparing:

   868             mCapturePending = true;

   869             break;

   870 

   871     }

   872     CX_DEBUG_EXIT_FUNCTION();

   873 }

   874 

   875 void CxuiVideoPrecaptureView::prepareNewVideo(CxeError::Id error)

   876 {

   877     if (!error) {

   878         mEngine->initMode(Cxe::VideoMode);

   879         disconnect(mVideoCaptureControl, SIGNAL(videoComposed(CxeError::Id, const QString&)),

   880                    this, SLOT(prepareNewVideo(CxeError::Id)));

   881     } else {

   882         emit errorEncountered(error);

   883     }

   884 

   885 }

   886 

   887 void CxuiVideoPrecaptureView::handleQuitClicked()

   888 {

   889     CX_DEBUG_ENTER_FUNCTION();

   890 

   891     CxeVideoCaptureControl::State state = mVideoCaptureControl->state();

   892     if (state == CxeVideoCaptureControl::Recording ||

   893         state == CxeVideoCaptureControl::Paused) {

   894         // Disable going to post-capture when video capture control goes to stopping state.

   895         disconnect(mVideoCaptureControl, SIGNAL(stateChanged(CxeVideoCaptureControl::State, CxeError::Id)),

   896                    this, SLOT(handleVideoStateChanged(CxeVideoCaptureControl::State,CxeError::Id)));

   897         mVideoCaptureControl->stop();

   898         mElapsedTimer.stop();

   899     }

   900 

   901     QCoreApplication::exit();

   902 

   903     CX_DEBUG_EXIT_FUNCTION();

   904 }

   905 

   906 void CxuiVideoPrecaptureView::launchVideoScenePopup()

   907 {

   908     CX_DEBUG_ENTER_FUNCTION();

   909     hideControls();

   910     emit showScenesView();

   911     CX_DEBUG_EXIT_FUNCTION();

   912 }

   913 

   914 

   915 /*!

   916 * Launches show-postcapture setting pop-up

   917 */

   918 void CxuiVideoPrecaptureView::launchSetting()

   919 {

   920     CX_DEBUG_ENTER_FUNCTION();

   921 

   922     QObject *action = sender();

   923 

   924     if (action) {

   925         QString settingsKey = action->property(PROPERTY_KEY_SETTING_ID).toString();

   926         CX_DEBUG(("settingsKey=%s", settingsKey.toAscii().constData()));

   927         launchSettingsDialog(action);

   928     }

   929 

   930     CX_DEBUG_EXIT_FUNCTION();

   931 }

   932 

   933 /*!

   934 * Handle change in setting value. Update UI to reflect new value.

   935 */

   936 void CxuiVideoPrecaptureView::handleSettingValueChanged(const QString& key, QVariant newValue)

   937 {

   938     CX_DEBUG_ENTER_FUNCTION();

   939 

   940     Q_UNUSED(newValue);

   941     // Ignored if not in video mode.

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

   943         if (key == CxeSettingIds::VIDEO_QUALITY) {

   944             // update the quality indicator on screen

   945             updateQualityIcon();

   946 

   947             // update video remaining time counter when video quality is changed

   948             updateTimeLabels();

   949         } else if (key == CxeSettingIds::GEOTAGGING) {

   950             reloadIndicatorWidgets();

   951         } else if (key == CxeSettingIds::VIDEO_MUTE_SETTING) {

   952             reloadIndicatorWidgets();

   953         }

   954     }

   955 

   956     CX_DEBUG_EXIT_FUNCTION();

   957 }

   958 

   959 /*!

   960 * Handle scene mode change.

   961 * @param scene The new active scene mode.

   962 */

   963 void CxuiVideoPrecaptureView::handleSceneChanged(const QVariant &scene)

   964 {

   965     CX_DEBUG_ENTER_FUNCTION();

   966     // Ignore if not in video mode.

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

   968         // Update toolbar scene mode icon.

   969         updateSceneIcon(scene.toString());

   970     }

   971 

   972     CX_DEBUG_EXIT_FUNCTION();

   973 }

   974 

   975 /*!

   976  * Overridden eventFilter() to restart the pause timer.

   977  */

   978 bool CxuiVideoPrecaptureView::eventFilter(QObject *object, QEvent *event)

   979 {

   980 

   981     if (mVideoCaptureControl && mVideoCaptureControl->state() == CxeVideoCaptureControl::Paused) {

   982         // restart the timer if the screen is touched and we are in paused state

   983         switch (event->type())

   984         {

   985         case QEvent::GraphicsSceneMouseRelease:

   986             mPauseTimer.start();

   987             break;

   988         case QEvent::GraphicsSceneMousePress:

   989             mPauseTimer.stop();

   990             break;

   991         default:

   992             break;

   993         }

   994     }

   995     return CxuiPrecaptureView::eventFilter(object, event);

   996 }

   997 

   998 //end of file

   999