--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraxui/cxengine/src/cxesettingsimp.cpp Tue Aug 31 15:03:46 2010 +0300
@@ -0,0 +1,535 @@
+/*
+* 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:
+*
+*/
+/*
+* Symbian specific settings handling
+*/
+
+#include <QCoreApplication>
+#include <QVariant>
+#include <QList>
+#include <QMetaType>
+#include <QObject>
+
+#include "cxesettingsimp.h"
+#include "cxutils.h"
+#include "cxenamespace.h"
+#include "cxeerror.h"
+#include "cxesettingsstore.h"
+#include "cxeexception.h"
+
+#ifdef Q_OS_SYMBIAN
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "cxesettingsimpTraces.h"
+#endif
+#endif // Q_OS_SYMBIAN
+
+
+// signatures for setting listener slots
+const char *SETTING_LISTENER_SIGNATURE1 = "settingChanged(const QString &, const QVariant &)";
+const char *SETTING_LISTENER_SIGNATURE2 = "settingChanged(const QVariant &)";
+
+
+/*
+* CxeSettingsImp::CxeSettingsImp
+*/
+CxeSettingsImp::CxeSettingsImp(CxeSettingsStore *settingStore)
+: mSettingStore(settingStore),
+ mVariationSettings(),
+ mSceneModeStore(),
+ mCameraMode(Cxe::ImageMode)
+{
+ CX_DEBUG_ENTER_FUNCTION();
+ loadVariationSettings();
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*
+* CxeSettingsImp::close
+*/
+CxeSettingsImp::~CxeSettingsImp()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+ delete mSettingStore;
+
+ mVariationSettings.clear();
+ mSettingListeners.clear();
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*
+* Reads a value from cenrep
+* @param key - setting key
+* @param uid - setting UID of the component that owns the setting key
+* @param type - the type of key cr key or P&S key (constantly monitoring value)
+* @param value - setting value read from cenrep
+*/
+
+void CxeSettingsImp::get(long int uid,
+ unsigned long int key,
+ Cxe::SettingKeyType type,
+ QVariant &value) const
+{
+ CX_DEBUG_ENTER_FUNCTION();
+ CX_DEBUG_ASSERT(mSettingStore);
+
+ mSettingStore->startMonitoring(uid, key, type, value);
+
+ CX_DEBUG_EXIT_FUNCTION();
+
+}
+
+
+/*!
+ Reset static settings (persistent settings)
+*/
+void CxeSettingsImp::reset()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ CX_DEBUG_ASSERT(mSettingStore);
+ mSettingStore->reset();
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Get the configured run-time value associated with the key.
+* @Param key - Setting key Id ( refer to CxeSettingIds in cxenums.h )
+* @Param value - contains the value associated with the key.
+* @returns CxeError::None if successful or any CxeError specific error code.
+*/
+CxeError::Id CxeSettingsImp::getVariationValue(const QString &key, QVariant &value)
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ CxeError::Id err = CxeError::None;
+
+ // read run-time configuration value
+ if ( mVariationSettings.contains(key) ) {
+ value = qVariantFromValue<QVariantList > (mVariationSettings.value(key));
+ } else {
+ err = CxeError::NotFound;
+ }
+
+ CX_DEBUG_EXIT_FUNCTION();
+
+ return err;
+}
+
+
+/*!
+ * Add listener for changes in one setting. When the value of the setting changes, the given
+ * slot is invoked on given object.
+ * The validity of the settingKey is not checked.
+ *
+ * @param settingKey Setting to listen to
+ * @param target Object that the slot will be invoked for
+ * @param slot Slot that will be invoked. The slot can have either of these two signatures:
+ * slotName(const QVariant&) only new value of setting is passed as parameter
+ * slotName(const QString&, const QVariant&) both setting key and new value are passed as parameter
+ *
+ * @return boolean to indicate success
+ *
+ */
+bool CxeSettingsImp::listenForSetting(const QString &settingKey, QObject *target, const char *slot)
+{
+
+ CX_DEBUG_ENTER_FUNCTION();
+ CX_DEBUG_ASSERT(target && slot);
+
+ // SLOT() macro adds '1' to the beginning of string so we use slot+1 to get the name of the slot
+ CX_DEBUG(("Adding listener %s::%s for key %s", target->metaObject()->className(), slot+1, settingKey.toAscii().data()));
+ QByteArray normalizedSlotName = QMetaObject::normalizedSignature(slot+1);
+
+ int slotIndex = target->metaObject()->indexOfSlot(normalizedSlotName);
+
+ bool ok = false;
+ if (slotIndex > -1) {
+ CX_DEBUG(("Slot found, checking signature"));
+ // verify that slot is correct type
+ if (QMetaObject::checkConnectArgs(QMetaObject::normalizedSignature(SETTING_LISTENER_SIGNATURE1), normalizedSlotName) ||
+ QMetaObject::checkConnectArgs(QMetaObject::normalizedSignature(SETTING_LISTENER_SIGNATURE2), normalizedSlotName)) {
+
+ CX_DEBUG(("Slot signature ok, adding listener"));
+
+ // check if list for given key already exists
+ if (!mSettingListeners.contains(settingKey)) {
+ mSettingListeners.insert(settingKey, CxeSettingListenerList());
+ }
+
+ // get QMetaMethod object
+ QMetaMethod method = target->metaObject()->method(slotIndex);
+ // add listener to the list
+ CxeSettingListenerList& list = mSettingListeners[settingKey];
+ list.append(CxeSettingListener(target, method));
+
+ // connect to destroyed() signal so we can remove listener if it's deleted
+ connect(target, SIGNAL(destroyed(QObject*)), this, SLOT(handleListenerDestroyed(QObject*)));
+
+ ok = true;
+ } else {
+ CX_DEBUG(("Slot signature doesn't match, can't add listener"));
+ }
+
+ } else {
+ CX_DEBUG(("Slot not found, can't add listener"));
+ }
+
+ CX_DEBUG_EXIT_FUNCTION();
+ return ok;
+}
+
+/*!
+ Load image/video specific settings during mode change or startup
+*/
+void CxeSettingsImp::loadSettings(Cxe::CameraMode mode)
+{
+ CX_DEBUG_ENTER_FUNCTION();
+ OstTrace0(camerax_performance, CXESETTINGSIMP_LOADSETTINGS_IN, "msg: e_CX_SETTINGS_LOADSETTINGS 1");
+
+ mCameraMode = mode;
+
+ // inform the settings model for the change in mode.
+ if (mode == Cxe::ImageMode) {
+ restoreImageSettings();
+ notifyListeners(CxeSettingIds::IMAGE_SCENE_DATA, mSceneModeStore.currentScene(Cxe::ImageMode));
+ notifyListeners(CxeSettingIds::IMAGE_SCENE, mSceneModeStore.currentSceneId(Cxe::ImageMode));
+ emit settingValueChanged(CxeSettingIds::IMAGE_SCENE, mSceneModeStore.currentSceneId(Cxe::ImageMode));
+ } else {
+ restoreVideoSettings();
+ notifyListeners(CxeSettingIds::VIDEO_SCENE_DATA, mSceneModeStore.currentScene(Cxe::VideoMode));
+ notifyListeners(CxeSettingIds::VIDEO_SCENE, mSceneModeStore.currentSceneId(Cxe::VideoMode));
+ emit settingValueChanged(CxeSettingIds::VIDEO_SCENE, mSceneModeStore.currentSceneId(Cxe::VideoMode));
+ }
+
+ OstTrace0(camerax_performance, CXESETTINGSIMP_LOADSETTINGS_OUT, "msg: e_CX_SETTINGS_LOADSETTINGS 0");
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Get setting value associated with the key.
+* @Param key - Setting key Id ( refer to CxeSettingIds in cxenums.h )
+* @Param value - contains the value associated with the key.
+* @returns CxeError::None if successful or any CxeError specific error code.
+*/
+void CxeSettingsImp::getValue(const QString &key, QVariant &value) const
+{
+ CX_DEBUG_ENTER_FUNCTION();
+ CX_DEBUG_ASSERT(mSettingStore);
+
+
+ CxeError::Id err = CxeError::None;
+
+ // check if getting scene mode
+ if(key == CxeSettingIds::IMAGE_SCENE_DATA) {
+ value = mSceneModeStore.currentScene(Cxe::ImageMode);
+ } else if(key == CxeSettingIds::VIDEO_SCENE_DATA) {
+ value = mSceneModeStore.currentScene(Cxe::VideoMode);
+ } else {
+ // Try first to find the item from cenrep store.
+ err = mSettingStore->get(key, value);
+
+ // If setting is not in cenrep store, try fetching it from scene settings.
+ if (!err) {
+ CX_DEBUG(("Got value %s from settings store", value.toString().toAscii().data()));
+ } else {
+ // setting not found in setting store, try finding if its scene specific setting.
+ CX_DEBUG(( "fetching value from scene settings" ));
+ err = mSceneModeStore.sceneSettingValue(mCameraMode, key, value);
+ }
+ if (err) {
+ throw CxeException(err);
+ }
+ }
+
+ CX_DEBUG_EXIT_FUNCTION();
+
+}
+
+/*!
+* Set a value to the key.
+* @Param key - Setting key Id ( refer to CxeSettingIds in cxenums.h )
+* @Param value - contains the value associated with the key.
+* @returns CxeError::None if successful or any CxeError specific error code.
+*/
+void CxeSettingsImp::setValue(const QString &key, const QVariant &newValue)
+{
+ CX_DEBUG_ENTER_FUNCTION();
+ CX_DEBUG_ASSERT(mSettingStore);
+
+ CxeError::Id err;
+ // check if setting scene mode
+ if(key == CxeSettingIds::IMAGE_SCENE) {
+ setImageScene(newValue.toString());
+ } else if(key == CxeSettingIds::VIDEO_SCENE) {
+ setVideoScene(newValue.toString());
+ } else if(key == CxeSettingIds::IMAGE_SCENE_DATA || key == CxeSettingIds::VIDEO_SCENE_DATA) {
+ // setting whole scene by value is not supported
+ throw CxeException(CxeError::NotSupported);
+ } else {
+ // Try storing new value to cenrep
+ err = mSettingStore->set(key, newValue);
+
+ if (err) {
+ CX_DEBUG(( "Key not found in cenrepstore, writing value to scene settings" ));
+ err = mSceneModeStore.setSceneSettingValue(mCameraMode, key, newValue);
+ }
+
+ if (err) {
+ throw CxeException(err);
+ }
+
+ // send notifications
+ emit settingValueChanged(key, newValue);
+ notifyListeners(key, newValue);
+ }
+
+ CX_DEBUG_EXIT_FUNCTION();
+
+}
+
+/*!
+* Restores image settings, during mode change or during startup.
+*/
+void CxeSettingsImp::restoreImageSettings()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ QString currentSceneInUse = mSceneModeStore.currentSceneId(Cxe::ImageMode);
+
+ // get the image scene value from cenrep and load the scene settings
+ QString key(CxeSettingIds::IMAGE_SCENE);
+ QString cenrepSceneValue = CxeSettings::get<QString>(key);
+
+ bool ok2LoadSceneSettings = (cenrepSceneValue != currentSceneInUse);
+
+ if (ok2LoadSceneSettings) {
+ // loading scene settings
+ mSceneModeStore.setCurrentScene(Cxe::ImageMode, cenrepSceneValue);
+ }
+
+ // Updating Flash setting from cenrep
+ key = CxeSettingIds::FLASH_MODE;
+ int flashMode = CxeSettings::get<int>(key);
+
+ // update local datastructure with flash setting value from cenrep.
+ CX_DEBUG(( "flash setting value %d", flashMode));
+ mSceneModeStore.setSceneSettingValue(Cxe::ImageMode, key, flashMode);
+
+ // Updating Face Tracking setting from cenrep
+ key = CxeSettingIds::FACE_TRACKING;
+ int faceTracking = CxeSettings::get<int>(key);
+
+ // update local datastructure with flash setting value from cenrep.
+ CX_DEBUG(( "Face Tracking setting value %d", faceTracking));
+ mSceneModeStore.setSceneSettingValue(Cxe::ImageMode, key, faceTracking);
+
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+
+/*!
+* Restores video settings, during mode change or during startup.
+*/
+void CxeSettingsImp::restoreVideoSettings()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ QString currentSceneInUse = mSceneModeStore.currentSceneId(Cxe::VideoMode);
+
+ // get the video scene value from cenrep and load the scene settings
+ QString cenrepSceneValue = CxeSettings::get<QString>(CxeSettingIds::VIDEO_SCENE);
+
+ bool ok2LoadSceneSettings = (cenrepSceneValue != currentSceneInUse);
+
+ if (ok2LoadSceneSettings) {
+ // loading video scene settings
+ mSceneModeStore.setCurrentScene(Cxe::VideoMode, cenrepSceneValue);
+ }
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Set new Image scene mode.
+* @returns CxeError::None if successful or any CxeError specific error code.
+*/
+void CxeSettingsImp::setImageScene(const QString &newScene)
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ // load scene specific settings
+ mSceneModeStore.setCurrentScene(Cxe::ImageMode, newScene);
+
+ // saving current image scene to cenrep
+ CxeError::Id err = mSettingStore->set(CxeSettingIds::IMAGE_SCENE, newScene);
+ CxeException::throwIfError(err);
+
+ // saving flash value from scene to cenrep
+ // call CxeSettingStore::set directly because we don't want to send notifications
+ // about these changes
+ QString key(CxeSettingIds::FLASH_MODE);
+ err = mSettingStore->set(key, mSceneModeStore.currentScene(Cxe::ImageMode)[key].toInt());
+
+ CxeException::throwIfError(err);
+ // saving face tracking value from scene to cenrep
+ key = CxeSettingIds::FACE_TRACKING;
+ err = mSettingStore->set(key, mSceneModeStore.currentScene(Cxe::ImageMode)[key].toInt());
+ CxeException::throwIfError(err);
+
+ // send notifications
+ emit settingValueChanged(CxeSettingIds::IMAGE_SCENE, mSceneModeStore.currentSceneId(Cxe::ImageMode));
+ notifyListeners(CxeSettingIds::IMAGE_SCENE, mSceneModeStore.currentSceneId(Cxe::ImageMode));
+ notifyListeners(CxeSettingIds::IMAGE_SCENE_DATA, mSceneModeStore.currentScene(Cxe::ImageMode));
+
+ CX_DEBUG_EXIT_FUNCTION();
+
+}
+
+/*!
+* Set new video scene mode.
+* @returns CxeError::None if successful or any CxeError specific error code.
+*/
+void CxeSettingsImp::setVideoScene(const QString &newScene)
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ mSceneModeStore.setCurrentScene(Cxe::VideoMode, newScene);
+
+ // video scene set successfully, store the scene value to cenrep
+ CxeError::Id err = mSettingStore->set(CxeSettingIds::VIDEO_SCENE, newScene);
+ CxeException::throwIfError(err);
+
+ emit settingValueChanged(CxeSettingIds::VIDEO_SCENE, mSceneModeStore.currentSceneId(Cxe::VideoMode));
+ notifyListeners(CxeSettingIds::VIDEO_SCENE, mSceneModeStore.currentSceneId(Cxe::VideoMode));
+ notifyListeners(CxeSettingIds::VIDEO_SCENE_DATA, mSceneModeStore.currentScene(Cxe::VideoMode));
+
+ CX_DEBUG_EXIT_FUNCTION();
+
+}
+
+/*!
+* Loads all run-time variation settings
+*/
+void CxeSettingsImp::loadVariationSettings()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+ CX_DEBUG_ASSERT( mSettingStore );
+
+ QList<QString> variationKeys;
+ // all supported runtime variation keys are fetched from here.
+ variationKeys.append(CxeVariationKeys::FREE_MEMORY_LEVELS);
+ variationKeys.append(CxeVariationKeys::STILL_MAX_ZOOM_LIMITS);
+ variationKeys.append(CxeVariationKeys::VIDEO_MAX_ZOOM_LIMITS);
+
+ // load all run-time setting values from cenrep.
+ mVariationSettings = mSettingStore->loadVariationSettings(variationKeys);
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+ * Notify setting listeners that setting has changed
+ * @param settingKey Setting that has changed
+ * @param newValue New value of the setting
+ */
+void CxeSettingsImp::notifyListeners(const QString &settingKey, const QVariant &newValue)
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ CX_DEBUG(("CxeSettingsImp::notifyListeners settingKey=%s", settingKey.toAscii().data()));
+
+ if (mSettingListeners.contains(settingKey)) {
+ CX_DEBUG(("Listeners found"));
+ // get list of listener
+ CxeSettingListenerList& list = mSettingListeners[settingKey];
+
+ // iterate through the list and call all listeners
+ CxeSettingListenerList::const_iterator i = list.constBegin();
+ for(; i != list.constEnd(); ++i) {
+
+ QObject *object = (*i).first;
+ QMetaMethod slot = (*i).second;
+
+ CX_DEBUG_ASSERT(object);
+
+ // invoke the slot
+ CX_DEBUG(("Calling slot %s::%s", object->metaObject()->className(), slot.signature()));
+
+ bool ok = false;
+ if (slot.parameterTypes().size() == 2) {
+ // slot has two parameters, send settingKey as well
+ ok = slot.invoke(object,
+ Qt::AutoConnection,
+ Q_ARG(QString, settingKey),
+ Q_ARG(QVariant, newValue));
+ } else {
+ // don't send settingKey as parameter
+ ok = slot.invoke(object,
+ Qt::AutoConnection,
+ Q_ARG(QVariant, newValue));
+ }
+
+ if (!ok) {
+ CX_DEBUG(("QMetaMethod::invoke() failed, listener not notified"))
+ }
+
+ }
+
+ } else {
+ CX_DEBUG(("NO listeners found"));
+ }
+
+
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+ * Handle deletion of registered listener.
+ */
+void CxeSettingsImp::handleListenerDestroyed(QObject *object)
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ QList<QString> keyList = mSettingListeners.keys();
+
+ for (int i = 0; i < keyList.size(); i++) {
+
+ QString key = keyList[i];
+ CxeSettingListenerList& list = mSettingListeners[key];
+
+ for (int j = 0; j < list.size(); j++) {
+ CxeSettingListener &listener = list[j];
+ if (listener.first == object) {
+ list.removeAt(j--);
+ }
+ }
+
+ // removed last listener for this key
+ if (list.size() == 0) {
+ mSettingListeners.remove(key);
+ }
+ }
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+// end of file