camerauis/cameraxui/cxui/src/cxuiselftimer.cpp
branchRCL_3
changeset 53 61bc0f252b2b
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraxui/cxui/src/cxuiselftimer.cpp	Tue Aug 31 15:03:46 2010 +0300
@@ -0,0 +1,417 @@
+/*
+* 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"
+* 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 <QGraphicsWidget>
+#include <hblabel.h>
+#include <hbpushbutton.h>
+
+#ifdef Q_OS_SYMBIAN
+#include <ProfileEngineSDKCRKeys.h>
+#endif
+
+#include "cxuiselftimer.h"
+#include "cxutils.h"
+#include "cxuienums.h"
+#include "cxuidocumentloader.h"
+#include "cxesettings.h"
+#include "cxenamespace.h" // CxeSettingIds
+#include "cxeerror.h"
+#include "cxeexception.h"
+
+using namespace CxUiLayout;
+
+/*!
+    \class CxuiSelfTimer
+    \brief Class for handling selftimer countdown.
+
+    CxuiSelfTimer class handles the selftimer countdown and updates widgets
+    accordingly.
+*/
+
+// constants
+
+const int CONTINUOUS_POSTCAPTURE    = -1;
+const int UNKNOWN                   = -99;
+
+const static QString SELFTIMER_SOUND = "z:\\system\\sounds\\digital\\selftimer.wav";
+
+CxuiSelfTimer::CxuiSelfTimer(CxeSettings &settings)
+:  mDelay(-1),
+   mCounter(0),
+   mTimer(this),
+   mOldPostCaptureTimeOut(UNKNOWN),
+   mWidgetContainer(NULL),
+   mTimerLabel(NULL),
+   mCancelButton(NULL),
+   mStartButton(NULL),
+   mSettings(settings),
+   mSound(SELFTIMER_SOUND),
+   mUseSound(true)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    connect(&mTimer, SIGNAL(timeout()), this, SLOT(timeout()));
+    mTimer.setSingleShot(false);
+
+    // connect to capture sound signal in order to monitor
+    // warning tone changes
+    connect(&mSettings,
+            SIGNAL(settingValueChanged(long int, unsigned long int, QVariant)),
+            this, SLOT(enableSound(long int, unsigned long int, QVariant)));
+
+    // get initial warning tone value from profile
+    QVariant value(0);
+
+#ifdef Q_OS_SYMBIAN
+    // get current profile setting for using camerasound
+    // camera sound follows warning tone setting
+    unsigned long int key = KProEngActiveWarningTones;
+    long int uid = KCRUidProfileEngine.iUid;
+    mSettings.get(uid, key, Cxe::Repository, value);
+#endif
+
+    // possible values are:
+    // 0 -> warning tones off
+    // 1 -> warning tones on
+    mUseSound = (value.toInt() == 1);
+    CX_DEBUG(("Warning tones enabled [%d]", value.toInt()));
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+CxuiSelfTimer::~CxuiSelfTimer()
+{
+    CX_DEBUG_IN_FUNCTION();
+}
+
+/*!
+    Get pointers to the UI widgets from the documentloader.
+
+    \param documentLoader Pointer to a CxuiDocumentLoader instance that has
+    loaded the docml containing selftimer widgets.
+ */
+void CxuiSelfTimer::loadSelftimerWidgets(CxuiDocumentLoader *documentLoader) {
+
+    if (documentLoader) {
+
+        QGraphicsWidget *widget = NULL;
+        
+        widget = documentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_CONTAINER);
+        mWidgetContainer = qobject_cast<HbWidget *>(widget);
+        CX_DEBUG_ASSERT(mWidgetContainer);
+
+        widget = documentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_COUNTER);
+        mTimerLabel = qobject_cast<HbLabel *>(widget);
+        CX_DEBUG_ASSERT(mTimerLabel);
+
+        widget = documentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_CANCEL_BUTTON);
+        mCancelButton = qobject_cast<HbPushButton *>(widget);
+        CX_DEBUG_ASSERT(mCancelButton);
+
+        widget = documentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_START_BUTTON);
+        mStartButton = qobject_cast<HbPushButton *>(widget);
+        CX_DEBUG_ASSERT(mStartButton);
+
+        connect(mCancelButton, SIGNAL(released()), this, SLOT(cancel()));
+        connect(mStartButton, SIGNAL(released()), this, SLOT(startTimer()));
+
+        updateWidgets();
+    }
+}
+
+/*!
+    Method for checking if selftimer is enabled.
+    Selftimer is enabled/disabled using slots cancel() and changeTimeout()
+    \return True if selftimer is enabled
+
+    \sa changeTimeOut(int seconds)
+    \sa cancel()
+ */
+bool CxuiSelfTimer::isEnabled()
+{
+    return (mDelay >= 0);
+}
+
+/*!
+    Method for checking if selftimer countdown is ongoing.
+    Countdown is started with by calling startTimer().
+    \return True if selftimer is active.
+
+    \sa startTimer()
+ */
+bool CxuiSelfTimer::isOngoing()
+{
+    return mTimer.isActive();
+}
+
+/*!
+   Returns current timeout value of selftimer.
+ */
+int CxuiSelfTimer::getTimeout() const
+{
+    return mDelay;
+}
+
+/*! Slot for canceling the selftimer.
+    Disables selftimer, sets back the postcapturetimeout if it
+    has been changed by selftimer and emits signal to notify interested
+    parties that cancel has been called.
+
+    \sa startTimer()
+ */
+void CxuiSelfTimer::cancel()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    // show postcapture setting is changed when selftimer is started
+    // if it has been changed, then change it back
+    if (mOldPostCaptureTimeOut != UNKNOWN) {
+        mSettings.set(CxeSettingIds::STILL_SHOWCAPTURED, mOldPostCaptureTimeOut);
+        mOldPostCaptureTimeOut = UNKNOWN;
+    }
+
+    // Reset counter and stop any ongoing action.
+    // Start button back to enabled.
+    reset(false);
+    // Disable self timer
+    mDelay = -1;
+
+    // Update UI components.
+    updateWidgets();
+
+    // Signal others about cancellation.
+    emit cancelled();
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+    Slot for handling timer timouts. Counter will be updated and when
+    selftimer countdown is finished, timerFinished() signal is emitted.
+ */
+void CxuiSelfTimer::timeout()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    // Update seconds passed.
+    ++mCounter;
+
+    // Update now to have better looking user experience,
+    // especially when counter elapses: "0" is updated before emitting event,
+    // so the UI seems to update smoother.
+    updateWidgets();
+
+    playSound();
+
+    // Check if timer ran out
+    if (mCounter >= mDelay) {
+        mTimer.stop();
+        mSound.stop();
+        hideWidgets();
+        emit timerFinished();
+    }
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+ * Play selftimer sound.
+ */
+void CxuiSelfTimer::playSound()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    // play sounds only if warning tones are enabled
+    if (mUseSound) {
+        CX_DEBUG(("play"));
+
+        int timeLeft = mDelay - mCounter;
+
+        if (timeLeft <= 3) {
+            // play as fast as we can
+            if (mSound.isFinished()) {
+                mSound.setLoops(-1);
+                mSound.play();
+            }
+        } else if (timeLeft <= 10) {
+            // play every second
+            mSound.setLoops(1);
+            mSound.play();
+        } else {
+            // play once every two seconds
+            if (mCounter%2) {
+                mSound.setLoops(1);
+                mSound.play();
+            }
+        }
+    }
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+     Slot for starting the countdown. Show postcapture setting is set to
+     continuous and previous value stored. Timer is started.
+
+     \sa cancel()
+ */
+void CxuiSelfTimer::startTimer()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    // get the current postcapture timeout
+    try {
+        mOldPostCaptureTimeOut = mSettings.get<int>(CxeSettingIds::STILL_SHOWCAPTURED);
+        // set continuous postcapture (view is visible until dismissed)
+        mSettings.set(CxeSettingIds::STILL_SHOWCAPTURED, CONTINUOUS_POSTCAPTURE);
+    } catch (CxeException &e) {
+        // if there was an error, don't modify the postcapture setting
+        mOldPostCaptureTimeOut = UNKNOWN;
+    }
+
+    if (mStartButton) {
+        mStartButton->setEnabled(false);
+    }
+
+    // start countdown
+    mCounter = 0;
+    playSound();
+    mTimer.start(1000); // 1000 milliseconds == 1 second
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+    Slot for receiving changes to the selftimer countdown timeout.
+
+    \param seconds Amount of seconds for the selftimer countdown. If the value is
+    0 then selftimer is disabled.
+ */
+void CxuiSelfTimer::changeTimeOut(int seconds)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    // make sure that timer is not running (should not be)
+    reset(false);
+
+    // set the new timer value
+    // if incoming value is 0, it means that the selftimer is disabled
+    if (seconds > 0) {
+        mDelay = seconds;
+    } else {
+        //value == 0
+        mDelay = -1;
+    }
+
+    updateWidgets();
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*! Resets the selftimer countdown.
+    Countdown is stopped, and set back to starting value. Start button is set enabled.
+    @param update Update the UI widgets if true, skip update if false.
+    Can be used to by-pass the UI update if planned to do shortly again.
+ */
+void CxuiSelfTimer::reset(bool update)
+{
+    // Stop timer and reset counter.
+    mTimer.stop();
+    mSound.stop();
+    mCounter = 0;
+
+    // Set start buttonback to enabled.
+    if (mStartButton) {
+        mStartButton->setEnabled(true);
+    }
+
+    // Update UI if requested.
+    if(update) {
+        updateWidgets();
+    }
+}
+
+/*! Updates the selftimer widgets
+    Changes the visibility of the selftimer widgets (counter and cancel button)
+    based on the timeoutValue. Updates the counter value.
+ */
+void CxuiSelfTimer::updateWidgets()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    int remaining(mDelay - mCounter);
+    CX_DEBUG(("remaining time %d", remaining));
+
+    if (mTimerLabel) {
+        mTimerLabel->setPlainText(QString::number(remaining));
+    }
+
+    if (isEnabled()) {
+        showWidgets();
+    } else {
+        hideWidgets();
+    }
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+    Shows the selftimer widgets.
+ */
+void CxuiSelfTimer::showWidgets()
+{
+    if (mWidgetContainer){
+        mWidgetContainer->show();
+    }
+
+
+}
+
+/*!
+    Hides the selftimer widgets.
+ */
+void CxuiSelfTimer::hideWidgets()
+{
+    if (mWidgetContainer){
+        mWidgetContainer->hide();
+    }
+
+}
+
+/*!
+ * Enables or disables the selftimer sound.
+ * \param uid UID of the changed setting
+ * \param key Key of the changed setting
+ * \param value New setting value
+ */
+void CxuiSelfTimer::enableSound(long int uid, unsigned long int key, QVariant value)
+{
+#ifdef Q_OS_SYMBIAN
+    // selftimer is only interested in warning tones
+    if (uid == KCRUidProfileEngine.iUid && key == KProEngActiveWarningTones) {
+        CX_DEBUG_IN_FUNCTION();
+        // possible values are:
+        // 0 -> warning tones off
+        // 1 -> warning tones on
+        mUseSound = (value.toInt() == 1);
+    }
+#else
+    Q_UNUSED(uid);
+    Q_UNUSED(key);
+    Q_UNUSED(value);
+#endif
+}
+