--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraxui/cxengine/src/cxezoomcontrolsymbian.cpp Fri Apr 16 14:51:30 2010 +0300
@@ -0,0 +1,319 @@
+/*
+* Copyright (c) 2009 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 "cxezoomcontrolsymbian.h"
+#include "cxecameradevicecontrol.h"
+#include "cxefeaturemanager.h"
+#include "cxesettings.h"
+#include "cxutils.h"
+#include "cxenamespace.h"
+#include "cxestate.h"
+
+const int NOT_DEFINED = -1;
+
+// ---------------------------------------------------------------------------
+// CxeZoomControlSymbian::CxeZoomControlSymbian
+//
+// ---------------------------------------------------------------------------
+//
+CxeZoomControlSymbian::CxeZoomControlSymbian(CxeCameraDevice &cameraDevice,
+ CxeCameraDeviceControl &cameraDeviceControl,
+ CxeSettings &settings,
+ CxeFeatureManager &featureManager) :
+ CxeStateMachine("CxeZoomControlSymbian"),
+ mCameraDevice(cameraDevice),
+ mCameraDeviceControl(cameraDeviceControl),
+ mSettings(settings)
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ qRegisterMetaType<CxeZoomControl::State> ();
+
+ // Initialize states and member variables
+ initializeStates();
+
+ // getting still max zoom limits from feature manager
+ featureManager.configuredValues(CxeRuntimeKeys::STILL_MAX_ZOOM_LIMITS, mStillMaxZoomLimits);
+ featureManager.configuredValues(CxeRuntimeKeys::VIDEO_MAX_ZOOM_LIMITS, mVideoMaxZoomLimits);
+
+ connect(&mCameraDevice,
+ SIGNAL(prepareForCameraDelete()),
+ this,
+ SLOT(reset()));
+
+ // enabling setting value change call backs
+ connect(&mSettings,
+ SIGNAL(settingValueChanged(const QString&,QVariant)),
+ this,
+ SLOT(handleSettingValueChanged(const QString&,QVariant)));
+
+ init();
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+// ---------------------------------------------------------------------------
+// CxeZoomControlSymbian::~CxeZoomControlSymbian
+//
+// ---------------------------------------------------------------------------
+//
+CxeZoomControlSymbian::~CxeZoomControlSymbian()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ // clean up
+ mDigitalZoomValues.Close();
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+// ---------------------------------------------------------------------------
+// CxeZoomControlSymbian::min
+// Get the minimum zoom index
+// ---------------------------------------------------------------------------
+//
+int CxeZoomControlSymbian::min() const
+{
+ return mMinZoomLevel;
+}
+
+// ---------------------------------------------------------------------------
+// CxeZoomControlSymbian::max
+// Get the maximum zoom index
+// ---------------------------------------------------------------------------
+//
+int CxeZoomControlSymbian::max() const
+{
+ return mMaxZoomLevel;
+}
+
+void CxeZoomControlSymbian::init()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ // Initialize the variables
+ mMinZoomLevel = 0;
+ mMaxZoomLevel = 0;
+ mCurrentZoomLevel = 0;
+ mDigitalZoomValues.Close();
+
+ setState(Idle);
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+// ---------------------------------------------------------------------------
+// CxeZoomControlSymbian::reset
+// Re-initializes the zoom control
+// ---------------------------------------------------------------------------
+//
+void CxeZoomControlSymbian::reset()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ init();
+ emit zoomLevelChanged(mCurrentZoomLevel);
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+
+
+/**
+ * Settings changed, needs updated
+ */
+void CxeZoomControlSymbian::handleSettingValueChanged(const QString& settingId, QVariant /*newValue*/)
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ if (settingId == CxeSettingIds::IMAGE_QUALITY ||
+ settingId == CxeSettingIds::VIDEO_QUALITY) {
+ reset();
+ } else {
+ // do nothing
+ }
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+
+/*!
+* slot to prepare zoom control for still mode
+*/
+void CxeZoomControlSymbian::prepareZoomForStill(int ecamStillResolutionIndex)
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ if (mCameraDeviceControl.state() == CxeCameraDeviceControl::Ready) {
+ init();
+ // For image mode
+ CCamera::TFormat format = CCamera::EFormatExif;
+ TBool isInfluencePossible = EFalse;
+ int error = KErrNone;
+
+ // Get the zoom steps for image mode
+ TRAP(error, mCameraDevice.advancedSettings()->GetDigitalZoomStepsForStillL (
+ mDigitalZoomValues,
+ mDigitalZoomValueInfo,
+ ecamStillResolutionIndex,
+ format,
+ isInfluencePossible));
+
+ int imageQualityIndex;
+ CxeError::Id cxErr = mSettings.get(CxeSettingIds::IMAGE_QUALITY, imageQualityIndex);
+ if (cxErr == CxeError::None && mStillMaxZoomLimits.count() > 0) {
+ // fetching the zoom limit based on the image quality
+ mMaxZoomLevel = mStillMaxZoomLimits[imageQualityIndex];
+ } else {
+ mMaxZoomLevel = NOT_DEFINED;
+ }
+
+ finalizeZoomPreparation(error);
+ }
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+
+/*!
+* slot to prepare zoom control for video mode
+*/
+void CxeZoomControlSymbian::prepareZoomForVideo()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ if (mCameraDeviceControl.state() == CxeCameraDeviceControl::Ready) {
+ init();
+ // if CxeCameraDeviceControl is ready, this pointer is valid
+ CX_ASSERT_ALWAYS(mCameraDevice.advancedSettings())
+ int error = KErrNone;
+ TRAP(error,
+ mCameraDevice.advancedSettings()->GetDigitalZoomStepsL(mDigitalZoomValues, mDigitalZoomValueInfo);
+ );
+
+ if (mVideoMaxZoomLimits.count() > 0) {
+ // fetching the zoom limit based on the video quality
+ mMaxZoomLevel = mVideoMaxZoomLimits[0];
+ } else {
+ mMaxZoomLevel = NOT_DEFINED;
+ }
+
+ finalizeZoomPreparation(error);
+ }
+
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+
+
+/**
+* Completes zoom control preparation.
+*/
+void CxeZoomControlSymbian::finalizeZoomPreparation(int error)
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ CX_DEBUG(("Num digital zoom steps: %d", mDigitalZoomValues.Count()));
+ CX_DEBUG(("Maximum zoom limit: %d", mMaxZoomLevel));
+
+ if (!error) {
+ // Note that this is called only after setting the resolution.
+ TCameraInfo cameraInfo;
+ mCameraDevice.camera()->CameraInfo(cameraInfo);
+ CX_DEBUG(("cameraInfo.iMinZoom: %d, cameraInfo.iMaxDigitalZoom: %d, cameraInfo.iMaxZoom: %d",
+ cameraInfo.iMinZoom, cameraInfo.iMaxDigitalZoom, cameraInfo.iMaxZoom ));
+
+ CX_DEBUG(("cameraInfo.iMaxDigitalZoomFactor: %d", cameraInfo.iMaxDigitalZoomFactor));
+
+ mMinZoomLevel = cameraInfo.iMinZoom;
+ if ( (mMaxZoomLevel == NOT_DEFINED) || mMaxZoomLevel > cameraInfo.iMaxDigitalZoom) {
+ CX_DEBUG(("Fetching maximum zoom limit value from ecam"));
+ mMaxZoomLevel = cameraInfo.iMaxDigitalZoom;
+ }
+ // change the state, since zoom is now ready
+ setState(Ready, KErrNone);
+
+ mCameraDevice.advancedSettings()->SetDigitalZoom(mDigitalZoomValues[mCurrentZoomLevel]);
+
+ // emit the zoom changed signal so that clients can do any updates if necessary.
+ emit zoomLevelChanged(mCurrentZoomLevel);
+ }
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+// ---------------------------------------------------------------------------
+// CxeZoomControlSymbian::zoomTo
+// Zooms to the level specified in the parameter.
+// ---------------------------------------------------------------------------
+//
+void CxeZoomControlSymbian::zoomTo(int value)
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ CX_DEBUG(("Zoom to: %d, current zoom: %d", value, mCurrentZoomLevel));
+
+ // If not currently zooming and value falls between min & max
+ // then zoom to the passed level. Also there's no need to zoom if new zoom
+ // level is same as the current.
+ if (state() == CxeZoomControl::Ready && (value <= mMaxZoomLevel)
+ && (value >= mMinZoomLevel) && (mCurrentZoomLevel != value)) {
+
+ // Set the appropriate zooming state
+ if (value < mCurrentZoomLevel) {
+ setState(CxeZoomControl::ZoomingOut);
+ } else {
+ setState(CxeZoomControl::ZoomingIn);
+ }
+
+ // Could also check the number of values in the array to avoid out of bounds indexing,
+ // though this is done in alternate way by the min and max limits.
+ mCameraDevice.advancedSettings()->SetDigitalZoom(mDigitalZoomValues[value]);
+ mCurrentZoomLevel = value;
+
+ //! @todo: Wait for zoom callback: ECamEventZoomStateChanged ?
+ // set the state to idle.
+ setState(CxeZoomControl::Ready);
+
+ // Emit the zoom level change signal
+ emit zoomLevelChanged(mCurrentZoomLevel);
+ }
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+CxeZoomControl::State CxeZoomControlSymbian::state() const
+{
+ return static_cast<State> (stateId());
+}
+
+void CxeZoomControlSymbian::handleStateChanged(int newStateId,
+ CxeError::Id error)
+{
+ emit stateChanged(static_cast<State> (newStateId), error);
+}
+
+void CxeZoomControlSymbian::initializeStates()
+{
+ // addState( id, name, allowed next states )
+ addState(new CxeState(Idle, "Idle", Ready));
+ addState(new CxeState(ZoomingIn, "ZoomingIn", Ready | ZoomingOut | Idle));
+ addState(new CxeState(ZoomingOut, "ZoomingOut", Ready | ZoomingIn | Idle));
+ addState(new CxeState(Ready, "Ready", Idle | ZoomingOut | ZoomingIn));
+
+ setInitialState(Idle);
+}