# HG changeset patch
# User hgs
# Date 1282129365 -10800
# Node ID ccc0e7e3344fabc461d1700de94b05e609b5b6e6
# Parent  24fd826316162d7e76abc7f70f3d8be0699362fc
201031_1

diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/inc/cxecameradevicecontrolsymbian.h
--- 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
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/inc/cxegeotaggingtrail_symbian_p.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;
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/src/cxecameradevicecontrolsymbian.cpp
--- 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;
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/src/cxegeotaggingtrail_symbian_p.cpp
--- 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 = 
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakeautofocuscontrol.cpp
--- 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;
 }
 
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakefilesavethread.cpp
--- 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);
 }
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakesettingsmodel.cpp
--- 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
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakesettingsmodel.h
--- 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
-
-
-
-
-
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakesettingsstore.cpp
--- 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();
 }
 
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakesettingsstore.h
--- 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*/
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/fakeclasses/cxefakevideorecorderutility.cpp
--- 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();
 }
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/cxeunitrunner/cxetestrunner.cpp
--- 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);
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/system_include/imagingconfigmanager.cpp
--- /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;
+
+}
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/system_include/imagingconfigmanager.h
--- /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
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/system_include/thumbnailmanager_qt.cpp
--- 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;
 
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unit.pro
--- 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 \
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeautofocuscontrolsymbian/cxeautofocuscontrolsymbianunit.cpp
--- /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()
+{
+
+}
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeautofocuscontrolsymbian/cxeautofocuscontrolsymbianunit.h
--- /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_ */
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeautofocuscontrolsymbian/unittest_cxeautofocuscontrolsymbian.cpp
--- 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);
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeautofocuscontrolsymbian/unittest_cxeautofocuscontrolsymbian.h
--- 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
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeautofocuscontrolsymbian/unittest_cxeautofocuscontrolsymbian.pro
--- 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
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxecameradevicecontrolsymbian/cxecameradevicecontrolunit.cpp
--- 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"
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeenginesymbian/cxeenginesymbianunit.cpp
--- 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();
 
     }
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeenginesymbian/unittest_cxeenginesymbian.pro
--- 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
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxefeaturemanagerimp/unittest_cxefeaturemanagerimp.cpp
--- 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);
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxefeaturemanagerimp/unittest_cxefeaturemanagerimp.h
--- 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
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxefeaturemanagerimp/unittest_cxefeaturemanagerimp.pro
--- 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
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxefilenamegeneratorsymbian/unittest_cxefilenamegeneratorsymbian.cpp
--- 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);
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxememorymonitor/oommonitorsession.cpp
--- 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
 }
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxequalitypresetssymbian/unittest_cxequalitypresetssymbian.cpp
--- 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"
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxequalitypresetssymbian/unittest_cxequalitypresetssymbian.pro
--- 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 \
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxesettingscenrepstore/unittest_cxesettingscenrepstore.cpp
--- 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;
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxesettingsimp/unittest_cxesettingsimp.cpp
--- 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
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxesettingsimp/unittest_cxesettingsimp.h
--- 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
 
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxesettingsimp/unittest_cxesettingsimp.pro
--- 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
 
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxestillcapturecontrolsymbian/unittest_cxestillcapturecontrolsymbian.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();
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxestillcapturecontrolsymbian/unittest_cxestillcapturecontrolsymbian.pro
--- 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 \
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxevideocapturecontrolsymbian/unittest_cxevideocapturecontrolsymbian.cpp
--- 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);
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxevideocapturecontrolsymbian/unittest_cxevideocapturecontrolsymbian.pro
--- 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 \
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxezoomcontrolsymbian/unittest_cxezoomcontrolsymbian.cpp
--- 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,
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxui/cxui.pro
--- 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 \
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxui/cxui.qrc
--- 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>
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxui/src/cxuiapplication.cpp
--- 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();
 }
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxui/src/cxuistillprecaptureview.cpp
--- 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 {
diff -r 24fd82631616 -r ccc0e7e3344f camerauis/cameraxui/cxui/src/main.cpp
--- 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.