--- a/camerauis/cameraxui/cxengine/inc/cxecameradevicecontrolsymbian.h Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/inc/cxecameradevicecontrolsymbian.h Wed Aug 18 14:02:45 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"
@@ -18,6 +18,7 @@
#define CXECAMERADEVICECONTROLSYMBIAN_H
// Include Files
+#include <QTimer>
#include "cxecameradevicecontrol.h"
#include "cxecameradevice.h"
@@ -77,6 +78,9 @@
void deviceReady(); // device is ready to prepared in either still or video mode
void vfFrameReady(MCameraBuffer* buffer, int error);
+private slots:
+ void doReserve();
+
protected: // Protected data so that unit test cases can replace
// mCameraDevice with a fake implementation.
CxeCameraDevice *mCameraDevice; // own
@@ -84,6 +88,7 @@
protected: // data
Cxe::CameraIndex mCameraIndex;
Cxe::CameraMode mCameraMode;
+ QTimer mReserveTimer;
};
#endif // CXECAMERADEVICECONTROLSYMBIAN_H
--- a/camerauis/cameraxui/cxengine/inc/cxegeotaggingtrail_symbian_p.h Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/inc/cxegeotaggingtrail_symbian_p.h Wed Aug 18 14:02:45 2010 +0300
@@ -62,7 +62,7 @@
void handleSettingValueChanged(const QString&, QVariant);
void handleGeoTaggingPropertyEvent(long int uid, unsigned long int key, QVariant value);
void timeout();
- void stop(bool closeSession = false);
+ void stop();
private:
CxeStillCaptureControl &mStillCaptureControl;
--- a/camerauis/cameraxui/cxengine/src/cxecameradevicecontrolsymbian.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/src/cxecameradevicecontrolsymbian.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -45,6 +45,10 @@
mCameraDevice = new CxeCameraDevice();
+ //!@todo Temporary delay before reserving camera to avoid timing issues
+ connect(&mReserveTimer, SIGNAL(timeout()), this, SLOT(doReserve()));
+ mReserveTimer.setSingleShot(true);
+
CX_DEBUG_EXIT_FUNCTION();
}
@@ -76,13 +80,14 @@
void CxeCameraDeviceControlSymbian::reserve()
{
CX_DEBUG_ENTER_FUNCTION();
-
- CX_DEBUG_ASSERT(mCameraDevice && mCameraDevice->camera());
+ CX_ASSERT_ALWAYS(mCameraDevice);
if (state() == Idle) {
setState(Initializing);
- mCameraDevice->reserveCamera();
+ //!@todo Temporary delay before reserving camera to avoid timing issues
+ mReserveTimer.start(2000);
OstTrace0(camerax_performance, CXECAMERADEVICECONTROLSYMBIAN_RESERVE, "msg: e_CX_RESERVE 1");
+ CX_DEBUG(("HACK: Waiting for 2000ms before really doing reserve()"));
} else if (state() == PendingRelease) {
// if we get a reserve request and if there is a pending release
// it is just fine to continue the init operation.
@@ -94,6 +99,15 @@
CX_DEBUG_EXIT_FUNCTION();
}
+void CxeCameraDeviceControlSymbian::doReserve()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+ CX_ASSERT_ALWAYS(mCameraDevice);
+ mCameraDevice->reserveCamera();
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+
void CxeCameraDeviceControlSymbian::powerOn()
{
CX_DEBUG_ENTER_FUNCTION();
@@ -226,6 +240,16 @@
{
CX_DEBUG_ENTER_FUNCTION();
+ //!@todo Temporary delay before reserving camera to avoid timing issues
+ if (mReserveTimer.isActive()) {
+ // release() was called when the timer was active
+ mReserveTimer.stop();
+ mCameraDevice->releaseCamera();
+ setState(Idle);
+ CX_DEBUG_EXIT_FUNCTION();
+ return;
+ }
+
if (state() == Idle) {
// nothing to do
return;
--- a/camerauis/cameraxui/cxengine/src/cxegeotaggingtrail_symbian_p.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/src/cxegeotaggingtrail_symbian_p.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -74,8 +74,8 @@
{
CX_DEBUG_ENTER_FUNCTION();
- // stop trail and close location utility session
- stop(true);
+ // close the location utility session
+ mLocationTrail.Close();
CX_DEBUG_EXIT_FUNCTION();
}
@@ -113,7 +113,7 @@
if (err) {
CX_DEBUG(("CxeGeoTaggingTrailPrivate::start <> FAILED: error = %d ", err));
- stop(true);
+ mLocationTrail.Close();
}
} else {
// geotagging setting off, do nothing.
@@ -125,9 +125,8 @@
/*!
* Stop location trail.
-* @ param closeSession, indicates if we are willing to close the location utility session.
*/
-void CxeGeoTaggingTrailPrivate::stop(bool closeSession)
+void CxeGeoTaggingTrailPrivate::stop()
{
CX_DEBUG_ENTER_FUNCTION();
@@ -143,17 +142,9 @@
mLocationTrail.StopLocationTrail();
setState(CxeGeoTaggingTrail::Connected);
}
-
- if (closeSession && state() == CxeGeoTaggingTrail::Connected) {
- CX_DEBUG(("CxeGeoTaggingTrailPrivate <> disconnect location trail utility"));
- mLocationTrail.Close();
- setState(CxeGeoTaggingTrail::NotConnected);
- }
+
} else {
// not ready to stop the location trail, TrailStarted the timer.
- if (!mPendingStopTrailSession) {
- mPendingStopTrailSession = closeSession;
- }
mStopLocationTrailTimer.start(STOP_TRAIL_INTERVAL);
}
@@ -188,7 +179,7 @@
CX_DEBUG_ENTER_FUNCTION();
// stop the pending location trail utility
- stop(mPendingStopTrailSession);
+ stop();
CX_DEBUG_EXIT_FUNCTION();
}
@@ -228,8 +219,8 @@
QVariant value)
{
CX_DEBUG_ENTER_FUNCTION();
-
- if (uid == KPSUidLocationTrail.iUid && key == KLocationTrailState) {
+ bool stateOk = (state() == CxeGeoTaggingTrail::DataAvailable || state() == CxeGeoTaggingTrail::TrailStarted);
+ if (uid == KPSUidLocationTrail.iUid && key == KLocationTrailState && stateOk) {
CX_DEBUG(("Location trail: new state = %d ", value.toInt()));
RLocationTrail::TTrailState newState =
--- a/camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakeautofocuscontrol.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakeautofocuscontrol.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -27,6 +27,8 @@
{
CX_DEBUG_ENTER_FUNCTION();
initializeStates();
+ qRegisterMetaType<CxeAutoFocusControl::State>("CxeAutoFocusControl::State");
+ qRegisterMetaType<CxeAutoFocusControl::Mode>("CxeAutoFocusControl::Mode");
CX_DEBUG_EXIT_FUNCTION();
}
@@ -38,6 +40,7 @@
CxeError::Id CxeFakeAutoFocusControl::start(bool soundEnabled)
{
CX_DEBUG_IN_FUNCTION();
+ Q_UNUSED(soundEnabled);
return CxeError::None;
}
--- a/camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakefilesavethread.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakefilesavethread.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -36,12 +36,20 @@
void CxeFakeFileSaveThread::handleVideoSaved(CxeError::Id status, const QString &filename)
{
+ Q_UNUSED(status);
+ Q_UNUSED(filename);
}
void CxeFakeFileSaveThread::handleSnapshotReady(CxeError::Id status, const QImage &snapshot, const QString &filename)
{
+ Q_UNUSED(status);
+ Q_UNUSED(snapshot);
+ Q_UNUSED(filename);
}
void CxeFakeFileSaveThread::handleSnapshotReady(CxeError::Id status, const QImage &snapshot, int id)
{
+ Q_UNUSED(status);
+ Q_UNUSED(snapshot);
+ Q_UNUSED(id);
}
--- a/camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakesettingsmodel.cpp Fri Jul 23 11:35:41 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,241 +0,0 @@
-/*
-* 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 "cxefakesettingsmodel.h"
-#include "cxutils.h"
-
-CxeFakeSettingsModel::CxeFakeSettingsModel()
-{
- CX_DEBUG_ENTER_FUNCTION();
-
- initDefaultCameraSettings();
- initRuntimeSettings();
-
- CX_DEBUG_EXIT_FUNCTION();
-}
-
-CxeFakeSettingsModel::~CxeFakeSettingsModel()
-{
- CX_DEBUG_IN_FUNCTION();
-}
-
-CxeError::Id CxeFakeSettingsModel::getRuntimeValue( const QString &key, QVariant &value)
-{
- CX_DEBUG_ENTER_FUNCTION();
- CxeError::Id err = CxeError::None;
-
- // read run-time configuration value
- if (mRuntimeSettings.contains(key)) {
- value = qVariantFromValue<QVariantList > (mRuntimeSettings.value(key));
- } else {
- err = CxeError::NotFound;
- }
-
- CX_DEBUG_EXIT_FUNCTION();
- return err;
-}
-
-CxeError::Id CxeFakeSettingsModel::getSettingValue( const QString &key, QVariant &value)
-{
- CX_DEBUG_ENTER_FUNCTION();
- CxeError::Id err = CxeError::None;
-
- // read run-time configuration value
- if (mSettingStore.contains(key)) {
- value = mSettingStore[key];
- } else {
- err = CxeError::NotFound;
- }
-
- CX_DEBUG_EXIT_FUNCTION();
- return err;
-}
-
-void CxeFakeSettingsModel::getSettingValue(long int uid, unsigned long int key, Cxe::SettingKeyType type, QVariant &value)
-{
- Q_UNUSED(uid);
- Q_UNUSED(key);
- Q_UNUSED(type);
- Q_UNUSED(value);
-
- // no support yet
- CX_DEBUG_IN_FUNCTION();
-}
-
-
-/*! This is a helper method for this fake class that can be used to set key-value pairs
- * to local mStore database. Key-value pairs don't have to refer any real values used
- * in camera application as the fake class is used only for testing purposes
- */
-CxeError::Id CxeFakeSettingsModel::set(const QString &key, QVariant value)
-{
- CX_DEBUG_ENTER_FUNCTION();
- CxeError::Id error = CxeError::None;
-
- if(mSettingStore.contains(key)) {
- mSettingStore.insert(key, value);
- } else {
- error = CxeError::NotFound;
- }
-
-
-
- CX_DEBUG_EXIT_FUNCTION();
- return error;
-}
-
-CxeError::Id CxeFakeSettingsModel::setImageScene(const QString &newScene)
-{
- mDummyImageScene.clear();
-
- // image scene mode key values
- if(newScene == Cxe::IMAGE_SCENE_AUTO) {
- mDummyImageScene.insert(CxeSettingIds::SCENE_ID, Cxe::IMAGE_SCENE_AUTO);
- }
- else if(newScene == Cxe::IMAGE_SCENE_PORTRAIT) {
- mDummyImageScene.insert(CxeSettingIds::SCENE_ID, Cxe::IMAGE_SCENE_PORTRAIT);
- }
- else if(newScene == Cxe::IMAGE_SCENE_SCENERY) {
- mDummyImageScene.insert(CxeSettingIds::SCENE_ID, Cxe::IMAGE_SCENE_SCENERY);
- }
- else if(newScene == Cxe::IMAGE_SCENE_MACRO) {
- mDummyImageScene.insert(CxeSettingIds::SCENE_ID, Cxe::IMAGE_SCENE_MACRO);
- }
- else if(newScene == Cxe::IMAGE_SCENE_SPORTS) {
- mDummyImageScene.insert(CxeSettingIds::SCENE_ID, Cxe::IMAGE_SCENE_SPORTS);
- }
- else if(newScene == Cxe::IMAGE_SCENE_NIGHT) {
- mDummyImageScene.insert(CxeSettingIds::SCENE_ID, Cxe::IMAGE_SCENE_NIGHT);
- }
- else if(newScene == Cxe::IMAGE_SCENE_NIGHTPORTRAIT) {
- mDummyImageScene.insert(CxeSettingIds::SCENE_ID, Cxe::IMAGE_SCENE_NIGHTPORTRAIT);
- }
- else {
- return CxeError::NotFound;
- }
-
- return CxeError::None;
-}
-
-CxeError::Id CxeFakeSettingsModel::setVideoScene(const QString &newScene)
-{
- mDummyVideoScene.clear();
-
- // image scene mode key values
- if(newScene == Cxe::VIDEO_SCENE_AUTO) {
- mDummyVideoScene.insert(CxeSettingIds::SCENE_ID, Cxe::VIDEO_SCENE_AUTO);
- }
- else if(newScene == Cxe::VIDEO_SCENE_NIGHTPORTRAIT) {
- mDummyVideoScene.insert(CxeSettingIds::SCENE_ID, Cxe::VIDEO_SCENE_NIGHTPORTRAIT);
- }
- else if(newScene == Cxe::VIDEO_SCENE_LOWLIGHT) {
- mDummyVideoScene.insert(CxeSettingIds::SCENE_ID, Cxe::VIDEO_SCENE_LOWLIGHT);
- }
- else if(newScene == Cxe::VIDEO_SCENE_NIGHT) {
- mDummyVideoScene.insert(CxeSettingIds::SCENE_ID, Cxe::VIDEO_SCENE_NIGHT);
- }
- else {
- return CxeError::NotFound;
- }
-
- return CxeError::None;
-}
-
-
-CxeScene& CxeFakeSettingsModel::currentImageScene()
-{
- return mDummyImageScene;
-}
-
-
-CxeScene& CxeFakeSettingsModel::currentVideoScene()
-{
- return mDummyVideoScene;
-}
-
-
-void CxeFakeSettingsModel::cameraModeChanged(Cxe::CameraMode newMode)
-{
- mDummyCameraMode = newMode;
-}
-
-
-/* This helper method initializes fake store for default camera settings
- */
-void CxeFakeSettingsModel::initDefaultCameraSettings()
-{
- CX_DEBUG_ENTER_FUNCTION();
- mSettingStore.insert(CxeSettingIds::FNAME_FOLDER_SUFFIX, QVariant(1));
- mSettingStore.insert(CxeSettingIds::FNAME_MONTH_FOLDER, QVariant(1));
- mSettingStore.insert(CxeSettingIds::FNAME_IMAGE_COUNTER, QVariant(1));
- mSettingStore.insert(CxeSettingIds::FNAME_VIDEO_COUNTER, QVariant(1));
- mSettingStore.insert(CxeSettingIds::COLOR_TONE, QVariant(1));
- mSettingStore.insert(CxeSettingIds::SHARPNESS, QVariant(1));
- mSettingStore.insert(CxeSettingIds::CONTRAST, QVariant(1));
- mSettingStore.insert(CxeSettingIds::BRIGHTNESS, QVariant(1));
- mSettingStore.insert(CxeSettingIds::EV_COMPENSATION_VALUE, QVariant(1));
- mSettingStore.insert(CxeSettingIds::EXPOSURE_MODE, QVariant(1));
- mSettingStore.insert(CxeSettingIds::FLASH_MODE, QVariant(1));
- mSettingStore.insert(CxeSettingIds::FOCAL_RANGE, QVariant(1));
- mSettingStore.insert(CxeSettingIds::FRAME_RATE, QVariant(1));
- mSettingStore.insert(CxeSettingIds::IMAGE_QUALITY, QVariant(1));
- mSettingStore.insert(CxeSettingIds::IMAGE_SCENE, QVariant(1));
- mSettingStore.insert(CxeSettingIds::LIGHT_SENSITIVITY, QVariant(1));
- mSettingStore.insert(CxeSettingIds::SCENE_ID, QVariant(1));
- mSettingStore.insert(CxeSettingIds::SECONDARY_CAMERA, QVariant(1));
- mSettingStore.insert(CxeSettingIds::SELF_TIMER, QVariant(1));
- mSettingStore.insert(CxeSettingIds::VIDEO_SCENE, QVariant(1));
- mSettingStore.insert(CxeSettingIds::WHITE_BALANCE, QVariant(1));
-
- // default scene
- setImageScene(Cxe::IMAGE_SCENE_AUTO);
- setVideoScene(Cxe::VIDEO_SCENE_AUTO);
-
- CX_DEBUG_EXIT_FUNCTION();
-}
-
-
-
-/* This helper method initializes fake runtime setting values for the keys
- */
-void CxeFakeSettingsModel::initRuntimeSettings()
-{
- CX_DEBUG_ENTER_FUNCTION();
-
- QVariantList supported;
- supported.append(QVariant(1));
-
- QVariantList notSupported;
- notSupported.append(QVariant(0));
-
- QVariantList values;
- values.append(QVariant(1));
- values.append(QVariant(2));
- values.append(QVariant(3));
-
- mRuntimeSettings.insert(CxeRuntimeKeys::PRIMARY_CAMERA_CAPTURE_KEYS, supported);
- mRuntimeSettings.insert(CxeRuntimeKeys::PRIMARY_CAMERA_AUTOFOCUS_KEYS, supported);
- mRuntimeSettings.insert(CxeRuntimeKeys::SECONDARY_CAMERA_CAPTURE_KEYS, notSupported);
- mRuntimeSettings.insert(CxeRuntimeKeys::FREE_MEMORY_LEVELS, notSupported);
- mRuntimeSettings.insert(CxeRuntimeKeys::STILL_MAX_ZOOM_LIMITS, values);
- mRuntimeSettings.insert(CxeRuntimeKeys::VIDEO_MAX_ZOOM_LIMITS, values);
-
- CX_DEBUG_EXIT_FUNCTION();
-}
-
-
-// end of file
--- a/camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakesettingsmodel.h Fri Jul 23 11:35:41 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,66 +0,0 @@
-/*
-* 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:
-*
-*/
-#ifndef CXEFAKESETTINGSMODEL_H
-#define CXEFAKESETTINGSMODEL_H
-
-#include <QHash>
-#include "cxesettingsmodel.h"
-
-class CxeFakeSettingsModel : public CxeSettingsModel
-{
-
-public:
-
- CxeFakeSettingsModel();
- ~CxeFakeSettingsModel();
-
- void reset() {};
- CxeError::Id getSettingValue(const QString &key, QVariant &value);
- void getSettingValue(long int uid, unsigned long int key, Cxe::SettingKeyType type, QVariant &value);
- CxeError::Id getRuntimeValue(const QString &key, QVariant &value);
-
- CxeError::Id set(const QString &key,const QVariant newValue);
- CxeScene& currentImageScene();
- CxeScene& currentVideoScene();
- void cameraModeChanged(Cxe::CameraMode newMode);
- CxeError::Id setImageScene(const QString &newScene);
- CxeError::Id setVideoScene(const QString &newScene);
-
-public: // own helper methods
- void setRuntimeValues(QString &key, QList<QVariant> value);
- void initDefaultCameraSettings();
- void initRuntimeSettings();
- void testSetCurrenImageScene();
- void testSetCurrenVideoScene();
-
- Cxe::CameraMode getDummyCameraMode() {return mDummyCameraMode;}
-
-private:
-
- QHash<QString, QVariant> mSettingStore;
- QHash<QString, QVariantList> mRuntimeSettings;
- CxeScene mDummyImageScene;
- CxeScene mDummyVideoScene;
- Cxe::CameraMode mDummyCameraMode;
-};
-
-#endif // CXEFAKESETTINGSMODEL_H
-
-
-
-
-
--- a/camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakesettingsstore.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakesettingsstore.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -24,13 +24,23 @@
CxeFakeSettingsStore::CxeFakeSettingsStore()
{
- // all supported settings are initialized here.
+ resetSettings();
+}
+
+CxeFakeSettingsStore::~CxeFakeSettingsStore()
+{
+}
+
+void CxeFakeSettingsStore::resetSettings()
+{
+ // This part should be synchronized with the current settings
+ // supported by camera and defined in cxenamespace
mSettingKeyHash.clear();
mSettingKeyHash.insert(CxeSettingIds::FNAME_FOLDER_SUFFIX, QVariant("_Nokia"));
mSettingKeyHash.insert(CxeSettingIds::FNAME_MONTH_FOLDER, QVariant("08042009"));
mSettingKeyHash.insert(CxeSettingIds::FNAME_IMAGE_COUNTER, QVariant(0));
mSettingKeyHash.insert(CxeSettingIds::FNAME_VIDEO_COUNTER, QVariant(0));
-
+
mSettingKeyHash.insert(CxeSettingIds::CAMERA_MODE, QVariant(0));
mSettingKeyHash.insert(CxeSettingIds::FLASH_MODE, QVariant(0));
mSettingKeyHash.insert(CxeSettingIds::IMAGE_SCENE, QVariant("image_scene_auto"));
@@ -38,17 +48,27 @@
mSettingKeyHash.insert(CxeSettingIds::STILL_SHOWCAPTURED, QVariant(0));
mSettingKeyHash.insert(CxeSettingIds::VIDEO_SHOWCAPTURED, QVariant(0));
mSettingKeyHash.insert(CxeSettingIds::VIDEO_MUTE_SETTING, QVariant(0));
-
+
mSettingKeyHash.insert(CxeSettingIds::GEOTAGGING, QVariant(0));
mSettingKeyHash.insert(CxeSettingIds::GEOTAGGING_DISCLAIMER, QVariant(1));
mSettingKeyHash.insert(CxeSettingIds::FACE_TRACKING, QVariant(1));
mSettingKeyHash.insert(CxeSettingIds::IMAGE_QUALITY, QVariant(0));
mSettingKeyHash.insert(CxeSettingIds::VIDEO_QUALITY, QVariant(0));
-}
-
-CxeFakeSettingsStore::~CxeFakeSettingsStore()
-{
+ mSettingKeyHash.insert(CxeSettingIds::FOCAL_RANGE, QVariant(0));
+ mSettingKeyHash.insert(CxeSettingIds::WHITE_BALANCE, QVariant(0));
+ mSettingKeyHash.insert(CxeSettingIds::LIGHT_SENSITIVITY, QVariant(0));
+ mSettingKeyHash.insert(CxeSettingIds::EXPOSURE_MODE, QVariant(0));
+ mSettingKeyHash.insert(CxeSettingIds::SHARPNESS, QVariant(0));
+ mSettingKeyHash.insert(CxeSettingIds::COLOR_TONE, QVariant(0));
+ mSettingKeyHash.insert(CxeSettingIds::EV_COMPENSATION_VALUE, QVariant(0));
+ mSettingKeyHash.insert(CxeSettingIds::CONTRAST, QVariant(0));
+ mSettingKeyHash.insert(CxeSettingIds::BRIGHTNESS, QVariant(0));
+ mSettingKeyHash.insert(CxeSettingIds::FRAME_RATE, QVariant(0));
+ mSettingKeyHash.insert(CxeSettingIds::SCENE_ID, QVariant(0));
+ mSettingKeyHash.insert(CxeSettingIds::SECONDARY_CAMERA, QVariant(0));
+ mSettingKeyHash.insert(CxeSettingIds::SELF_TIMER, QVariant(0));
+ mSettingKeyHash.insert(CxeSettingIds::CAPTURE_SOUND_ALWAYS_ON, QVariant(0));
}
/*!
@@ -61,8 +81,8 @@
CxeError::Id error = CxeError::None;
if(mSettingKeyHash.contains(key)) {
value = mSettingKeyHash[key];
- } else if(mRuntimeKeyHash.contains(key)) {
- value = mRuntimeKeyHash[key];
+ } else if(mVariationKeyHash.contains(key)) {
+ value = mVariationKeyHash[key];
} else {
error = CxeError::NotFound;
}
@@ -82,29 +102,30 @@
Q_UNUSED(uid);
Q_UNUSED(key);
Q_UNUSED(type);
- Q_UNUSED(value);
- // no support yet
+ // Instead of emulating cenrep functionality
+ // we just return a test value for verification
+ value = 42;
}
/*!
-* Reads/loads all run-time settings values from cenrep
-* @param QList<QString> contains list of all runtime key ids which we use to load values from cenrep.
+* Reads/loads all variation settings values from cenrep
+* @param QList<QString> contains list of all variation key ids which we use to load values from cenrep.
* returns: QHash container, "contains" values associated with each key that are read from cenrep
-* NOTE: loading runtime settings should be done only ONCE at start-up.
+* NOTE: loading variation settings should be done only ONCE at start-up.
*/
-QHash<QString, QVariantList> CxeFakeSettingsStore::loadRuntimeSettings(QList<QString>& keylist)
+QHash<QString, QVariantList> CxeFakeSettingsStore::loadVariationSettings(QList<QString> &settingKeys)
{
QVariant data;
CxeError::Id err = CxeError::None;
QVariantList list;
QHash<QString, QVariantList> settings;
- mRuntimeKeyHash.clear();
+ mVariationKeyHash.clear();
- foreach (QString key, keylist) {
+ foreach (QString key, settingKeys) {
// before we read from get function we set values to the key
- mRuntimeKeyHash.insert(key, QVariant(1));
+ mVariationKeyHash.insert(key, QVariant(1));
// read the data from cenrep
err = get(key, data);
@@ -141,5 +162,6 @@
*/
void CxeFakeSettingsStore::reset()
{
+ resetSettings();
}
--- a/camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakesettingsstore.h Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakesettingsstore.h Wed Aug 18 14:02:45 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,7 @@
#ifndef CXEFAKESETTINGS_H
#define CXEFAKESETTINGS_H
-#include "cxesettingscenrepstore.h"
+#include "cxesettingsstore.h"
#include "cxeerror.h"
class CxeFakeSettingsStore : public CxeSettingsStore
@@ -25,18 +25,21 @@
public:
CxeFakeSettingsStore();
- ~CxeFakeSettingsStore();
+ ~CxeFakeSettingsStore();
public: // from base class
void reset();
- CxeError::Id get(const QString& key, QVariant &value);
- void startMonitoring(long int uid, unsigned long int key, Cxe::SettingKeyType type, QVariant &value);
- CxeError::Id set(const QString& key,const QVariant newValue);
- QHash<QString, QVariantList> loadRuntimeSettings(QList<QString>& keylist);
+ CxeError::Id get(const QString& key, QVariant &value);
+ void startMonitoring(long int uid, unsigned long int key, Cxe::SettingKeyType type, QVariant &value);
+ CxeError::Id set(const QString& key,const QVariant newValue);
+ QHash<QString, QVariantList> loadVariationSettings(QList<QString> &settingKeys);
+
+private:
+ void resetSettings();
private:
QHash<QString, QVariant> mSettingKeyHash;
- QHash<QString, QVariant> mRuntimeKeyHash;
+ QHash<QString, QVariant> mVariationKeyHash;
};
#endif /*CXEFAKESETTINGS_H*/
--- a/camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakevideorecorderutility.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakevideorecorderutility.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -35,6 +35,8 @@
: mObserver( &aObserver )
{
CX_DEBUG_IN_FUNCTION();
+ Q_UNUSED(aPriority);
+ Q_UNUSED(aPref);
}
void CxeFakeVideoRecorderUtility::open(int cameraHandle,
@@ -45,6 +47,7 @@
const QString &/*audioType*/)
{
CX_DEBUG_ENTER_FUNCTION();
+ Q_UNUSED(cameraHandle);
mObserver->MvruoOpenComplete(KErrNone);
CX_DEBUG_EXIT_FUNCTION();
}
@@ -57,21 +60,25 @@
void CxeFakeVideoRecorderUtility::setVideoFrameRate(int rate)
{
CX_DEBUG_IN_FUNCTION();
+ Q_UNUSED(rate);
}
void CxeFakeVideoRecorderUtility::setVideoBitRate(int rate)
{
CX_DEBUG_IN_FUNCTION();
+ Q_UNUSED(rate);
}
void CxeFakeVideoRecorderUtility::setAudioEnabled(bool enabled)
{
CX_DEBUG_IN_FUNCTION();
+ Q_UNUSED(enabled);
}
void CxeFakeVideoRecorderUtility::setVideoMaxSize(int sizeInBytes)
{
CX_DEBUG_IN_FUNCTION();
+ Q_UNUSED(sizeInBytes);
}
void CxeFakeVideoRecorderUtility::close()
@@ -94,6 +101,7 @@
void CxeFakeVideoRecorderUtility::stop(bool asynchronous)
{
CX_DEBUG_ENTER_FUNCTION();
+ Q_UNUSED(asynchronous);
mObserver->MvruoRecordComplete(KErrNone);
CX_DEBUG_EXIT_FUNCTION();
}
--- a/camerauis/cameraxui/cxengine/tsrc/unit/cxeunitrunner/cxetestrunner.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/cxeunitrunner/cxetestrunner.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -41,6 +41,7 @@
#endif
QStringList tests;
+
tests << "unittest_cxevideocapturecontrolsymbian"
<< "unittest_cxestillimagesymbian"
<< "unittest_cxequalitypresetssymbian"
@@ -56,13 +57,13 @@
<< "unittest_cxeimagedataitemsymbian"
<< "unittest_cxeimagedataqueuesymbian"
<< "unittest_cxeerrormappersymbian"
- << "unittest_cxesettingsmodelimp"
<< "unittest_cxefilesavethreadsymbian"
<< "unittest_cxesettingscenrepstore"
<< "unittest_cxezoomcontrolsymbian"
<< "unittest_cxestillcapturecontrolsymbian"
<< "unittest_cxefeaturemanagerimp"
<< "unittest_cxesettingsimp"
+ << "unittest_cxescenemodestore"
<< "unittest_cxethumbnailmanagersymbian"
<< "unittest_cxeharvestercontrolsymbian"
<< "unittest_cxesettingscontrolsymbian"
@@ -70,7 +71,7 @@
<< "unittest_cxeenginesymbian"
<< "unittest_cxegeotaggingtrail"
<< "unittest_cxememorymonitor"
- << "unittest_cxediskmonitor";
+ << "unittest_cxediskmonitor";
QDir dir;
dir.mkpath(logFileFolder);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/system_include/imagingconfigmanager.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -0,0 +1,197 @@
+/*
+* Copyright (c) 2006-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: Fake implementation for the unittest_cxequalitypresetssymbian
+*
+*/
+
+
+#include "imagingconfigmanager.h"
+
+
+const int KNumberOfQualityLevels = 5;
+
+// ---------------------------------------------------------------------------
+// Constructor of CImagingConfigManager
+// ---------------------------------------------------------------------------
+//
+CImagingConfigManager::CImagingConfigManager()
+{
+ iVideoQualitySets = new CArrayFixFlat< TVideoQualitySet >( 1 );
+ iImageQualitySets = new CArrayFixFlat< TImageQualitySet >( 1 );
+
+ // init
+ for( TInt i = 0 ; i < KNumberOfQualityLevels ; i++ )
+ {
+ TVideoQualitySet videoset;
+ initVideoQualitySet(videoset);
+ iVideoQualitySets->AppendL(videoset);
+
+ TImageQualitySet imageset;
+ initImageQualitySet(imageset);
+ iImageQualitySets->AppendL(imageset);
+ }
+
+}
+
+// ---------------------------------------------------------------------------
+// Destructor of CImagingConfigManager
+// ---------------------------------------------------------------------------
+//
+CImagingConfigManager::~CImagingConfigManager()
+{
+}
+
+
+
+
+// CImagingConfigManager::NewL
+CImagingConfigManager* CImagingConfigManager::NewL()
+{
+ return new CImagingConfigManager();
+}
+
+// returns no of video quality levels
+TInt CImagingConfigManager::NumberOfVideoQualityLevels() const
+{
+ return iVideoQualitySets->Count();
+}
+
+// ---------------------------------------------------------------------------
+// Get an array of video quality levels that are in use with the current
+// product with given Camera/Display ID. If the ID is zero, then all levels
+// dispite of the ID value are returned.
+// ---------------------------------------------------------------------------
+//
+TInt CImagingConfigManager::GetVideoQualityLevelsL(
+ CArrayFixFlat<TUint>& aLevels,
+ TUint /*aCameraDisplayID*/ )
+ {
+ aLevels.Reset();
+ aLevels.SetReserveL( iVideoQualitySets->Count() );
+ for( TInt i = 0 ; i < NumberOfVideoQualityLevels() ; i++ )
+ {
+ aLevels.AppendL(
+ iVideoQualitySets->At( i ).iVideoQualitySetLevel);
+ }
+ return KErrNone;
+ }
+
+// CImagingConfigManager::GetVideoQualitySet
+TInt CImagingConfigManager::GetVideoQualitySet( TVideoQualitySet& aSet,
+ TInt /*aLevel*/,
+ TUint /*aCameraDisplayID*/ )
+ {
+ initVideoQualitySet(aSet);
+ return KErrNone;
+ }
+
+// Get all settings for Camcorder
+TInt CImagingConfigManager::GetCamcorderMMFPluginSettings(TCamcorderMMFPluginSettings& /*aSet*/) const
+ {
+ return KErrNone;
+ }
+
+
+// ---------------------------------------------------------------------------
+// Get number of defined image quality levels. This is always at least
+// KNumberOfNominalLevels but can be higher
+// ---------------------------------------------------------------------------
+//
+TInt CImagingConfigManager::NumberOfImageQualityLevels() const
+ {
+ return iImageQualitySets->Count();
+ }
+
+// ---------------------------------------------------------------------------
+// Get an array of image quality levels that are in use with the current
+// product with given Camera/Display ID. If the ID is zero, then all levels
+// dispite of the ID value are returned.
+// ---------------------------------------------------------------------------
+//
+TInt CImagingConfigManager::GetImageQualityLevelsL(
+ CArrayFixFlat<TUint>& aLevels,
+ TUint /*aCameraDisplayID*/ )
+ {
+ aLevels.Reset();
+ for( TInt i = 0 ; i < NumberOfImageQualityLevels() ; i++ )
+ {
+ aLevels.AppendL(
+ iImageQualitySets->At( i ).iImageQualitySetLevel );
+ }
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+// Get image quality set associated with the given level and Camera/Display ID
+// if it is nonzero. If the ID is zero, smallest matching ID set is returned.
+// If there is no set associated with given intermediate
+// level, then set from a nearest level is returned (dividable by
+// KBasicQualityGranularity).
+// ---------------------------------------------------------------------------
+//
+TInt CImagingConfigManager::GetImageQualitySet( TImageQualitySet& aSet,
+ TInt /*aLevel*/,
+ TUint /*aCameraDisplayID*/ )
+{
+ initImageQualitySet(aSet);
+ return KErrNone;
+}
+
+
+void CImagingConfigManager::initImageQualitySet(TImageQualitySet& aSet)
+{
+ for( TUint i = 0 ; i < KMaxStringLength ; i++ )
+ {
+ aSet.iImageFileMimeType[ i ] = NULL;
+ aSet.iImageFileExtension[ i ] = NULL;
+ }
+ aSet.iImageQualitySetLevel = 100;
+ aSet.iImageWidth = 0;
+ aSet.iImageHeight = 0;
+ aSet.iImageEncoderUID.iUid = 0;
+ aSet.iCompressionQuality = 0;
+ aSet.iEstimatedSize = 0;
+ aSet.iCameraDisplayId = 0;
+ aSet.iCamcorderVisible = 100;
+
+}
+
+void CImagingConfigManager::initVideoQualitySet(TVideoQualitySet& aSet)
+{
+ for( TUint i = 0 ; i < KMaxStringLength ; i++ )
+ {
+ aSet.iVideoFileMimeType[ i ] = NULL;
+ aSet.iVideoCodecMimeType[ i ] = NULL;
+ aSet.iPreferredSupplier[ i ] = NULL;
+ }
+ aSet.iVideoQualitySetLevel = 100;
+ aSet.iVideoWidth = 0;
+ aSet.iVideoHeight = 0;
+ aSet.iVideoFrameRate = 0.0;
+ aSet.iVideoBitRate = 0;
+ aSet.iVideoEncoderUID.iUid = 0;
+ aSet.iRandomAccessRate = 0;
+ aSet.iVideoPixelAspectRatioNum = 0;
+ aSet.iVideoPixelAspectRatioDenom = 0;
+ aSet.iAudioFourCCType = 0;
+ aSet.iAudioBitRate = 0;
+ aSet.iAudioSamplingRate = 0;
+ aSet.iAudioChannels = 0;
+ aSet.iAudioEncoderUID.iUid = 0;
+ aSet.iAVSyncStartDelay = 0;
+ aSet.iAVSyncResumeDelay = 0;
+ aSet.iCameraDisplayId = 0;
+ aSet.iCamcorderVisible = 100;
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/system_include/imagingconfigmanager.h Wed Aug 18 14:02:45 2010 +0300
@@ -0,0 +1,207 @@
+/*
+* Copyright (c) 2006-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: Fake implementation for the unittest_cxequalitypresetssymbian
+*
+*/
+
+
+#ifndef IMAGINGCONFIGMANAGER_H
+#define IMAGINGCONFIGMANAGER_H
+
+#include <mmf\common\mmfutilities.h>
+
+const TUint KMaxStringLength = 256;
+
+/*
+ * Video quality set structure
+ */
+class TVideoQualitySet
+ {
+ public:
+ // Enum level for the Quality set, used as ID
+ TUint iVideoQualitySetLevel;
+ // Video file format mime type, e.g. "video/3gpp"
+ TText8 iVideoFileMimeType[ KMaxStringLength ];
+ // Video codec mime type, e.g. "video/mp4v-es"
+ TText8 iVideoCodecMimeType[ KMaxStringLength ];
+ // Video picture width in pixels (luminance), resolution width
+ TInt iVideoWidth;
+ // Video picture height in pixels (luminance), resolution height
+ TInt iVideoHeight;
+ // Video framerate in fps
+ TReal iVideoFrameRate;
+ // Video bitrate in bps
+ TInt iVideoBitRate;
+ // Video encoder UID
+ TUid iVideoEncoderUID;
+ // Random access point rate, in pictures per second. For example, to
+ // request a random access point every ten seconds, set the value to
+ // 0.1. Random access means in video case usually that an INTRA frame
+ // is forced by the encoder to make the video accessible at that time
+ // without depending on the previous frames
+ TReal iRandomAccessRate;
+ // Video's pixel aspect ratio numerator, e.g. in PAL 16:11 pixel
+ // aspect ratio means that this value is set to 16
+ TUint iVideoPixelAspectRatioNum;
+ // Video's pixel aspect ratio denominator, e.g. in PAL 16:11 pixel
+ // aspect ratio means that this value is set to 11
+ TUint iVideoPixelAspectRatioDenom;
+ // Preferred supplier for the MMF camcorder plug-in (e.g. "Nokia")
+ TText8 iPreferredSupplier[ KMaxStringLength ];
+
+ // Audio codec FourCC, e.g. " AMR"
+ TFourCC iAudioFourCCType;
+ // Audio bitrate in bps
+ TInt iAudioBitRate;
+ // Audio sampling rate in Hz
+ TInt iAudioSamplingRate;
+ // Number of audio channels; in practice mono(1) vs stereo(2)
+ TInt iAudioChannels;
+ // Audio encoder UID
+ TUid iAudioEncoderUID;
+ // Video recording A/V sync start delay (ms), only used by
+ // CamcorderMMFPlugIn, but depends on the qualityset
+ TInt iAVSyncStartDelay;
+ // Video recording A/V sync resume delay (ms), only used by
+ // CamcorderMMFPlugIn, but depends on the qualityset
+ TInt iAVSyncResumeDelay;
+ // A non-zero ID telling unique combination of camera (primary/
+ // secondary) and/or display (cover UI/main display) and/or rotation
+ // setting combined into a number for separating each setting set
+ // type from others
+ TUint iCameraDisplayId;
+ // Camcorder specific field that can be either 1(true) or 0(false)
+ // meaning if the current quality settings set should be shown on
+ // Camcorder UI or not
+ TUint iCamcorderVisible;
+ };
+
+
+/*
+ * Image quality set structure
+ */
+class TImageQualitySet
+ {
+ public:
+ // Enum level for the Quality set, used as ID
+ TUint iImageQualitySetLevel;
+ // Image file format mime type, e.g. "image/jpeg"
+ TText8 iImageFileMimeType[ KMaxStringLength ];
+ // Image picture width in pixels, resolution width
+ TInt iImageWidth;
+ // Image picture height in pixels, resolution height
+ TInt iImageHeight;
+ // Image extension, e.g. ".jpg"
+ TText8 iImageFileExtension[ KMaxStringLength ];
+ // Image encoder UID
+ TUid iImageEncoderUID;
+ // Compression quality, determines wether file size or image quality
+ // is preferred over the other
+ TInt iCompressionQuality;
+ // Estimated image size, in bytes
+ TInt iEstimatedSize;
+ // A non-Zero ID telling unique combination of camera (primary/
+ // secondary) and/or display (cover UI/main display) and/or rotation
+ // setting combined into a number for separating each setting set type
+ // from others
+ TUint iCameraDisplayId;
+ // Camcorder specific field that can be either 1(true) or 0(false)
+ // meaning if the current quality settings set should be shown on
+ // Camcorder UI or not
+ TUint iCamcorderVisible;
+ };
+
+/*
+ * Camcorder MMF Plug-in Specific settings structure
+ *
+ */
+class TCamcorderMMFPluginSettings
+ {
+ public:
+ // Video framerate in nightmode (fps)
+ TReal iVideoNightFrameRate;
+ // Video bitrate scaler for remaining time calculation during
+ // first 3seconds.
+ TReal iCMRAvgVideoBitRateScaler;
+ // Video Complexity Setting
+ TInt iVideoComplexitySetting;
+ // Quality is more important in camcorder than delay
+ TReal iCMRLatencyQualityTradeoff;
+ // range is [0...100]
+ TUint iCMRPictureQuality;
+ // Try to maintain the frame-rate,
+ // 1.0 means the picture quality is sacrificed
+ // "all the way" to match the target fps
+ TReal iCMRQualityTemporalTradeoff;
+ // number of camera buffers to use when using HW accelerated encoder
+ TUint iCMRNumCameraBuffers;
+ // number of camera buffers to use when using SW encoder
+ TUint iCMRNumCameraBuffersARM;
+ // min number of output (bitstream) buffers
+ TUint iCMRMinNumOutputBuffers;
+ };
+
+/**
+ * Fake API class for emulate imaging configurations and settings
+ */
+class CImagingConfigManager : public CBase
+ {
+ public:
+
+ // two phase constructor
+ static CImagingConfigManager* NewL();
+
+
+ // Destructor
+ ~CImagingConfigManager();
+
+ // Returns number of video quality levels
+ TInt NumberOfVideoQualityLevels() const;
+
+ // Get video quality levels
+ TInt GetVideoQualityLevelsL( CArrayFixFlat<TUint>& aLevels,
+ TUint aCameraDisplayID = 0 );
+
+ /// returns video quality set and symbian error code if any.
+ TInt GetVideoQualitySet( TVideoQualitySet& aSet,
+ TInt aLevel,
+ TUint aCameraDisplayID = 0 );
+
+ // Get all settings for Camcorder
+ TInt GetCamcorderMMFPluginSettings(TCamcorderMMFPluginSettings& aSet) const;
+
+ // returns number of image quality levels
+ TInt NumberOfImageQualityLevels() const;
+
+ // Get image quality levels
+ TInt GetImageQualityLevelsL( CArrayFixFlat<TUint>& aLevels,
+ TUint aCameraDisplayID = 0 );
+
+ // Get image quality set
+ TInt GetImageQualitySet( TImageQualitySet& aSet,
+ TInt aLevel,
+ TUint aCameraDisplayID = 0 );
+
+ private:
+ CImagingConfigManager();
+ // helper method to init image quality set
+ void initImageQualitySet(TImageQualitySet& aSet);
+ void initVideoQualitySet(TVideoQualitySet& aSet);
+ private:
+ CArrayFixFlat< TVideoQualitySet >* iVideoQualitySets;
+ CArrayFixFlat< TImageQualitySet >* iImageQualitySets;
+
+ };
+
+#endif //IMAGINGCONFIGMANAGER_H
--- a/camerauis/cameraxui/cxengine/tsrc/unit/system_include/thumbnailmanager_qt.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/system_include/thumbnailmanager_qt.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -54,7 +54,6 @@
int ThumbnailManager::getThumbnail(const QString& filename, void * clientData, int priority)
{
CX_DEBUG_ENTER_FUNCTION();
-
Q_UNUSED(priority);
int id = 0;
@@ -80,6 +79,7 @@
{
Q_UNUSED(clientData);
Q_UNUSED(priority);
+ Q_UNUSED(source);
int status = KErrNone;
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unit.pro Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unit.pro Wed Aug 18 14:02:45 2010 +0300
@@ -31,7 +31,6 @@
unittest_cxestillimagesymbian \
unittest_cxeimagedataitemsymbian \
unittest_cxeerrormappersymbian \
- unittest_cxesettingsmodelimp \
unittest_cxefilesavethreadsymbian \
unittest_cxesettingscenrepstore \
unittest_cxestillcapturecontrolsymbian \
@@ -39,6 +38,7 @@
unittest_cxefeaturemanagerimp \
unittest_cxeenginesymbian \
unittest_cxesettingsimp \
+ unittest_cxescenemodestore \
unittest_cxequalitypresetssymbian \
unittest_cxethumbnailmanagersymbian \
unittest_cxeharvestercontrolsymbian \
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeautofocuscontrolsymbian/cxeautofocuscontrolsymbianunit.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -0,0 +1,31 @@
+/*
+* Copyright (c) 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 "cxeautofocuscontrolsymbianunit.h"
+#include "cxecameradevice.h"
+#include "cxesettings.h"
+
+CxeAutoFocusControlSymbianUnit::CxeAutoFocusControlSymbianUnit(CxeCameraDevice &cameraDevice, CxeSettings &settings)
+: CxeAutoFocusControlSymbian(cameraDevice, settings)
+{
+
+}
+
+CxeAutoFocusControlSymbianUnit::~CxeAutoFocusControlSymbianUnit()
+{
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeautofocuscontrolsymbian/cxeautofocuscontrolsymbianunit.h Wed Aug 18 14:02:45 2010 +0300
@@ -0,0 +1,42 @@
+/*
+* Copyright (c) 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:
+*
+*/
+
+#ifndef CXEAUTOFOCUSCONTROLSYMBIANUNIT_H_
+#define CXEAUTOFOCUSCONTROLSYMBIANUNIT_H_
+
+#include "cxeautofocuscontrolsymbian.h"
+
+/*
+ * CxeAutoFocusControlSymbianUnit is inherited from
+ * the class to be tested (CxeAutoFocusControlSymbian) so that
+ * the tester class (UnitTestCxeAutoFocusControlSymbian) can be declared
+ * as friend.
+ */
+
+class CxeCameraDevice;
+class CxeSettings;
+
+class CxeAutoFocusControlSymbianUnit: public CxeAutoFocusControlSymbian
+{
+public:
+ CxeAutoFocusControlSymbianUnit(CxeCameraDevice &cameraDevice, CxeSettings &settings);
+ virtual ~CxeAutoFocusControlSymbianUnit();
+
+ friend class UnitTestCxeAutoFocusControlSymbian;
+};
+
+#endif /* CXEAUTOFOCUSCONTROLSYMBIANUNIT_H_ */
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeautofocuscontrolsymbian/unittest_cxeautofocuscontrolsymbian.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeautofocuscontrolsymbian/unittest_cxeautofocuscontrolsymbian.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -24,8 +24,9 @@
#include "cxefakecameradevicecontrol.h"
#include "cxefakecameradevice.h"
#include "cxefakesettings.h"
-#include "cxeautofocuscontrolsymbian.h"
+#include "cxeautofocuscontrolsymbianunit.h"
#include "unittest_cxeautofocuscontrolsymbian.h"
+#include "cxenamespace.h"
UnitTestCxeAutoFocusControlSymbian::UnitTestCxeAutoFocusControlSymbian()
: mAutoFocusControl(NULL),
@@ -33,17 +34,19 @@
mCameraDevice(NULL),
mFakeSettings(NULL)
{
+ qRegisterMetaType<CxeError::Id>("CxeError::Id");
+ qRegisterMetaType<CxeAutoFocusControl::State>("CxeAutoFocusControl::State");
+ qRegisterMetaType<CxeAutoFocusControl::Mode>("CxeAutoFocusControl::Mode");
}
UnitTestCxeAutoFocusControlSymbian::~UnitTestCxeAutoFocusControlSymbian()
{
- cleanup();
}
// Run before each individual test case
void UnitTestCxeAutoFocusControlSymbian::init()
{
- qDebug() << "UnitTestCxeAutoFocusControlSymbian::init =>";
+ CX_DEBUG_ENTER_FUNCTION();
mFakeSettings = new CxeFakeSettings();
@@ -51,19 +54,22 @@
mCameraDevice = new CxeFakeCameraDevice();
mCameraDevice->newCamera(mCameraDeviceControl->cameraIndex(), mCameraDeviceControl);
- mAutoFocusControl = new CxeAutoFocusControlSymbian(*mCameraDevice, *mFakeSettings);
- //mAutoFocusControl->initializeResources();
+ mAutoFocusControl = new CxeAutoFocusControlSymbianUnit(*mCameraDevice, *mFakeSettings);
- connect(mCameraDeviceControl, SIGNAL(cameraEvent(int,int)),
- mAutoFocusControl, SLOT(handleCameraEvent(int,int)));
+ // make sure that initialization is correct
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown);
+ QCOMPARE(mAutoFocusControl->mode(), CxeAutoFocusControl::Hyperfocal);
+ QCOMPARE(mAutoFocusControl->isSoundEnabled(), false);
+ QCOMPARE(mAutoFocusControl->supported(), true);
- qDebug() << "UnitTestCxeAutoFocusControlSymbian::init <=";
+ CX_DEBUG_EXIT_FUNCTION();
}
// Run after each individual test case
void UnitTestCxeAutoFocusControlSymbian::cleanup()
{
- qDebug() << "UnitTestCxeAutoFocusControlSymbian::cleanup =>";
+ CX_DEBUG_ENTER_FUNCTION();
+
delete mAutoFocusControl;
mAutoFocusControl = NULL;
@@ -76,52 +82,124 @@
delete mFakeSettings;
mFakeSettings = NULL;
- qDebug() << "UnitTestCxeAutoFocusControlSymbian::cleanup <=";
+ CX_DEBUG_EXIT_FUNCTION();
}
void UnitTestCxeAutoFocusControlSymbian::testStart()
{
- QVERIFY(mAutoFocusControl->state() == CxeAutoFocusControl::Unknown);
- mAutoFocusControl->start();
- QVERIFY(mAutoFocusControl->state() == CxeAutoFocusControl::InProgress);
- QVERIFY(CxeTestUtils::waitForState<CxeAutoFocusControl>(*mAutoFocusControl, CxeAutoFocusControl::Ready, 500));
+ // start takes a boolean input and returns CxeError
+ // functionality depends on current state and current autofocus mode
+
+ QSignalSpy stateSpy(mAutoFocusControl,
+ SIGNAL(stateChanged(CxeAutoFocusControl::State,
+ CxeError::Id)));
+
+ CxeError::Id returnValue = CxeError::None;
+ // 1) Default input after initialisation (fixed focus) -> nothing should happen
+ returnValue = mAutoFocusControl->start();
+ // verifying the result:
+ QVERIFY(returnValue == CxeError::None);
+ QCOMPARE(mAutoFocusControl->isSoundEnabled(), true); // check for input paramete
+ // no state changes
+ QVERIFY(!CxeTestUtils::waitForSignal(stateSpy, 1000));
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown);
+
+ // 2) Input parameter false is handled correctly
+ // prequisites: not fixed mode & unknown state -> normal functionality
+ mAutoFocusControl->setMode(CxeAutoFocusControl::Auto); // non-fixed
+ // function call
+ returnValue = mAutoFocusControl->start(false);
+ // verifying the result:
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress);
+ QCOMPARE(returnValue, CxeError::None);
+ QCOMPARE(mAutoFocusControl->isSoundEnabled(), false); // check for input parameter
+
+ // 3) Autofocus is not ready (state is cancelling or in progress)
+ // prequisites:
+ mAutoFocusControl->setMode(CxeAutoFocusControl::Macro); // non-fixed mode
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress);
+ // start should return CxeError::InUse
+ returnValue = mAutoFocusControl->start();
+ QCOMPARE(returnValue, CxeError::InUse);
+
+ // 4) Camera has been released
+ mAutoFocusControl->prepareForCameraDelete();
+ stateSpy.clear();
+ returnValue = mAutoFocusControl->start();
+ // result: no signal should be emitted
+ QVERIFY(!CxeTestUtils::waitForSignal(stateSpy, 1000));
+ QCOMPARE(returnValue, CxeError::None); // should there be and error here?
}
void UnitTestCxeAutoFocusControlSymbian::testCancel()
{
+ // create signalspy to monitor that state changed signal
+ QSignalSpy spy(mAutoFocusControl,
+ SIGNAL(stateChanged(CxeAutoFocusControl::State,
+ CxeError::Id)));
+
+ // 1) after initialisation cancel does nothing
+ mAutoFocusControl->cancel();
+ // no state changes
+ QCOMPARE(spy.count(), 0);
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown);
+
+ // 2) When in fixed focus mode, cancel does nothing
+ mAutoFocusControl->setMode(CxeAutoFocusControl::Auto); // non fixed mode so that start works
mAutoFocusControl->start();
- QVERIFY(mAutoFocusControl->state() == CxeAutoFocusControl::InProgress);
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress); //verify start state
+ mAutoFocusControl->setMode(CxeAutoFocusControl::Infinity); // fixed mode
+ spy.clear();
+ mAutoFocusControl->cancel();
+ QCOMPARE(spy.count(), 0);
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress);
+
+ // 3) InProgress state and "normal cancel"
+ // set mode back to non fixed mode
+ mAutoFocusControl->setMode(CxeAutoFocusControl::Auto);
mAutoFocusControl->cancel();
- QVERIFY(mAutoFocusControl->state() == CxeAutoFocusControl::Canceling);
- QVERIFY(CxeTestUtils::waitForState<CxeAutoFocusControl>(*mAutoFocusControl, CxeAutoFocusControl::Unknown, 500));
+ // -> state is changed to Canceling
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Canceling);
+ // -> focustype set correctly
+ QVERIFY(mAutoFocusControl->focusType()
+ == CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff);
+
+ // 4) Canceling state (reached when calling canceling twice in a row,
+ // now already in canceling state after previous test)
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Canceling);
+ mAutoFocusControl->cancel();
+ // -> state or focustype is not changing
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Canceling);
+ QVERIFY(mAutoFocusControl->focusType()
+ == CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff);
+
+ // 5) Ready state (cancel called after start has been called and focus
+ // found)
+ // force state to ready in order to test canceling
+ mAutoFocusControl->setState(CxeAutoFocusControl::Unknown);
+ mAutoFocusControl->start(); // changes to in progress + sets focus type & range
+ mAutoFocusControl->setState(CxeAutoFocusControl::Ready);
+ mAutoFocusControl->cancel();
+ // state is changed to canceling
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Canceling);
+
}
-void UnitTestCxeAutoFocusControlSymbian::testMode()
-{
- mAutoFocusControl->setMode(CxeAutoFocusControl::Auto);
- QVERIFY(mAutoFocusControl->mode() == CxeAutoFocusControl::Auto);
-
- mAutoFocusControl->setMode(CxeAutoFocusControl::Hyperfocal);
- QVERIFY(mAutoFocusControl->mode() == CxeAutoFocusControl::Hyperfocal);
-
- mAutoFocusControl->setMode(CxeAutoFocusControl::Macro);
- QVERIFY(mAutoFocusControl->mode() == CxeAutoFocusControl::Macro);
-
- mAutoFocusControl->setMode(CxeAutoFocusControl::Infinity);
- QVERIFY(mAutoFocusControl->mode() == CxeAutoFocusControl::Infinity);
-
- mAutoFocusControl->setMode(CxeAutoFocusControl::Portrait);
- QVERIFY(mAutoFocusControl->mode() == CxeAutoFocusControl::Portrait);
-}
void UnitTestCxeAutoFocusControlSymbian::testIsFixedFocusMode()
{
- QVERIFY(mAutoFocusControl->isFixedFocusMode(CxeAutoFocusControl::Auto) == false);
- QVERIFY(mAutoFocusControl->isFixedFocusMode(CxeAutoFocusControl::Hyperfocal) == true);
- QVERIFY(mAutoFocusControl->isFixedFocusMode(CxeAutoFocusControl::Macro) == false);
- QVERIFY(mAutoFocusControl->isFixedFocusMode(CxeAutoFocusControl::Infinity) == true);
- QVERIFY(mAutoFocusControl->isFixedFocusMode(CxeAutoFocusControl::Portrait) == false);
+ // default value (hyperfocal)
+ QCOMPARE(mAutoFocusControl->isFixedFocusMode(mAutoFocusControl->mode()), true);
+
+ // set non fixed focus mode
+ mAutoFocusControl->setMode(CxeAutoFocusControl::Auto);
+ QCOMPARE(mAutoFocusControl->isFixedFocusMode(mAutoFocusControl->mode()), false);
+
+ // set fixed focus mode
+ mAutoFocusControl->setMode(CxeAutoFocusControl::Infinity);
+ QCOMPARE(mAutoFocusControl->isFixedFocusMode(mAutoFocusControl->mode()), true);
+
}
void UnitTestCxeAutoFocusControlSymbian::testSupported()
@@ -131,6 +209,242 @@
}
+void UnitTestCxeAutoFocusControlSymbian::testPrepareForCameraDelete()
+{
+ // prepareCameraDelete calls prepareCameraRelease plus sets advanced
+ // settings false (supported() will return false)
+ // this test is for both methods
+
+ // 1) initial values
+ mAutoFocusControl->prepareForCameraDelete();
+ QCOMPARE(mAutoFocusControl->supported(), false);
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown);
+
+ // 2) test prepareForCameraDelete with non-initial values
+ mAutoFocusControl->handleCameraAllocated(CxeError::None);
+ // force state to be something else than Unknown and check that it will be changed
+ mAutoFocusControl->setState(CxeAutoFocusControl::Canceling);
+ // force mCancelled to be false and check that it will be changed
+ mAutoFocusControl->mCancelled = true;
+ mAutoFocusControl->prepareForCameraDelete();
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown);
+ QCOMPARE(mAutoFocusControl->mCancelled, false);
+ QCOMPARE(mAutoFocusControl->supported(), false);
+
+}
+
+void UnitTestCxeAutoFocusControlSymbian::testHandleCameraAllocated()
+{
+ // create signalspy to monitor that state changed signal
+ QSignalSpy stateSpy(mAutoFocusControl,
+ SIGNAL(stateChanged(CxeAutoFocusControl::State,
+ CxeError::Id)));
+
+ // 1) initial setup without an error (camera is allocated already)
+ mAutoFocusControl->handleCameraAllocated(CxeError::None);
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown);
+ QCOMPARE(mAutoFocusControl->supported(), true);
+
+ // 2) release camera and call with an error code
+ // -> supported should return false since initializeResources is not called in error case
+ // -> state is not changed
+ mAutoFocusControl->prepareForCameraDelete();
+ stateSpy.clear();
+ mAutoFocusControl->handleCameraAllocated(CxeError::General);
+ QVERIFY(!CxeTestUtils::waitForSignal(stateSpy, 1000));
+ QCOMPARE(mAutoFocusControl->supported(), false);
+
+ // 3) release camera and call without an error
+ // (prepareForCameraDelete has been called in previous test)
+ // -> resources are initialized i.e. supported returns true
+ // first force state to something else so state change can be verified
+ mAutoFocusControl->setState(CxeAutoFocusControl::Canceling);
+ mAutoFocusControl->handleCameraAllocated(CxeError::None);
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown);
+ QCOMPARE(mAutoFocusControl->supported(), true);
+
+}
+
+void UnitTestCxeAutoFocusControlSymbian::testPrepareForRelease()
+{
+ // see testPrepareForCameraDelete
+}
+
+void UnitTestCxeAutoFocusControlSymbian::testHandleCameraEvent()
+{
+ // handleCameraEvent handles callbacks and gets information about
+ // focus events. handleCameraEvent calls private method handleAfEvent
+ // for the focusing events that CxeAutoFocusControlSymbian needs
+
+ // testing handleAfEvent is done by calling handleCameraEvent
+ // and monitoring state changes after each "event"
+
+ QSignalSpy stateSpy(mAutoFocusControl,
+ SIGNAL(stateChanged(CxeAutoFocusControl::State,
+ CxeError::Id)));
+
+
+ // Input 1 ----------------------------------------------------
+ // Optimal focus was reached or couldn't be found
+ int eventUid = KUidECamEventCameraSettingsOptimalFocusUidValue;
+ int symbianError = 0; //KErrNone
+
+ // AutofocusControl class is not InProgress or Canceling state
+ // => event ignored, nothing is changed
+ mAutoFocusControl->handleCameraEvent(eventUid, symbianError);
+ QVERIFY(!CxeTestUtils::waitForSignal(stateSpy, 1000));
+
+ // AutoFocusControl is InProgress state (waiting for the focus)
+ mAutoFocusControl->setMode(CxeAutoFocusControl::Auto); // not fixed focus
+ mAutoFocusControl->start();
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress); //verify start state
+ mAutoFocusControl->handleCameraEvent(eventUid, symbianError);
+ // => state should change to Ready
+ QVERIFY(CxeTestUtils::waitForSignal(stateSpy, 1000));
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Ready);
+
+ // InProgress state but focus fails
+ mAutoFocusControl->start();
+ stateSpy.clear();
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress); //verify start state
+ mAutoFocusControl->handleCameraEvent(eventUid, -18); // KErrNotReady
+ // => state should change to Failed
+ QVERIFY(CxeTestUtils::waitForSignal(stateSpy, 1000));
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Failed);
+
+ // AutoFocusControl is in Canceling state
+ mAutoFocusControl->start();
+ mAutoFocusControl->cancel();
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Canceling); //verify start state
+ stateSpy.clear();
+ mAutoFocusControl->handleCameraEvent(eventUid, symbianError);
+ // => state should change to Unknown
+ QVERIFY(CxeTestUtils::waitForSignal(stateSpy, 1000));
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown);
+
+ // cleanup and init to make sure that the dummy engine is not messed up
+ // and we get to initial state
+ cleanup();
+ init();
+
+ // Input 2 -----------------------------------------------------
+ // Notifies a change in autofocus type
+ eventUid = KUidECamEventCameraSettingAutoFocusType2UidValue;
+ symbianError = -18; // == KErrNotReady
+
+ // InProgress: event is ignored
+ mAutoFocusControl->setMode(CxeAutoFocusControl::Auto); // not fixed focus
+ mAutoFocusControl->start();
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress); //verify start state
+ stateSpy.clear();
+ mAutoFocusControl->handleCameraEvent(eventUid, symbianError);
+ QVERIFY(!CxeTestUtils::waitForSignal(stateSpy, 1000));
+
+ // Canceling:
+ // error parameter is ignored, state is not changed
+ mAutoFocusControl->cancel();
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Canceling); //verify start state
+ stateSpy.clear();
+ mAutoFocusControl->handleCameraEvent(eventUid, symbianError);
+ QVERIFY(!CxeTestUtils::waitForSignal(stateSpy, 1000));
+
+ // cleanup and init to make sure that the dummy engine is not messed up
+ // and we get to initial state
+ cleanup();
+ init();
+
+ // Input 3 -----------------------------------------------------
+ // Focus range have changed
+ eventUid = KUidECamEventCameraSettingFocusRangeUidValue;
+ symbianError = -2; // == KErrGeneral
+
+ // In any other state than InProgress this event is ignored
+ stateSpy.clear();
+ mAutoFocusControl->handleCameraEvent(eventUid, symbianError);
+ QVERIFY(!CxeTestUtils::waitForSignal(stateSpy, 1000));
+
+ // InProgress: because of the error parameter state changes to failed
+ // (focus range change failed because of error)
+ mAutoFocusControl->setMode(CxeAutoFocusControl::Auto); // not fixed focus
+ mAutoFocusControl->start();
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress); //verify start state
+ mAutoFocusControl->handleCameraEvent(eventUid, symbianError);
+ // => state should change to Failed
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Failed);
+}
+
+void UnitTestCxeAutoFocusControlSymbian::testHandleSceneChanged()
+{
+ // changes the autofocus settings to match the new scene settings
+ QVariantMap scene;
+
+ // changes focus if new scene setting defines fixed focus
+ // otherwise sets the autofocus control to Unknown state (==initial state)
+
+ // 1) change to a scene with fixed focus mode (Infinity & Hyperfocal)
+ scene.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Infinity);
+ mAutoFocusControl->handleSceneChanged(scene);
+ // states are changed and mode is set correctly ->Unknown->InProgress
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress); // end state
+ QCOMPARE(mAutoFocusControl->mode(), CxeAutoFocusControl::Infinity);
+
+ // 2) change to non-fixed mode (like Macro)
+ scene.clear();
+ scene.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Macro);
+ mAutoFocusControl->handleSceneChanged(scene);
+ // states are changed and mode is set correctly
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown);
+ QCOMPARE(mAutoFocusControl->mode(), CxeAutoFocusControl::Macro);
+
+ // 3) try with error input (scene does not contain focal_range)
+ scene.clear();
+ // change the autofocuscontrol state from Unknown (last test) to
+ // something else calling start() for example
+ mAutoFocusControl->start();
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress); //verify start state
+ mAutoFocusControl->handleSceneChanged(scene);
+ // state is changed and mode is not changed
+ QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown);
+ QCOMPARE(mAutoFocusControl->mode(), CxeAutoFocusControl::Macro);
+
+}
+
+void UnitTestCxeAutoFocusControlSymbian::testHandleSettingValueChanged()
+{
+ // Autofocus mode needs to be updated when face trackin is actived in
+ // scene mod which doesn't support facetracking
+
+ QVariant on = QVariant(1);
+ QVariant off = QVariant(0);
+
+ // 1) check that mode does not change when some other setting value
+ // than face tracking is given
+ mAutoFocusControl->handleSettingValueChanged(CxeSettingIds::LIGHT_SENSITIVITY, on);
+ QCOMPARE(mAutoFocusControl->mode(), CxeAutoFocusControl::Hyperfocal);
+
+ // 2) check turning facetracking on, when mode is fixed
+ mAutoFocusControl->setMode(CxeAutoFocusControl::Infinity);
+ mAutoFocusControl->handleSettingValueChanged(CxeSettingIds::FACE_TRACKING, on);
+ QCOMPARE(mAutoFocusControl->mode(), CxeAutoFocusControl::Auto);
+ QCOMPARE(mAutoFocusControl->mFaceTrackingOverride, true);
+
+ // 3) check turning facetracking off will return the previous mode
+ mAutoFocusControl->handleSettingValueChanged(CxeSettingIds::FACE_TRACKING, off);
+ QCOMPARE(mAutoFocusControl->mode(), CxeAutoFocusControl::Infinity);
+ QCOMPARE(mAutoFocusControl->mFaceTrackingOverride, false);
+
+ // 4) check that turning facetracking off, when it is not on, won't
+ // set the previous mode
+ mAutoFocusControl->setMode(CxeAutoFocusControl::Macro);
+ mAutoFocusControl->handleSettingValueChanged(CxeSettingIds::FACE_TRACKING, off);
+ QCOMPARE(mAutoFocusControl->mode(), CxeAutoFocusControl::Macro);
+ QCOMPARE(mAutoFocusControl->mFaceTrackingOverride, false);
+
+
+}
+
+
+
// main() function - Need event loop for waiting signals,
// so can't use QTEST_APPLESS_MAIN.
QTEST_MAIN(UnitTestCxeAutoFocusControlSymbian);
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeautofocuscontrolsymbian/unittest_cxeautofocuscontrolsymbian.h Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeautofocuscontrolsymbian/unittest_cxeautofocuscontrolsymbian.h Wed Aug 18 14:02:45 2010 +0300
@@ -21,7 +21,7 @@
#include "cxenamespace.h"
-class CxeAutoFocusControlSymbian;
+class CxeAutoFocusControlSymbianUnit;
class CxeFakeCameraDeviceControl;
class CxeFakeCameraDevice;
class CxeFakeSettings;
@@ -40,21 +40,28 @@
void testStart();
void testCancel();
- void testMode();
+
void testIsFixedFocusMode();
+ void testSupported();
- void testSupported();
+ // tests for protected slots?
+ void testPrepareForCameraDelete();
+ void testHandleCameraAllocated();
+ void testPrepareForRelease();
+ void testHandleCameraEvent();
+ void testHandleSceneChanged();
+ void testHandleSettingValueChanged();
private:
// Helper methods for test cases
private:
-
// Need to test with derived class to hide missing ECAM.
- CxeAutoFocusControlSymbian *mAutoFocusControl;
+ CxeAutoFocusControlSymbianUnit *mAutoFocusControl;
CxeFakeCameraDeviceControl *mCameraDeviceControl;
CxeFakeCameraDevice *mCameraDevice;
CxeFakeSettings *mFakeSettings;
+
};
#endif // UNITTEST_CXEAUTOFOCUSCONTROLSYMBIAN_H
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeautofocuscontrolsymbian/unittest_cxeautofocuscontrolsymbian.pro Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeautofocuscontrolsymbian/unittest_cxeautofocuscontrolsymbian.pro Wed Aug 18 14:02:45 2010 +0300
@@ -24,6 +24,7 @@
SOURCES *= unittest_cxeautofocuscontrolsymbian.cpp \
cxeautofocuscontrolsymbian.cpp \
+ cxeautofocuscontrolsymbianunit.cpp \
cxestatemachine.cpp \
cxestate.cpp \
cxestatemachinebase.cpp \
@@ -39,6 +40,7 @@
HEADERS *= unittest_cxeautofocuscontrolsymbian.h \
cxeautofocuscontrol.h \
cxeautofocuscontrolsymbian.h \
+ cxeautofocuscontrolsymbianunit.h \
cxestatemachine.h \
cxestate.h \
cxestatemachinebase.h \
@@ -52,4 +54,5 @@
cxefakecameradevicecontrol.h \
cxutils.h \
cxefakesettings.h \
- cxesettings.h
+ cxesettings.h \
+ cxenamespace.h
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxecameradevicecontrolsymbian/cxecameradevicecontrolunit.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxecameradevicecontrolsymbian/cxecameradevicecontrolunit.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -18,7 +18,6 @@
#include "cxefakecameradevice.h"
#include "cxesettingsimp.h"
#include "cxefeaturemanagerimp.h"
-#include "cxesettingsmodel.h"
#include "cxutils.h"
#include "cxenamespace.h"
#include "cxeerrormappingsymbian.h"
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeenginesymbian/cxeenginesymbianunit.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeenginesymbian/cxeenginesymbianunit.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -27,7 +27,7 @@
#include "cxefakesensoreventhandler.h"
#include "cxefakefilenamegenerator.h"
#include "cxutils.h"
-#include "cxefakesettingsmodel.h"
+
// Member Functions
@@ -52,8 +52,6 @@
if (!mVideoCaptureControl) {
mCameraDeviceControl = new CxeFakeCameraDeviceControl();
- mSettings = new CxeFakeSettings();
-
mFeatureManager = new CxeFakeFeatureManager();
mSensorEventHandler = new CxeFakeSensorEventHandler();
@@ -70,8 +68,6 @@
mVideoCaptureControl = new CxeFakeVideoCaptureControl();
- mSettingsModel = new CxeFakeSettingsModel();
-
mFeatureManager = new CxeFakeFeatureManager();
}
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeenginesymbian/unittest_cxeenginesymbian.pro Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeenginesymbian/unittest_cxeenginesymbian.pro Wed Aug 18 14:02:45 2010 +0300
@@ -71,7 +71,6 @@
cxestatemachine.cpp \
cxestatemachinebase.cpp \
cxestate.cpp \
- cxesettingsmodelimp.cpp \
cxesettingscenrepstore.cpp \
cxefilenamegeneratorsymbian.cpp \
cxefakefilenamegenerator.cpp \
@@ -108,9 +107,9 @@
cxememorymonitorprivate.cpp \
cxesnapshotcontrol.cpp \
cxesnapshotcontrolprivate.cpp \
- cxefakesettingsmodel.cpp \
cxegeotaggingtrail.cpp \
- cxegeotaggingtrail_symbian_p.cpp
+ cxegeotaggingtrail_symbian_p.cpp \
+ cxescenemodestore.cpp
@@ -145,7 +144,6 @@
cxesettings.h \
cxesettingsimp.h \
cxefakesettings.h \
- cxesettingsmodel.h \
cxesettingscenrepstore.h \
cxesettingsmappersymbian.h \
cxesettingscontrolsymbian.h \
@@ -186,6 +184,6 @@
cxememorymonitorprivate.h \
cxesnapshotcontrol.h \
cxesnapshotcontrolprivate.h \
- cxefakesettingsmodel.h \
cxegeotaggingtrail.h \
- cxegeotaggingtrail_symbian_p.h
+ cxegeotaggingtrail_symbian_p.h \
+ cxescenemodestore.h
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxefeaturemanagerimp/unittest_cxefeaturemanagerimp.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxefeaturemanagerimp/unittest_cxefeaturemanagerimp.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -18,9 +18,9 @@
#include <QTest>
#include "unittest_cxefeaturemanagerimp.h"
-#include "cxefakesettingsmodel.h"
#include "cxefeaturemanagerimp.h"
#include "cxenamespace.h"
+#include "cxesettings.h"
static const char* INVALID_KEY = "invalid key";
@@ -28,7 +28,7 @@
UnitTestCxeFeatureManager::UnitTestCxeFeatureManager()
-: mFakeSettingsModel(NULL), mFeatureManager(NULL)
+: mFeatureManager(NULL)
{
}
@@ -41,16 +41,12 @@
void UnitTestCxeFeatureManager::init()
{
// fake model contains initialized test data.
- mFakeSettingsModel = new CxeFakeSettingsModel();
- mFeatureManager = new CxeFeatureManagerImp(*mFakeSettingsModel);
+ mFeatureManager = new CxeFeatureManagerImp(*mSettings);
}
// Run after each individual test case
void UnitTestCxeFeatureManager::cleanup()
{
- delete mFakeSettingsModel;
- mFakeSettingsModel = 0;
-
delete mFeatureManager;
mFeatureManager = 0;
}
@@ -73,7 +69,7 @@
QCOMPARE(err, CxeError::NotFound);
// test with right key
- key = CxeRuntimeKeys::PRIMARY_CAMERA_CAPTURE_KEYS;
+ key = CxeVariationKeys::STILL_MAX_ZOOM_LIMITS;
err = mFeatureManager->isFeatureSupported(key, isSupported);
QVERIFY(isSupported);
QCOMPARE(err, CxeError::None);
@@ -99,7 +95,7 @@
QCOMPARE(values.count(), 0);
// case 3: test with right key
- key = CxeRuntimeKeys::VIDEO_MAX_ZOOM_LIMITS;
+ key = CxeVariationKeys::VIDEO_MAX_ZOOM_LIMITS;
err = mFeatureManager->configuredValues(key, values);
QCOMPARE(err, CxeError::None);
QVERIFY(values.count() > 0);
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxefeaturemanagerimp/unittest_cxefeaturemanagerimp.h Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxefeaturemanagerimp/unittest_cxefeaturemanagerimp.h Wed Aug 18 14:02:45 2010 +0300
@@ -19,8 +19,8 @@
#include <QObject>
-class CxeFakeSettingsModel;
class CxeFeatureManagerImp;
+class CxeSettings;
class UnitTestCxeFeatureManager : public QObject
{
@@ -38,8 +38,8 @@
void testconfiguredValues();
private:
- CxeFakeSettingsModel *mFakeSettingsModel;
CxeFeatureManagerImp *mFeatureManager;
+ CxeSettings *mSettings;
};
#endif // UNITTEST_CXEFEATUREMANAGER_H
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxefeaturemanagerimp/unittest_cxefeaturemanagerimp.pro Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxefeaturemanagerimp/unittest_cxefeaturemanagerimp.pro Wed Aug 18 14:02:45 2010 +0300
@@ -14,10 +14,8 @@
TARGET = unittest_cxefeaturemanagerimp
SOURCES *= unittest_cxefeaturemanagerimp.cpp \
- cxefeaturemanagerimp.cpp \
- cxefakesettingsmodel.cpp
+ cxefeaturemanagerimp.cpp
HEADERS *= unittest_cxefeaturemanagerimp.h \
cxefeaturemanagerimp.h \
- cxefakesettingsmodel.h \
cxeerror.h \
cxenamespace.h
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxefilenamegeneratorsymbian/unittest_cxefilenamegeneratorsymbian.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxefilenamegeneratorsymbian/unittest_cxefilenamegeneratorsymbian.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -41,8 +41,6 @@
// Run before each individual test case
void UnitTestCxeFilenameGeneratorSymbian::init()
{
- mFakeSettings = new CxeFakeSettings();
-
mFakeSettings->set(CxeSettingIds::FNAME_MONTH_FOLDER, QDate::currentDate().toString("yyyyMM"));
mFakeSettings->set(CxeSettingIds::FNAME_IMAGE_COUNTER, 0);
mFakeSettings->set(CxeSettingIds::FNAME_VIDEO_COUNTER, 0);
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxememorymonitor/oommonitorsession.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxememorymonitor/oommonitorsession.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -22,7 +22,7 @@
return KErrNone;
}
-TInt ROomMonitorSession::RequestFreeMemory(TInt aBytesRequested)
+TInt ROomMonitorSession::RequestFreeMemory(TInt /*aBytesRequested*/)
{
return KErrNone;
}
@@ -37,7 +37,7 @@
return KErrNone;
}
-void ROomMonitorSession::RequestOptionalRam(TInt /*aBytesRequested*/, TInt /*aMinimumBytesNeeded*/, TInt aPluginId, TRequestStatus& /*aStatus*/)
+void ROomMonitorSession::RequestOptionalRam(TInt /*aBytesRequested*/, TInt /*aMinimumBytesNeeded*/, TInt /*aPluginId*/, TRequestStatus& /*aStatus*/)
{
// do nothing
}
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxequalitypresetssymbian/unittest_cxequalitypresetssymbian.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxequalitypresetssymbian/unittest_cxequalitypresetssymbian.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -16,8 +16,11 @@
*/
#include <QTest>
+#include <QList>
-#include <QList>
+// "fake" system include
+#include "imagingconfigmanager.h"
+
#include "cxefakesettings.h"
#include "unittest_cxequalitypresetssymbian.h"
#include "cxequalitypresetssymbian.h"
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxequalitypresetssymbian/unittest_cxequalitypresetssymbian.pro Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxequalitypresetssymbian/unittest_cxequalitypresetssymbian.pro Wed Aug 18 14:02:45 2010 +0300
@@ -13,6 +13,8 @@
TARGET = unittest_cxequalitypresetssymbian
+INCLUDEPATH *= ../system_include
+DEPENDPATH *= ../system_include
HEADERS *= unittest_cxequalitypresetssymbian.h \
cxequalitypresetssymbian.h \
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxesettingscenrepstore/unittest_cxesettingscenrepstore.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxesettingscenrepstore/unittest_cxesettingscenrepstore.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -67,7 +67,6 @@
*/
void UnitTestCxeSettingsCenrepStore::testSettingValues()
{
- QString runtimekey = CxeRuntimeKeys::PRIMARY_CAMERA_CAPTURE_KEYS;
QString settingkey = CxeSettingIds::FNAME_MONTH_FOLDER;
QString scenekey = CxeSettingIds::COLOR_TONE;
QVariant result;
@@ -75,10 +74,6 @@
CxeError::Id error;
// case 0: check default value of a runtime key, real setting key and scene key
- error = mSettingsCenrepStore->get(runtimekey, result);
- QVERIFY(error == CxeError::None);
- QCOMPARE(result.toInt(), 1);
-
error = mSettingsCenrepStore->get(settingkey, result);
QVERIFY(error == CxeError::None);
QCOMPARE(result.toInt(), 1);
@@ -89,9 +84,6 @@
// case 1: try setting a value to a run-time key and real setting key
- error = mSettingsCenrepStore->set(runtimekey, value);
- QVERIFY(error == CxeError::NotFound);
-
error = mSettingsCenrepStore->set(settingkey, value);
QVERIFY(error == CxeError::None);
@@ -124,11 +116,10 @@
void UnitTestCxeSettingsCenrepStore::testloadSettings()
{
QList<QString> keys;
- keys.append(CxeRuntimeKeys::PRIMARY_CAMERA_CAPTURE_KEYS);
- keys.append(CxeRuntimeKeys::PRIMARY_CAMERA_AUTOFOCUS_KEYS);
- keys.append(CxeRuntimeKeys::SECONDARY_CAMERA_CAPTURE_KEYS);
- keys.append(CxeRuntimeKeys::FREE_MEMORY_LEVELS);
- QHash<QString, QVariantList> runtimesettings = mSettingsCenrepStore->loadRuntimeSettings(keys);
+ keys.append(CxeVariationKeys::STILL_MAX_ZOOM_LIMITS);
+ keys.append(CxeVariationKeys::VIDEO_MAX_ZOOM_LIMITS);
+ keys.append(CxeVariationKeys::FREE_MEMORY_LEVELS);
+ QHash<QString, QVariantList> runtimesettings = mSettingsCenrepStore->loadVariationSettings(keys);
foreach(QString runtimekey, keys) {
QVariant result;
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxesettingsimp/unittest_cxesettingsimp.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxesettingsimp/unittest_cxesettingsimp.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -17,16 +17,24 @@
#include <QTest>
#include <QDebug>
#include <QSignalSpy>
+#include <QMetaType>
+#include "cxutils.h"
#include "cxetestutils.h"
-#include "cxefakesettingsmodel.h"
+#include "cxefakesettingsstore.h"
#include "unittest_cxesettingsimp.h"
+#include "cxecenrepkeys.h"
const char* FAIL_TEST_SETTING = "Fail test";
+const char* EMPTY_STRING = "";
+const int CAMERA_MODE_STILL = 0;
+const int CAMERA_MODE_VIDEO = 1;
+//Default EV compensation value for auto still and auto video scene mode
+const int SCENE_AUTO_EV_VALUE = 0;
+const int SIGNAL_TIMEOUT = 3000; //milliseconds
UnitTestCxeSettingsImp::UnitTestCxeSettingsImp() :
- mSettingsModel(NULL),
- mSettingsImp(NULL)
+ mSettingsImp(NULL), mSettingsStore(NULL)
{
qRegisterMetaType<CxeScene>("CxeScene");
qRegisterMetaType<CxeError::Id>("CxeError::Id");
@@ -35,416 +43,444 @@
UnitTestCxeSettingsImp::~UnitTestCxeSettingsImp()
{
- cleanup();
}
void UnitTestCxeSettingsImp::init()
{
- mSettingsModel = new CxeFakeSettingsModel;
- mSettingsImp = new CxeSettingsImp(*mSettingsModel);
+ mSettingsStore = new CxeFakeSettingsStore();
+ mSettingsImp = new CxeSettingsImp(mSettingsStore);
}
void UnitTestCxeSettingsImp::cleanup()
{
- delete mSettingsModel;
- mSettingsModel = NULL;
-
delete mSettingsImp;
mSettingsImp = NULL;
}
-void UnitTestCxeSettingsImp::testLoadSettings()
+/*
+ * Testing loadSettings() with Cxe::ImageMode argument
+ */
+void UnitTestCxeSettingsImp::testLoadImageSettings()
{
- Cxe::CameraMode mode;
+ CX_DEBUG_ENTER_FUNCTION();
+ QSignalSpy spy(mSettingsImp, SIGNAL(settingValueChanged(QString,QVariant)));
+ mSettingsImp->loadSettings(Cxe::ImageMode);
- /* Observe sceneChanged signal from mSettingsImp
- */
- CxeScene sigSce;
- QSignalSpy spyStateChange(mSettingsImp, SIGNAL(sceneChanged(CxeScene &)));
- QVERIFY( spyStateChange.isValid() );
+ //signal should be emitted when loading settings
+ QVERIFY(spy.count() > 0);
+
+ //now let's take a look inside a signal content
+ QList<QVariant> arguments = spy.takeFirst();
+ QVERIFY(arguments.at(0).toString().toAscii() == CxeSettingIds::IMAGE_SCENE);
+ CX_DEBUG_EXIT_FUNCTION();
+}
- /* Test load settings in camera/video mode. Helpper method is used to get the
- * new camera mode to test loadSettings method has set right camera mode
- */
- mSettingsImp->loadSettings(Cxe::ImageMode);
- mode = mSettingsModel->getDummyCameraMode();
- QCOMPARE(mode, Cxe::ImageMode);
- QVERIFY(CxeTestUtils::waitForSignal(spyStateChange, 1000)); // verify statechanges
+/*
+ * Testing loadSettings() with Cxe::VideoMode argument
+ */
+void UnitTestCxeSettingsImp::testLoadVideoSettings()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+ QSignalSpy spy(mSettingsImp, SIGNAL(settingValueChanged(QString,QVariant)));
+ mSettingsImp->loadSettings(Cxe::VideoMode);
- mSettingsImp->loadSettings(Cxe::VideoMode);
- mode = mSettingsModel->getDummyCameraMode();
- QCOMPARE(mode, Cxe::VideoMode);
- QVERIFY(CxeTestUtils::waitForSignal(spyStateChange, 1000)); // verify statechanges
+ //signal should be emitted when loading settings
+ QVERIFY(spy.count() > 0);
+
+ //now let's take a look inside a signal content
+ QList<QVariant> arguments = spy.takeFirst();
+ QVERIFY(arguments.at(0).toString().toAscii() == CxeSettingIds::VIDEO_SCENE);
+
+ CX_DEBUG_EXIT_FUNCTION();
}
+/*
+ * Advanced test case for loadSettings()
+ */
+void UnitTestCxeSettingsImp::testLoadImageAndVideoSettings()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+ QSignalSpy spy(mSettingsImp, SIGNAL(settingValueChanged(QString,QVariant)));
+ mSettingsImp->loadSettings(Cxe::VideoMode);
+ //signal should be emitted when loading settings
+ QVERIFY(spy.count() > 0);
+
+ //now let's take a look inside a signal content
+ QList<QVariant> arguments = spy.takeFirst();
+ QVERIFY(arguments.at(0).toString().toAscii() == CxeSettingIds::VIDEO_SCENE);
+ spy.clear();
+
+ mSettingsImp->loadSettings(Cxe::ImageMode);
+
+ //signal should be emitted when loading settings
+ QVERIFY(spy.count() > 0);
+
+ //now let's take a look inside a signal content
+ arguments = spy.takeFirst();
+ QVERIFY(arguments.at(0).toString().toAscii() == CxeSettingIds::IMAGE_SCENE);
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*
+ * Testing inline get(const QString &key)
+ * defined in cxesettings.h as template
+ */
void UnitTestCxeSettingsImp::testGet()
{
+ CX_DEBUG_ENTER_FUNCTION();
CxeError::Id err = CxeError::None;
- QString stringValue;
- QString expectedValue = "1";
+ // The idea of this test case is to test as much of different type of settings
+ // as possible
+
+ // Testing reading brightness setting value
+ int brightnessValue;
QVariant testValue;
- /* Test that get -method accepts key and returns correct value. Fakeclass method
- * is used to check that returned value matches with fakeclass' test values
- */
- err = mSettingsImp->get(CxeSettingIds::BRIGHTNESS, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::BRIGHTNESS, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
-
- /* Test that returned value can be viewed as string and int, since get -method
- * may be used for both strings and integers
- */
- int num = 1;
- QCOMPARE(stringValue, expectedValue);
- QVERIFY(stringValue.toInt() == num);
+ try {
+ brightnessValue = mSettingsImp->CxeSettings::get<int>(CxeSettingIds::BRIGHTNESS);
+ }
+ catch (CxeException exception) {
+ QString message = "Exception thrown, error id = ";
+ message.append(exception.error());
+ QFAIL(message.toAscii());
+ return;
+ }
- err = mSettingsImp->get(CxeSettingIds::COLOR_TONE, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::COLOR_TONE, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
-
- err = mSettingsImp->get(CxeSettingIds::CONTRAST, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::CONTRAST, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
-
- err = mSettingsImp->get(CxeSettingIds::EV_COMPENSATION_VALUE, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::EV_COMPENSATION_VALUE, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
+ mSettingsStore->get(CxeSettingIds::BRIGHTNESS, testValue);
+ QCOMPARE(brightnessValue, testValue.toInt());
- err = mSettingsImp->get(CxeSettingIds::EXPOSURE_MODE, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::EXPOSURE_MODE, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
-
- err = mSettingsImp->get(CxeSettingIds::FLASH_MODE, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::FLASH_MODE, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
-
- err = mSettingsImp->get(CxeSettingIds::FNAME_FOLDER_SUFFIX, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::FNAME_FOLDER_SUFFIX, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
+ // Testing reading color tone setting value
+ Cxe::Colortone colorTone;
+ try {
+ colorTone = mSettingsImp->CxeSettings::get<Cxe::Colortone>(CxeSettingIds::COLOR_TONE);
+ }
+ catch (CxeException exception) {
+ QString message = "Exception thrown, error id = ";
+ message.append(exception.error());
+ QFAIL(message.toAscii());
+ return;
+ }
- err = mSettingsImp->get(CxeSettingIds::FNAME_IMAGE_COUNTER, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::FNAME_IMAGE_COUNTER, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
+ QVariant colorTone2;
+ mSettingsStore->get(CxeSettingIds::COLOR_TONE, colorTone2);
+ QVERIFY(colorTone2 == colorTone);
- err = mSettingsImp->get(CxeSettingIds::FNAME_MONTH_FOLDER, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::FNAME_MONTH_FOLDER, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
+ // Testing reading contrast setting value
+ int contrastValue;
+ try {
+ contrastValue = mSettingsImp->CxeSettings::get<int>(CxeSettingIds::CONTRAST);
+ }
+ catch (CxeException exception) {
+ QString message = "Exception thrown, error id = ";
+ message.append(exception.error());
+ QFAIL(message.toAscii());
+ return;
+ }
- err = mSettingsImp->get(CxeSettingIds::FNAME_VIDEO_COUNTER, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::FNAME_VIDEO_COUNTER, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
+ mSettingsStore->get(CxeSettingIds::CONTRAST, testValue);
+ QCOMPARE(testValue.toInt(), contrastValue);
- err = mSettingsImp->get(CxeSettingIds::FOCAL_RANGE, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::FOCAL_RANGE, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
-
- err = mSettingsImp->get(CxeSettingIds::FRAME_RATE, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::FRAME_RATE, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
-
- err = mSettingsImp->get(CxeSettingIds::IMAGE_QUALITY, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::IMAGE_QUALITY, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
+ // Testing reading file name folder suffix setting value
+ QString fnameValue;
+ try {
+ fnameValue = mSettingsImp->CxeSettings::get<QString>(CxeSettingIds::FNAME_FOLDER_SUFFIX);
+ }
+ catch (CxeException exception) {
+ QString message = "Exception thrown, error id = ";
+ message.append(exception.error());
+ QFAIL(message.toAscii());
+ return;
+ }
- err = mSettingsImp->get(CxeSettingIds::IMAGE_SCENE, stringValue);
- QCOMPARE(err, CxeError::None);
- CxeScene scene = mSettingsModel->currentImageScene();
- QCOMPARE(stringValue, scene[CxeSettingIds::SCENE_ID].toString());
+ mSettingsStore->get(CxeSettingIds::FNAME_FOLDER_SUFFIX, testValue);
+ QCOMPARE(testValue.toString(), fnameValue);
- err = mSettingsImp->get(CxeSettingIds::LIGHT_SENSITIVITY, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::LIGHT_SENSITIVITY, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
+ // Testing reading scene data
+ QVariantMap sceneData;
- err = mSettingsImp->get(CxeSettingIds::SCENE_ID, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::SCENE_ID, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
+ // First set the still camera scene to auto
+ mSettingsStore->set(CxeSettingIds::IMAGE_SCENE, Cxe::IMAGE_SCENE_AUTO);
- err = mSettingsImp->get(CxeSettingIds::SECONDARY_CAMERA, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::SECONDARY_CAMERA, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
+ try {
+ sceneData = mSettingsImp->CxeSettings::get<QVariantMap>(CxeSettingIds::IMAGE_SCENE_DATA);
+ }
+ catch (CxeException exception) {
+ QString message = "Exception thrown, error id = ";
+ message.append(exception.error());
+ QFAIL(message.toAscii());
+ return;
+ }
- err = mSettingsImp->get(CxeSettingIds::SELF_TIMER, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::SELF_TIMER, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
-
- err = mSettingsImp->get(CxeSettingIds::SHARPNESS, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::SHARPNESS, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
+ QCOMPARE(sceneData[CxeSettingIds::EV_COMPENSATION_VALUE].toInt(), SCENE_AUTO_EV_VALUE);
- err = mSettingsImp->get(CxeSettingIds::VIDEO_SCENE, stringValue);
- QCOMPARE(err, CxeError::None);
- scene = mSettingsModel->currentVideoScene();
- QCOMPARE(stringValue, scene[CxeSettingIds::SCENE_ID].toString());
+ // Now let's try same with video scene
+ sceneData.clear();
+ mSettingsStore->set(CxeSettingIds::VIDEO_SCENE, Cxe::VIDEO_SCENE_AUTO);
+ try {
+ sceneData = mSettingsImp->CxeSettings::get<QVariantMap>(CxeSettingIds::VIDEO_SCENE_DATA);
+ }
+ catch (CxeException exception) {
+ QString message = "Exception thrown, error id = ";
+ message.append(exception.error());
+ QFAIL(message.toAscii());
+ return;
+ }
- err = mSettingsImp->get(CxeSettingIds::WHITE_BALANCE, stringValue);
- QCOMPARE(err, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::WHITE_BALANCE, testValue);
- QCOMPARE(stringValue, QString(testValue.toString()));
+ QCOMPARE(sceneData[CxeSettingIds::EV_COMPENSATION_VALUE].toInt(), SCENE_AUTO_EV_VALUE);
- /* Test error values
- */
- err = mSettingsImp->get(FAIL_TEST_SETTING , stringValue);
- QCOMPARE(err, CxeError::NotFound);
+ CX_DEBUG_EXIT_FUNCTION();
}
+/*
+ * Testing get(long int uid,
+ * unsigned long int key,
+ * Cxe::SettingKeyType type,
+ * QVariant &value)
+ */
void UnitTestCxeSettingsImp::testGet2()
{
+ CX_DEBUG_ENTER_FUNCTION();
QVariant value;
- QVariant reference;
- mSettingsImp->get(0, 0, Cxe::Repository, value);
- mSettingsModel->getSettingValue(0, 0, Cxe::Repository, reference);
- QCOMPARE(value, reference);
+ mSettingsImp->get(CxSettingsCrUid, FileNameSuffixCr, Cxe::Repository, value);
+ // 42 is just a test value from cxefakesettingsstore
+ // we just check that it is correctly returned
+ QCOMPARE(value.toInt(), 42);
mSettingsImp->get(0, 0, Cxe::PublishAndSubscribe, value);
- mSettingsModel->getSettingValue(0, 0, Cxe::PublishAndSubscribe, reference);
- QCOMPARE(value, reference);
+ // 42 is just a test value from cxefakesettingsstore
+ // we just check that it is correctly returned
+ QCOMPARE(value.toInt(), 42);
+ CX_DEBUG_EXIT_FUNCTION();
+}
+/*
+ * Testing get(const QString &key, const T &defaultValue)
+ * defined in cxesettings.h as template
+ */
+void UnitTestCxeSettingsImp::testGet3()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+ Cxe::Colortone defaultTone = Cxe::ColortoneNormal;
+ mSettingsStore->set(CxeSettingIds::COLOR_TONE, Cxe::ColortoneVivid);
+ Cxe::Colortone colorTone = mSettingsImp->CxeSettings::get<Cxe::Colortone>(
+ CxeSettingIds::COLOR_TONE, defaultTone);
+ QVERIFY(colorTone == Cxe::ColortoneVivid);
+
+ // Now when using this version of the overloaded get<int>()
+ // with invalid key parameter, it should internally
+ // catch the exception and not modify the default value
+ int defaultValue = 0;
+ int value = mSettingsImp->CxeSettings::get<int>(
+ FAIL_TEST_SETTING, defaultValue);
+ QVERIFY(value == defaultValue);
+ CX_DEBUG_EXIT_FUNCTION();
}
+/*
+ * Testing inputting some garbage into CxeSettingsImp::get()
+ */
+void UnitTestCxeSettingsImp::testGetGarbage()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+ int intTestValue = 0;
+ CxeError::Id errorId;
+
+ try {
+ mSettingsImp->CxeSettings::get<int>(EMPTY_STRING, intTestValue);
+ }
+ catch (CxeException exception) {
+ QString message = "Exception thrown, error id = ";
+ message.append(exception.error());
+ errorId = CxeError::Id(exception.error());
+ QCOMPARE(errorId, CxeError::NotFound);
+ }
+
+ try {
+ mSettingsImp->CxeSettings::get<int>(FAIL_TEST_SETTING, intTestValue);
+ }
+ catch (CxeException exception) {
+ QString message = "Exception thrown, error id = ";
+ message.append(exception.error());
+ errorId = CxeError::Id(exception.error());
+ QCOMPARE(errorId, CxeError::NotFound);
+ }
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*
+ * Testing inline void set(const QString &key, const T &value)
+ * defined in cxesettings.h
+ */
void UnitTestCxeSettingsImp::testSet()
{
- CxeError::Id error;
- int range = 0;
- QString string = "";
- QVariant variant(1);
- QVariant checkValue;
+ CX_DEBUG_ENTER_FUNCTION();
+
+ // Point of this test case is to try all versions of the set()
+ // method defined in cxesettings.inl
- /* Test that signal is corresponding correctly when setting value is changed
- */
- QList<QVariant> spyArguments;
- QSignalSpy signalSpy(mSettingsImp, SIGNAL(settingValueChanged(QString, QVariant)));
- QVERIFY( signalSpy.isValid() );
-
- error = mSettingsImp->set(CxeSettingIds::BRIGHTNESS, range);
- QCOMPARE(error, CxeError::None);
- QVERIFY(CxeTestUtils::waitForSignal(signalSpy, 1000)); // verify statechanges
-
- spyArguments = signalSpy.takeFirst();
- QCOMPARE(spyArguments.at(0).toString(), QString(CxeSettingIds::BRIGHTNESS));
- QCOMPARE(spyArguments.at(1).toInt(), range);
+ // Testing set<int>() version
+ QVariant value;
+ try {
+ mSettingsImp->set(CxeSettingIds::COLOR_TONE, Cxe::ColortoneBlackAndWhite);
+ }
+ catch (CxeException exception) {
+ QString message = "Exception thrown, error id = ";
+ message.append(exception.error());
+ QFAIL(message.toAscii());
+ return;
+ }
+ mSettingsStore->get(CxeSettingIds::COLOR_TONE, value);
+ QCOMPARE(value.toInt(), (int)Cxe::ColortoneBlackAndWhite);
- /* Test parameters
- */
- error = mSettingsImp->set(CxeSettingIds::BRIGHTNESS, range);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::BRIGHTNESS, checkValue);
- QCOMPARE(int(checkValue.toInt()), range);
-
- error = mSettingsImp->set(CxeSettingIds::COLOR_TONE, Cxe::ColortoneNormal);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::COLOR_TONE, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::ColortoneNormal));
+ // Testing set<QString>() version
+ QString stringValue = "some text";
+ try {
+ mSettingsImp->set(CxeSettingIds::FNAME_FOLDER_SUFFIX, stringValue);
+ }
+ catch (CxeException exception) {
+ QString message = "Exception thrown, error id = ";
+ message.append(exception.error());
+ QFAIL(message.toAscii());
+ return;
+ }
+ mSettingsStore->get(CxeSettingIds::FNAME_FOLDER_SUFFIX, value);
+ QCOMPARE(value.toString(), stringValue);
- error = mSettingsImp->set(CxeSettingIds::COLOR_TONE, Cxe::ColortoneSepia);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::COLOR_TONE, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::ColortoneSepia));
-
- error = mSettingsImp->set(CxeSettingIds::COLOR_TONE, Cxe::ColortoneNegative);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::COLOR_TONE, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::ColortoneNegative));
-
- error = mSettingsImp->set(CxeSettingIds::COLOR_TONE, Cxe::ColortoneBlackAndWhite);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::COLOR_TONE, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::ColortoneBlackAndWhite));
-
- error = mSettingsImp->set(CxeSettingIds::COLOR_TONE, Cxe::ColortoneVivid);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::COLOR_TONE, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::ColortoneVivid));
+ // Testing set<bool>() version
+ bool boolValue = true;
+ try {
+ mSettingsImp->set(CxeSettingIds::STILL_SHOWCAPTURED, boolValue);
+ }
+ catch (CxeException exception) {
+ QString message = "Exception thrown, error id = ";
+ message.append(exception.error());
+ QFAIL(message.toAscii());
+ return;
+ }
+ mSettingsStore->get(CxeSettingIds::STILL_SHOWCAPTURED, value);
+ QCOMPARE(value.toBool(), boolValue);
- error = mSettingsImp->set(CxeSettingIds::CONTRAST, range);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::CONTRAST, checkValue);
- QCOMPARE(int(checkValue.toInt()), range);
-
- error = mSettingsImp->set(CxeSettingIds::EV_COMPENSATION_VALUE, range);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::EV_COMPENSATION_VALUE, checkValue);
- QCOMPARE(int(checkValue.toInt()), range);
+ // Testing set<qreal>() version
+ qreal qrealValue = -1.25;
+ try {
+ mSettingsImp->set(CxeSettingIds::EV_COMPENSATION_VALUE, qrealValue);
+ }
+ catch (CxeException exception) {
+ QString message = "Exception thrown, error id = ";
+ message.append(exception.error());
+ QFAIL(message.toAscii());
+ return;
+ }
+ mSettingsStore->get(CxeSettingIds::EV_COMPENSATION_VALUE, value);
+ QCOMPARE(value.toReal(), qrealValue);
- error = mSettingsImp->set(CxeSettingIds::EXPOSURE_MODE, Cxe::ExposureAuto);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::EXPOSURE_MODE, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::ExposureAuto));
+ // Testing set<QVariantMap>() version
+ CxeScene testSceneData;
- error = mSettingsImp->set(CxeSettingIds::EXPOSURE_MODE, Cxe::ExposureBacklight);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::EXPOSURE_MODE, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::ExposureBacklight));
-
- error = mSettingsImp->set(CxeSettingIds::EXPOSURE_MODE, Cxe::ExposureNight);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::EXPOSURE_MODE, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::ExposureNight));
+ testSceneData.insert(CxeSettingIds::SCENE_ID, Cxe::IMAGE_SCENE_AUTO);
+ testSceneData.insert(CxeSettingIds::WHITE_BALANCE, Cxe::WhitebalanceAutomatic);
+ testSceneData.insert(CxeSettingIds::EXPOSURE_MODE, Cxe::ExposureAuto);
+ testSceneData.insert(CxeSettingIds::COLOR_TONE, Cxe::ColortoneNormal);
+ testSceneData.insert(CxeSettingIds::CONTRAST, 5);
+ testSceneData.insert(CxeSettingIds::SHARPNESS, Cxe::SharpnessNormal);
+ testSceneData.insert(CxeSettingIds::LIGHT_SENSITIVITY, Cxe::LightSensitivityAutomatic);
+ testSceneData.insert(CxeSettingIds::EV_COMPENSATION_VALUE, -2);
+ testSceneData.insert(CxeSettingIds::BRIGHTNESS, 8);
+ testSceneData.insert(CxeSettingIds::FLASH_MODE, Cxe::FlashAuto);
+ testSceneData.insert(CxeSettingIds::FACE_TRACKING, 1);
- error = mSettingsImp->set(CxeSettingIds::EXPOSURE_MODE, Cxe::ExposureSport);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::EXPOSURE_MODE, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::ExposureSport));
+ // First set the still camera scene to auto
+ mSettingsStore->set(CxeSettingIds::IMAGE_SCENE, Cxe::IMAGE_SCENE_AUTO);
- error = mSettingsImp->set(CxeSettingIds::FLASH_MODE, Cxe::FlashAntiRedEye);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::FLASH_MODE, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::FlashAntiRedEye));
-
- error = mSettingsImp->set(CxeSettingIds::FLASH_MODE, Cxe::FlashAuto);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::FLASH_MODE, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::FlashAuto));
+ // Now setting the value
+ try {
+ //This should throw an exception with CxeError::NotSupported
+ mSettingsImp->set(CxeSettingIds::IMAGE_SCENE_DATA, testSceneData);
+ }
+ catch (CxeException exception) {
+ QString message = "Exception thrown, error id = ";
+ message.append((int)exception.error());
+ QCOMPARE(exception.error(), (int)CxeError::NotSupported);
+ }
- error = mSettingsImp->set(CxeSettingIds::FLASH_MODE, Cxe::FlashOff);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::FLASH_MODE, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::FlashOff));
+ CX_DEBUG_EXIT_FUNCTION();
+}
- error = mSettingsImp->set(CxeSettingIds::FLASH_MODE, Cxe::FlashOn);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::FLASH_MODE, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::FlashOn));
+/*
+ * This will test calling void method of reset()
+ */
+void UnitTestCxeSettingsImp::testReset()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+ mSettingsImp->reset();
+ CX_DEBUG_EXIT_FUNCTION();
+}
- error = mSettingsImp->set(CxeSettingIds::FNAME_FOLDER_SUFFIX, range);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::FNAME_FOLDER_SUFFIX, checkValue);
- QCOMPARE(int(checkValue.toInt()), range);
-
- error = mSettingsImp->set(CxeSettingIds::FNAME_IMAGE_COUNTER, range);
+void UnitTestCxeSettingsImp::testGetVariationSetting()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+ QVariant value;
+ CxeError::Id error = mSettingsImp->getVariationValue(CxeVariationKeys::STILL_MAX_ZOOM_LIMITS, value);
QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::FNAME_IMAGE_COUNTER, checkValue);
- QCOMPARE(int(checkValue.toInt()), range);
- error = mSettingsImp->set(CxeSettingIds::FNAME_MONTH_FOLDER, range);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::FNAME_MONTH_FOLDER, checkValue);
- QCOMPARE(int(checkValue.toInt()), range);
+ error = mSettingsImp->getVariationValue(FAIL_TEST_SETTING, value);
+ QCOMPARE(error, CxeError::NotFound);
+ CX_DEBUG_EXIT_FUNCTION();
+}
- error = mSettingsImp->set(CxeSettingIds::FNAME_VIDEO_COUNTER, range);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::FNAME_VIDEO_COUNTER, checkValue);
- QCOMPARE(int(checkValue.toInt()), range);
+void UnitTestCxeSettingsImp::testListenForSetting()
+{
+ CX_DEBUG_ENTER_FUNCTION();
- error = mSettingsImp->set(CxeSettingIds::FOCAL_RANGE, range);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::FOCAL_RANGE, checkValue);
- QCOMPARE(int(checkValue.toInt()), range);
-
- error = mSettingsImp->set(CxeSettingIds::IMAGE_QUALITY, range);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::IMAGE_QUALITY, checkValue);
- QCOMPARE(int(checkValue.toInt()), range);
+ // This test case will initialize listening for certain setting changes
+ // and will verify that listener has succesfully deployed the signal
- error = mSettingsImp->set(CxeSettingIds::IMAGE_SCENE, range);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::IMAGE_SCENE, checkValue);
- QCOMPARE(int(checkValue.toInt()), range);
+ // First let's initialize a signal spy
+ QSignalSpy spy(mSettingsImp, SIGNAL(settingValueChanged(QString, QVariant)));
- error = mSettingsImp->set(CxeSettingIds::LIGHT_SENSITIVITY, Cxe::LightSensitivityAutomatic);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::LIGHT_SENSITIVITY, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::LightSensitivityAutomatic));
-
- error = mSettingsImp->set(CxeSettingIds::LIGHT_SENSITIVITY, Cxe::LightSensitivityHigh);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::LIGHT_SENSITIVITY, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::LightSensitivityHigh));
+ // Initializing the original value to make sure it changes later on
+ mSettingsStore->set(CxeSettingIds::CAMERA_MODE, Cxe::ImageMode);
- error = mSettingsImp->set(CxeSettingIds::LIGHT_SENSITIVITY, Cxe::LightSensitivityLow);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::LIGHT_SENSITIVITY, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::LightSensitivityLow));
+ // Now start listening and verify that starting was succesfull
+ bool result = mSettingsImp->listenForSetting(CxeSettingIds::CAMERA_MODE, this, SLOT(testSlot()));
+ QVERIFY(result);
- error = mSettingsImp->set(CxeSettingIds::LIGHT_SENSITIVITY, Cxe::LightSensitivityMedium);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::LIGHT_SENSITIVITY, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::LightSensitivityMedium));
-
- error = mSettingsImp->set(CxeSettingIds::SCENE_ID, range);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::SCENE_ID, checkValue);
- QCOMPARE(int(checkValue.toInt()), range);
+ // Now change the setting and wait for the signal
+ //mSettingsStore->set(CxeSettingIds::CAMERA_MODE, Cxe::VideoMode);
+ mSettingsImp->set(CxeSettingIds::CAMERA_MODE, Cxe::VideoMode);
- error = mSettingsImp->set(CxeSettingIds::SECONDARY_CAMERA, range);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::SECONDARY_CAMERA, checkValue);
- QCOMPARE(int(checkValue.toInt()), range);
- error = mSettingsImp->set(CxeSettingIds::SELF_TIMER, range);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::SELF_TIMER, checkValue);
- QCOMPARE(int(checkValue.toInt()), range);
-
- error = mSettingsImp->set(CxeSettingIds::SHARPNESS, Cxe::SharpnessHard);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::SHARPNESS, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::SharpnessHard));
+ // Check that signal was emitted
+ QVERIFY(CxeTestUtils::waitForSignal(spy, SIGNAL_TIMEOUT));
- error = mSettingsImp->set(CxeSettingIds::SHARPNESS, Cxe::SharpnessNormal);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::SHARPNESS, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::SharpnessNormal));
+ // One more check with invalid input parameter
+ result = mSettingsImp->listenForSetting(FAIL_TEST_SETTING, this, SLOT(testSlot()));
+ QVERIFY(!result);
- error = mSettingsImp->set(CxeSettingIds::SHARPNESS, Cxe::SharpnessSoft);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::SHARPNESS, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::SharpnessSoft));
-
- error = mSettingsImp->set(CxeSettingIds::VIDEO_SCENE, range);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::VIDEO_SCENE, checkValue);
- QCOMPARE(int(checkValue.toInt()), range);
+ // Now disconnecting the listener and checking if the signal is still emitted
+ disconnect(mSettingsImp, SIGNAL(settingValueChanged(QString,QVariant)), this, SLOT(testSlot()));
+ delete mSettingsImp;
+ mSettingsImp = NULL;
- error = mSettingsImp->set(CxeSettingIds::WHITE_BALANCE, Cxe::WhitebalanceAutomatic);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::WHITE_BALANCE, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::WhitebalanceAutomatic));
+ mSettingsStore->set(CxeSettingIds::CAMERA_MODE, Cxe::ImageMode);
- error = mSettingsImp->set(CxeSettingIds::WHITE_BALANCE, Cxe::WhitebalanceCloudy);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::WHITE_BALANCE, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::WhitebalanceCloudy));
-
- error = mSettingsImp->set(CxeSettingIds::WHITE_BALANCE, Cxe::WhitebalanceFluorescent);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::WHITE_BALANCE, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::WhitebalanceFluorescent));
+ // Make sure that no additional signals are emitted
+ QVERIFY(!CxeTestUtils::waitForSignal(spy, SIGNAL_TIMEOUT));
- error = mSettingsImp->set(CxeSettingIds::WHITE_BALANCE, Cxe::WhitebalanceIncandescent);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::WHITE_BALANCE, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::WhitebalanceIncandescent));
+ CX_DEBUG_EXIT_FUNCTION();
+}
- error = mSettingsImp->set(CxeSettingIds::WHITE_BALANCE, Cxe::WhitebalanceSunny);
- QCOMPARE(error, CxeError::None);
- mSettingsModel->getSettingValue(CxeSettingIds::WHITE_BALANCE, checkValue);
- QCOMPARE(int(checkValue.toInt()), ((int)Cxe::WhitebalanceSunny));
-
- /* Test fail parameter
- */
- error = mSettingsImp->set(FAIL_TEST_SETTING, Cxe::ColortoneNormal);
- QCOMPARE(error, CxeError::NotFound);
+/*
+ * Just a dummy slot
+ */
+void UnitTestCxeSettingsImp::testSlot()
+{
+ CX_DEBUG_IN_FUNCTION();
}
// main() function non-GUI testing
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxesettingsimp/unittest_cxesettingsimp.h Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxesettingsimp/unittest_cxesettingsimp.h Wed Aug 18 14:02:45 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"
@@ -11,18 +11,19 @@
*
* Contributors:
*
- * Description:
+ * Description: This test class contains unit tests for two cxengine classes:
+ * CxeSettings and CxeSettingsImp. CxeSettings is mostly a pure virtual
+ * class containing couple of overloaded versions of get() methods, and so it is
+ * tested together with CxeSettingsImp, which implements CxeSettings
*
*/
#ifndef UNITTEST_CXESETTINGSIMP_H
#define UNITTEST_CXESETTINGSIMP_H
#include <QObject>
-#include <QMetaType>
-
#include "cxesettingsimp.h"
-class CxeFakeSettingsModel;
+class CxeFakeSettingsStore;
class CxeSettingsImp;
class UnitTestCxeSettingsImp : public QObject
@@ -33,22 +34,32 @@
UnitTestCxeSettingsImp();
virtual ~UnitTestCxeSettingsImp();
+public slots:
+ void testSlot();
+
private slots:
void init();
void cleanup();
+ void testLoadImageSettings();
+ void testLoadVideoSettings();
+ void testLoadImageAndVideoSettings();
+
void testGet();
void testGet2();
+ void testGet3();
+ void testGetGarbage();
void testSet();
- void testLoadSettings();
+
+ void testReset();
+ void testGetVariationSetting();
+ void testListenForSetting();
private:
- CxeFakeSettingsModel *mSettingsModel;
+ CxeFakeSettingsStore *mSettingsStore;
CxeSettingsImp *mSettingsImp;
};
-Q_DECLARE_METATYPE(CxeScene)
-
#endif
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxesettingsimp/unittest_cxesettingsimp.pro Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxesettingsimp/unittest_cxesettingsimp.pro Wed Aug 18 14:02:45 2010 +0300
@@ -1,4 +1,4 @@
-# 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"
@@ -14,15 +14,16 @@
TARGET = unittest_cxesettingsimp
HEADERS *= unittest_cxesettingsimp.h \
- cxefakesettingsmodel.h \
+ cxefakesettingsstore.h \
cxesettings.h \
cxesettingsimp.h \
cxutils.h \
cxenamespace.h \
cxeerror.h \
- cxesettingsmodel.h
+ cxescenemodestore.h
SOURCES *= unittest_cxesettingsimp.cpp \
cxesettingsimp.cpp \
- cxefakesettingsmodel.cpp
+ cxefakesettingsstore.cpp \
+ cxescenemodestore.cpp
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxestillcapturecontrolsymbian/unittest_cxestillcapturecontrolsymbian.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxestillcapturecontrolsymbian/unittest_cxestillcapturecontrolsymbian.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -27,7 +27,6 @@
#include "unittest_cxestillcapturecontrolsymbian.h"
#include "cxefakeviewfindercontrol.h"
#include "cxesnapshotcontrol.h"
-#include "cxesettingsmodel.h"
#include "cxesensoreventhandlersymbian.h"
#include "cxefilenamegeneratorsymbian.h"
#include "cxefakefilenamegenerator.h"
@@ -60,7 +59,6 @@
// Run before each individual test case
void UnitTestCxeStillCaptureControlSymbian::initTestCase()
{
- mFakeSettings = new CxeFakeSettings();
mFakeSettings->set(CxeSettingIds::IMAGE_QUALITY, 0);
mFakeCameraDeviceControl = new CxeFakeCameraDeviceControl();
mFakeCameraDevice = new CxeFakeCameraDevice();
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxestillcapturecontrolsymbian/unittest_cxestillcapturecontrolsymbian.pro Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxestillcapturecontrolsymbian/unittest_cxestillcapturecontrolsymbian.pro Wed Aug 18 14:02:45 2010 +0300
@@ -60,7 +60,6 @@
sensor/xqaccsensor_p.cpp \
sensor/xqsensor.cpp \
sensor/xqsensor_p.cpp \
- cxesettingsmodelimp.cpp \
cxesettingsimp.cpp \
cxefakeviewfindercontrol.cpp \
cxesoundplayersymbian.cpp \
@@ -104,7 +103,6 @@
sensor/xqsensor.h \
sensor/xqsensor_p.h \
sensor/xqaccsensor_p.h \
- cxesettingsmodel.h \
cxesettingsimp.h \
cxesettings.h \
cxecenrepkeys.h \
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxevideocapturecontrolsymbian/unittest_cxevideocapturecontrolsymbian.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxevideocapturecontrolsymbian/unittest_cxevideocapturecontrolsymbian.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -67,7 +67,6 @@
mCameraDevice = new CxeFakeCameraDevice();
mViewfinderControl = new CxeFakeViewfinderControl();
mSnapshotControl = new CxeSnapshotControl(*mCameraDevice);
- mSettings = new CxeFakeSettings();
mSettings->set(CxeSettingIds::VIDEO_SHOWCAPTURED, -1);
mFilenameGeneratorSymbian = new CxeFakeFilenameGenerator();
mFilenameGeneratorSymbian->init(Cxe::VideoMode);
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxevideocapturecontrolsymbian/unittest_cxevideocapturecontrolsymbian.pro Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxevideocapturecontrolsymbian/unittest_cxevideocapturecontrolsymbian.pro Wed Aug 18 14:02:45 2010 +0300
@@ -43,7 +43,6 @@
cxefakecameradevicecontrol.cpp \
cxefakesettings.cpp \
cxesettingsimp.cpp \
- cxefakesettingsmodel.cpp \
cxestatemachine.cpp \
cxestate.cpp \
cxestatemachinebase.cpp \
@@ -75,7 +74,6 @@
cxesettingsimp.h \
cxesettings.h \
cxefakesettings.h \
- cxefakesettingsmodel.h \
cxestatemachine.h \
cxestate.h \
cxeerrormappingsymbian.h \
--- a/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxezoomcontrolsymbian/unittest_cxezoomcontrolsymbian.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxezoomcontrolsymbian/unittest_cxezoomcontrolsymbian.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -52,7 +52,6 @@
mFakeCameraDeviceControl = new CxeFakeCameraDeviceControl;
mFakeCameraDeviceControl->setState(CxeCameraDeviceControl::Ready);
- mFakeSettings = new CxeFakeSettings();
mFakeFeatureManager = new CxeFakeFeatureManager();
mZoomControl = new CxeZoomControlSymbian(*mFakeCameraDevice,
--- a/camerauis/cameraxui/cxui/cxui.pro Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxui/cxui.pro Wed Aug 18 14:02:45 2010 +0300
@@ -92,6 +92,16 @@
HB += hbcore hbwidgets hbfeedback hbutils
# Input
+
+DOCML += layouts/errornote_popup.docml \
+ layouts/full_screen_popup.docml \
+ layouts/setting.docml \
+ layouts/setting_scenemode.docml \
+ layouts/setting_slider.docml \
+ layouts/view_postcapture.docml \
+ layouts/view_still_precapture.docml \
+ layouts/view_video_precapture.docml
+
HEADERS += cxengine_global.h \
cxuiapplication.h \
cxuiapplicationframeworkmonitor.h \
--- a/camerauis/cameraxui/cxui/cxui.qrc Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxui/cxui.qrc Wed Aug 18 14:02:45 2010 +0300
@@ -3,14 +3,14 @@
<file alias="cxui.css" >layouts/cxui.css</file>
</qresource>
<qresource prefix="/xml" >
- <file alias="setting_scenemode.docml" >layouts/setting_scenemode.docml</file>
- <file alias="view_still_precapture.docml" >layouts/view_still_precapture.docml</file>
- <file alias="view_video_precapture.docml" >layouts/view_video_precapture.docml</file>
- <file alias="view_postcapture.docml" >layouts/view_postcapture.docml</file>
- <file alias="errornote_popup.docml" >layouts/errornote_popup.docml</file>
- <file alias="setting.docml" >layouts/setting.docml</file>
- <file alias="setting_slider.docml" >layouts/setting_slider.docml</file>
- <file alias="full_screen_popup.docml" >layouts/full_screen_popup.docml</file>
+ <file alias="setting_scenemode.docml" >layouts/setting_scenemode.docml.bin</file>
+ <file alias="view_still_precapture.docml" >layouts/view_still_precapture.docml.bin</file>
+ <file alias="view_video_precapture.docml" >layouts/view_video_precapture.docml.bin</file>
+ <file alias="view_postcapture.docml" >layouts/view_postcapture.docml.bin</file>
+ <file alias="errornote_popup.docml" >layouts/errornote_popup.docml.bin</file>
+ <file alias="setting.docml" >layouts/setting.docml.bin</file>
+ <file alias="setting_slider.docml" >layouts/setting_slider.docml.bin</file>
+ <file alias="full_screen_popup.docml" >layouts/full_screen_popup.docml.bin</file>
<file alias="image_setting.xml" >layouts/image_setting.xml</file>
<file alias="video_setting.xml" >layouts/video_setting.xml</file>
</qresource>
--- a/camerauis/cameraxui/cxui/src/cxuiapplication.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxui/src/cxuiapplication.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -33,7 +33,7 @@
*/
CxuiApplication::CxuiApplication(int &argc, char *argv[])
- : HbApplication(argc, argv, Hb::SplashFixedHorizontal)
+ : HbApplication(argc, argv, Hb::NoSplash)
{
CX_DEBUG_IN_FUNCTION();
}
--- a/camerauis/cameraxui/cxui/src/cxuistillprecaptureview.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxui/src/cxuistillprecaptureview.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -555,7 +555,8 @@
{
CX_DEBUG_ENTER_FUNCTION();
- if (!mEngine->autoFocusControl().supported()) {
+ if (!mEngine->autoFocusControl().supported() ||
+ mEngine->autoFocusControl().isFixedFocusMode(mEngine->autoFocusControl().mode())) {
// autofocus is not supported, so start capturing straight away
capture();
} else {
--- a/camerauis/cameraxui/cxui/src/main.cpp Fri Jul 23 11:35:41 2010 +0300
+++ b/camerauis/cameraxui/cxui/src/main.cpp Wed Aug 18 14:02:45 2010 +0300
@@ -57,10 +57,9 @@
Q_INIT_RESOURCE(cxui);
- // Use software rendering / raster graphics system to save GPU memory.
- CX_DEBUG(("CxUI: Take raster graphics system into use.."));
+ // Use software rendering / raster graphics system to save graphics memory
+ CX_DEBUG(("CxUI: Take raster graphics system into use"));
QApplication::setGraphicsSystem("raster");
- CX_DEBUG(("CxUI: ..raster graphics system in use"));
OstTrace0( camerax_performance, DUP1__MAIN, "msg: e_CX_HBAPP_CREATION 1" );
CxuiApplication app(argc, argv);
@@ -102,18 +101,11 @@
// so init can be done later
engine->setMode(mode);
}
- } else {
+ } else {
CX_DEBUG(("CxUI: Camera started as normal app"));
- // normal start
- engine->initMode(engine->mode());
- }
-
-#ifdef Q_OS_SYMBIAN
- //!@todo: Yield run time to system to get enough resources released to start camera.
- CX_DEBUG(("CxUI: yield control for resource freeing.."));
- User::After(2*1000*1000); // 2s
- CX_DEBUG(("CxUI: waiting done.."));
-#endif // Q_OS_SYMBIAN
+ // normal start
+ engine->initMode(engine->mode());
+ }
// Load language specific application localization file, e.g. "camera_en.qm"
// Translations need to be loaded before any widgets are created.