FCL/sf/os/mm: comparison imagingandcamerafws/camerafw/Include/ECam/ecamadvsettingsintf.h

equal deleted inserted replaced

--1:000000000000
+:40261b775718
+// Copyright (c) 2005-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:
+//
+/**
+@file
+@publishedPartner
+@released
+*/
+#ifndef  ECAMADVSETTINGSINTF_H
+#define  ECAMADVSETTINGSINTF_H
+#include <ecamadvsettings.h>
+#include <ecam/ecamimageprocessingintf.h>
+#include <ecam/ecamadvsettingsintfuids.hrh>
+/** This is the UID which is used to obtain the interface MCameraPresets, via the
+CCamera::CustomInterface() call, which provides implementation of the M-class interface.
+*/
+static const TUid KECamMCameraPresetsUid 			=  {KECamMCameraPresetsUidValue};
+/**
+This is the UID which is used to obtain the interface MCameraPresets2, via the
+CCamera::CustomInterface() call, which provides implementation of the M-class interface.
+@publishedPartner
+@prototype
+*/
+static const TUid KECamMCameraPresets2Uid 			=  {KECamMCameraPresets2UidValue};
+/** This is the UID which is used to obtain the interface MCameraAdvancedSettings, via the
+CCamera::CustomInterface() call, which provides implementation of the M-class interface. */
+static const TUid KECamMCameraAdvancedSettingsUid 	=  {KECamMCameraAdvancedSettingsUidValue};
+/** This is the UID which is used to obtain the interface MCameraAdvancedSettings2, via the
+CCamera::CustomInterface() call, which provides implementation of the M-class interface. */
+static const TUid KECamMCameraAdvancedSettings2Uid 	=  {KECamMCameraAdvancedSettings2UidValue};
+/**
+This is the UID which is used to obtain the interface MCameraAdvancedSettings3, via the
+CCamera::CustomInterface() call, which provides implementation of the M-class interface.
+*/
+static const TUid KECamMCameraAdvancedSettings3Uid 	=  {KECamMCameraAdvancedSettings3UidValue};
+/**
+This is the UID which is used to obtain the interface MCameraAdvancedSettings4, via the
+CCamera::CustomInterface() call, which provides implementation of the M-class interface.
+@publishedPartner
+@prototype
+*/
+static const TUid KECamMCameraAdvancedSettings4Uid 	=  {KECamMCameraAdvancedSettings4UidValue};
+/**
+This is the UID which is used to obtain the interface MCameraContinuousZoom, via the
+CCamera::CCameraAdvancedSettings::CreateContinuousZoomImpl() call, which provides
+implementation of the M-class interface.
+@internalTechnology
+@prototype
+*/
+static const TUid KECamMCameraContinuousZoomUid 	=  {KECamMCameraContinuousZoomUidValue};
+/**
+Mixin class for implementation by providers of the Advanced Settings Camera Extension API.
+CCamera advanced settings class exposes an API for controlling individually
+digital camera advanced settings. These settings directly relate to the
+image acquisition phase both for still images and video.
+@publishedPartner
+@released
+*/
+class MCameraAdvancedSettings
+	{
+public:
+	/**
+	Releases the interface.
+	*/
+	virtual void Release()=0;
+	/**
+	Gets the type of this camera.
+	@see TCameraType
+	@return a TCameraType value.
+	*/
+	virtual CCamera::CCameraAdvancedSettings::TCameraType CameraType() const=0;
+	/**
+	Get the type of a specific  camera denoted by its index. A pluggable camera
+	may not necessarily be physically present. The type denotes whether the slot allocated
+	to that index is for pluggable or onboard camera.
+@param aCameraIndex
+An integer in the range of [0: CCamera::CamerasAvailable()-1].
+	@return the TCameraType value for the specific camera.
+	        If the index is out of range, the return value is ECameraUnknown.
+	*/
+	virtual CCamera::CCameraAdvancedSettings::TCameraType CameraType(TInt aCameraIndex) const=0;
+	/**
+	Checks whether the current camera is present.
+	@return Whether the camera is currently present.
+			ETrue if camera is present, EFalse otherwise.
+			For example ECameraOnBoard (built-in) cameras are always present.
+	*/
+	virtual TBool IsCameraPresent() const=0;
+	/**
+	Checks whether the camera, denoted by its index, is currently present.
+	The index uniquely identifies the camera on the device.
+@param aCameraIndex
+An integer in the range of [0:CCamera::CamerasAvailable()-1] specifying the
+	       camera device to use
+	@return Whether the camera is currently present.
+			ETrue if camera is present, EFalse otherwise.
+			For example built-in (ECameraOnBoard) cameras
+			are always present.
+	*/
+	virtual TBool IsCameraPresent(TInt aCameraIndex) const=0;
+/**
+Gets current camera index. The index uniquely identifies the camera on the device.
+	@return camera index in the inclusive range of [0:CCamera::CamerasAvailable() - 1].
+*/
+	virtual TInt CameraIndex() const=0;
+/**
+	Gets all of the supported stabilization modes on the device. The result is a bitfield
+	of the valid TStabilizationMode flags.
+	@return a bitfield of all supported stabilization modes.
+	*/
+virtual TInt SupportedStabilizationModes() const=0;
+/**
+	Gets current stabilization mode on the device.
+	The result is a valid TStabilizationMode value.
+	@return current stabilization mode of type TStabilizationMode.
+	*/
+virtual CCamera::CCameraAdvancedSettings::TStabilizationMode StabilizationMode() const=0;
+/**
+	Sets a specific stabilization mode on the device.
+	Stabilization mode change fires a KUidECamEventCameraSettingStabilizationMode
+	event to all MCameraObserver2 clients of this specific camera.
+	@param aStabilizationMode
+	       new stabilization mode of TStabilizationMode type.
+	*/
+virtual void SetStabilizationMode(CCamera::CCameraAdvancedSettings::TStabilizationMode aStabilizationMode)=0;
+/**
+	Gets all of the supported focus modes on the device. The result is a bitfield
+	of the valid TFocusMode flags.
+	@return a bitfield of all supported focus modes.
+	*/
+virtual TInt SupportedFocusModes() const=0;
+/**
+	Gets current focus mode on the device.
+	The result is a valid TFocusMode value.
+	@return current focus mode.
+	*/
+virtual CCamera::CCameraAdvancedSettings::TFocusMode FocusMode() const=0;
+/**
+	Sets a specific focus mode on the device.
+	Focus mode change fires a KUidECamEventCameraSettingFocusMode event
+	to all MCameraObserver2 clients of the camera.
+	@param aFocusMode
+	       new focus mode of TFocusMode type.
+	*/
+virtual void SetFocusMode(CCamera::CCameraAdvancedSettings::TFocusMode aFocusMode)=0;
+	/**
+	Gets all supported focus ranges on the device.
+	@return an integer - a bitfield of all supported TFocusRange values.
+	*/
+virtual TInt SupportedFocusRanges() const=0;
+/**
+	Gets current focus range on the device.
+	@return the current TFocusRange value.
+	*/
+virtual CCamera::CCameraAdvancedSettings::TFocusRange FocusRange() const=0;
+/**
+	Sets a specific focus range on the device.
+	The focus range change fires both, KUidECamEventCameraSettingFocusRange and
+	KUidECamEventCameraSettingFocusRange2 event	to all MCameraObserver2 clients of the camera.
+	@see KUidECamEventCameraSettingFocusRange
+@param aFocusRange
+newly selected focus range.
+	*/
+virtual void SetFocusRange(CCamera::CCameraAdvancedSettings::TFocusRange aFocusRange)=0;
+/**
+	Gets all supported auto focus types on the device.
+	@return an integer - a bitfield of all supported TAutoFocusType values.
+	*/
+virtual TInt SupportedAutoFocusTypes() const=0;
+/**
+	Gets current auto focus type on the device.
+	@return a CCamera::TAutoFocusType value.
+	*/
+virtual CCamera::CCameraAdvancedSettings::TAutoFocusType AutoFocusType() const=0;
+/**
+	Sets a specific auto focus type on the device.
+	The focus type change fires both, KUidECamEventCameraSettingAutoFocusType and
+	KUidECamEventCameraSettingAutoFocusType2 event to all MCameraObserver2 clients of the camera.
+	@see KUidECamEventCameraSettingAutoFocusType
+	@param aAutoFocusType
+	       Autofocus selection.
+*/
+virtual void SetAutoFocusType(CCamera::CCameraAdvancedSettings::TAutoFocusType aAutoFocusType)=0;
+/**
+	Gets all supported auto focus areas on the device.
+	@return an integer - a bitfield of al supported TAutoFocusArea values.
+	*/
+virtual TInt SupportedAutoFocusAreas() const=0;
+/**
+	Gets current chosen auto focus area on the device.
+	@return a CCamera::TAutoFocusArea value.
+	*/
+virtual CCamera::CCameraAdvancedSettings::TAutoFocusArea AutoFocusArea() const=0;
+/**
+	Sets a specific auto focus area on the device.
+	Focus area change fires a KUidECamEventCameraSettingAutoFocusArea event
+	to all MCameraObserver2 clients of the camera.
+	@param aAutoFocusArea
+	       Autofocus area selection.
+*/
+virtual void SetAutoFocusArea(CCamera::CCameraAdvancedSettings::TAutoFocusArea aAutoFocusArea)=0;
+/**
+Get focus distance in millimetres.
+@return the current focus distance in millimetres, directly from user setting of lenses.
+*/
+	virtual TInt FocusDistance() const=0;
+	/**
+Set focus distance in millimetres. Focus distance change fires a KUidECamEventCameraSettingFocusDistance event
+to all MCameraObserver2 clients of the camera.
+@param aDistance
+		the current value in millimetres, directly from user setting of lenses.
+*/
+	virtual void SetFocusDistance(TInt aDistance)=0;
+	/**
+Get minimum focus distance in millimetres.
+@return the minimum (35 camera equivalent) focal length of a device.
+@note Current Focal length is calculated as
+		focalLength =  opticalZoom * minFocalLength;
+*/
+	virtual TInt GetMinFocalLength() const=0;
+	/**
+Gets the set of camera supported ISO rates.
+@param aSupportedIsoRates
+an array of integers which gets filled in with the supported ISO rates.
+@note  When camera device is incapable of revealing the ISO rates supported, it has to be assumed that
+		   camera will work only on the parmanently set value. If this value is not known, empty array should be
+		   returned, and the corresponding getter/setters for this feature for this feature should not be used.
+*/
+virtual void GetSupportedIsoRatesL(RArray<TInt>& aSupportedIsoRates) const=0;
+/**
+Gets current ISO rate.
+@return current ISO rate as a TInt value.
+@note  In case there is an error, a negative error value from system wide error should be returned.
+*/
+virtual TInt IsoRate() const=0;
+/**
+Set current ISO rate for the camera.
+Triggers a KUidECamEventCameraSettingIsoRate event to all MCameraObserver2 clients of the camera.
+@param aRate
+	   required new ISO rate.
+*/
+virtual void SetIsoRate(TInt aRate)=0;
+	/**
+	Gets the current discrete aperture steps (F-stops) supported by the device.
+	@param  aFStops
+	        A reference to an empty array of TInt which would be populated by the implementation with
+	        the specific supported values. If the array is empty on return,
+	        the camera supports all integer values in the aperture range. Each value is multiplied by
+	        a factor of KECamFineResolutionFactor.
+	@param  aInfo
+	        a reference to TValueInfo, which establishes the type of the returned data.
+	@leave KErrNoMemory Out of memory.
+	@note  When camera device is incapable of revealing the aperture openings supported, it has to be assumed that
+		   camera will work only on the parmanently set value. If this value is not known, empty array should be
+		   returned and TValueInfo should be ENotActive, and the corresponding getter/setters for this feature should not be used.
+	*/
+virtual void GetAperturesL(RArray<TInt>& aFStops, TValueInfo& aInfo) const=0;
+/**
+Get current aperture value.
+The default aperture value is ECAM implementation specific and could be either auto aperture or any other supported value.
+@return Current aperture value as an integer, multiplied by KECamFineResolutionFactor.
+	    For example the function will return 280 for the actual aperture of F2.8.
+@note  In case there is an error, a negative error value from system wide error should be returned.
+*/
+virtual TInt Aperture() const=0;
+/**
+Set a new aperture value.
+All MCameraObserver2 clients of the camera receive a KUidECamEventCameraSettingAperture
+event notification when aperture value is changed.
+@note The aperture parameter value is an integer, multiplied by KECamFineResolutionFactor.
+	  For example to set an aperture of F2.8, call SetAperture(280).
+@param aFStop
+	   a new aperture value in the supported by the device range.
+*/
+virtual void SetAperture(TInt aFStop)=0;
+	/**
+	Gets the set of supported shutter speeds
+	@param aShutterSpeeds
+			a reference to an RArray of TInt representing the discrete shutter speeds supported
+			currently by the device.
+	@param  aInfo
+			a reference to TValueInfo, which establishes the type of the returned data.
+	@return the populated array with all shutter speeds in microseconds.
+	@leave KErrNoMemory Out of memory.
+	@note  When camera device is incapable of revealing the shutter speeds supported, it has to be assumed that
+		   camera will work only on the parmanently set value. If this value is not known, empty array should be
+		   returned and TValueInfo should be ENotActive, and the corresponding getter/setters for this feature should not be used.
+	*/
+	virtual void GetShutterSpeedsL(RArray<TInt>& aShutterSpeeds, TValueInfo& aInfo) const=0;
+	/**
+	Gets the current shutter speed
+	@return the current shutter speed in microseconds.
+	@note  In case there is an error, a negative error value from system wide error should be returned.
+	*/
+virtual TInt ShutterSpeed() const=0;
+/**
+	Sets the current shutter speed. When set, all MCameraObserver2 clients of the camera
+	receive a KUidECamEventCameraSettingShutterSpeed event
+	@param aShutterSpeed
+	       the required shutter speed in microseconds.
+	*/
+virtual void SetShutterSpeed(TInt aShutterSpeed)=0;
+	/**
+	Get all supported metering modes on this device represented as bitfield of type TMeteringMode.
+	@return the set of supported metering modes.
+	*/
+virtual TInt SupportedMeteringModes() const=0;
+/**
+Get current metering mode.
+@return a value of type TMeteringMode.
+*/
+virtual CCamera::CCameraAdvancedSettings::TMeteringMode MeteringMode() const=0;
+/**
+Set the current metering mode. When set, all MCameraObserver2 clients are notified
+with a KUidECamEventCameraSettingMeteringMode event.
+@param aMeteringMode
+		a new selection for metering mode of type TMeteringMode.
+*/
+virtual void SetMeteringMode(CCamera::CCameraAdvancedSettings::TMeteringMode aMeteringMode)=0;
+/**
+Get all supported drive modes as bitfields of TDriveMode type.
+@return the set of supported drive modes.
+*/
+virtual TInt SupportedDriveModes() const=0;
+/**
+Gets currently active drive mode.
+@return current drive mode.
+*/
+virtual CCamera::CCameraAdvancedSettings::TDriveMode DriveMode() const=0;
+/**
+Set the current metering mode. When set all MCameraObserver2 clients are notified with a
+KUidECamEventCameraSettingDriveMode event.
+@param aDriveMode
+		new selection for drive mode value of type TDriveMode.
+@note  Unless reduced Latency scheme is not used (ie CaptureImageL(TInt aSequenceNumber) or PerformantStopVideoCaptureL())
+	   	   if an image/video capture is still outstanding, this method may report error KErrInUse.
+*/
+virtual void SetDriveMode(CCamera::CCameraAdvancedSettings::TDriveMode aDriveMode)=0;
+	/**
+	Get all supported bracket modes as bitfields.
+	@return the set of all supported bracket modes.
+	*/
+virtual TInt SupportedBracketModes() const=0;
+/**
+	Get current bracket mode.
+	@return the current bracket mode TBracketMode.
+	*/
+virtual CCamera::CCameraAdvancedSettings::TBracketMode BracketMode() const=0;
+/**
+Set new bracket mode. All MCameraObserver2 clients are notified with a
+KUidECamEventCameraSettingBracketMode event.
+@param aBracketMode
+		new selection for bracket mode of type TBracketMode.
+*/
+virtual void SetBracketMode(CCamera::CCameraAdvancedSettings::TBracketMode aBracketMode)=0;
+	/**
+	Get all supported bracket parameters as bitfields.
+	@return the set of all currently supported bracket modes.
+	*/
+virtual TInt SupportedBracketParameters() const=0;
+/**
+	Get current bracket parameter.
+	@return the current bracket mode TBracketParameter.
+	*/
+virtual CCamera::CCameraAdvancedSettings::TBracketParameter BracketParameter() const=0;
+/**
+Set new bracket parameter
+When set all clients are notified with a
+KUidECamEventCameraSettingBracketParameter event.
+@param aBracketParameter
+		new selection for parameter type of type TBracketParameter.
+*/
+virtual void SetBracketParameter(CCamera::CCameraAdvancedSettings::TBracketParameter aBracketParameter)=0;
+	/**
+	Get all supported bracket steps as bitfields.
+	@return the set of all supported bracket modes.
+	*/
+virtual TInt SupportedBracketSteps() const=0;
+/**
+	Get current bracket step.
+	@return the current bracket mode TBracketStep.
+	*/
+virtual CCamera::CCameraAdvancedSettings::TBracketStep BracketStep() const=0;
+/**
+Set new bracket step. All MCameraObserver2 clients are notified with
+KUidECamEventCameraSettingBracketStep.
+@param aBracketStep
+		new selection for step of type TBracketStep.
+*/
+virtual void SetBracketStep(CCamera::CCameraAdvancedSettings::TBracketStep aBracketStep)=0;
+/**
+	Gets the settings for which frames to merge. Valid only in EDriveModeBracketMerge mode.
+	@note there must be at least two images to merge. All are assumed to form a sequence and
+		are identified using the first frame index and number of frames e.g. to  merge two frames - one
+		on and one +1, when in EBracketMode3Image, one sets the start index to 1 and frames to two.
+	@note It is very much TBracketMode setting dependent.
+	@param  aStartIndex
+			the index of the start frame, starts from 0.
+	@param  aFrames
+			the number of frames to be merged.
+	*/
+	virtual void GetBracketMerge(TInt& aStartIndex, TInt& aFrames) const=0;
+	/**
+	Sets the settings for which frames to merge. Valid only in EDriveModeBracketMerge mode.
+	@note there must be at least two images to merge. All are assumed to form a sequence and
+		are identified using the first frame index and number of frames e.g. to  merge two frames - one
+		on and one +1, when in EBracketMode3Image, one sets the start index to 1 and frames to 2.
+		MCameraObserver2 clients are notified with a KUidECamEventBracketMerge event.
+	@note It is very TBracketMode setting dependent.
+	@param  aStartIndex
+			the index of the start frame, starts from 0.
+	@param  aFrames
+			the number of frames to be merged.
+	*/
+	virtual void SetBracketMerge(TInt aStartIndex, TInt aFrames)=0;
+/**
+Get camera all supported flash modes CCamera::TFlash
+@return the set of all supported flash modes as bitfields in an integer.
+*/
+virtual TInt SupportedFlashModes() const=0;
+/**
+	Gets the currently set flash mode.
+	@return  The currently set flash mode.
+	*/
+	virtual CCamera::TFlash FlashMode() const=0;
+/**
+	Sets the flash mode.
+Triggers a KUidECamEventCameraSettingFlashMode event to all camera
+MCameraObserver2 clients.
+	@param  aMode
+	        The required flash mode.
+	*/
+	virtual void SetFlashMode(CCamera::TFlash aMode)=0;
+/**
+	Gets whether the flash red eye reduction is switched on.
+	@return The present state - ETrue for switched on and EFalse for switched off.
+	*/
+virtual TBool RedEyeReduceOn() const=0;
+/**
+	Sets the flash red eye reduction on or off.
+Triggers a KUidECamEventCameraSettingFlashRedEyeReduce event to all camera
+MCameraObserver2 clients.
+	@param  aState
+	        The required state ETrue for switching it on and EFalse for switching it off.
+	*/
+virtual void SetRedEyeReduceOn(TBool aState)=0;
+	/**
+	Get flash compensation steps as integers multiplied by KECamFineResolutionFactor.
+	For example 0.5 EV is 50.
+	@param aFlashCompensationSteps
+	       an RArray of integers which is populated on return to reflect the supported
+	       flash compensation steps.
+	@param aInfo
+	       an TValueInfo reference, which establishes the organization of the returned data.
+	@see TValueInfo
+	@leave KErrNoMemory Out of memory.
+	@note  When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive,
+		   and the corresponding getter/setters for this feature should not be used.
+		   When camera device is incapable of revealing the flash compensation steps supported,
+		   it has to be assumed that camera will work only on the parmanently set value. If this value is not known, empty
+		   array should be returned and TValueInfo should be ENotActive, and the corresponding getter/setters for this feature should not be used.
+	*/
+	virtual void GetFlashCompensationStepsL(RArray<TInt>& aFlashCompensationSteps, TValueInfo& aInfo) const=0;
+	/**
+	@deprecated Use TInt GetFlashCompensationStep(TInt& aFlashCompensationStep);
+	Get current flash power compensation step.
+	@return current flash compensation step.
+	*/
+	virtual TInt FlashCompensationStep() const=0;
+	/**
+	Get current flash power compensation step.
+	@param aFlashCompensationStep
+		   Reference to the current flash power compensation step.
+	@return system wide error code.
+	*/
+	virtual TInt GetFlashCompensationStep(TInt& aFlashCompensationStep) const=0;
+/**
+	Set current flash compensation step as an integer multiplied by KECamFineResolutionFactor.
+	For example to set a compensation of -0.3 EV, one should use a parameter with value -30.
+	All clients receive a KUidECamEventCameraSettingFlashCompensationStep event, when the value has changed.
+	@param aFlashCompensationStep
+	       a new value for the flash compensation step.
+	*/
+	virtual void SetFlashCompensationStep(TInt aFlashCompensationStep)=0;
+	/**
+	Get current flash power compensation range measured in a already selected compensation step.
+	@note This range may change if a different compensation step is selected.
+	For example if flash compensation range is in the range -1EV 1.5EV and the selected flash compensation
+	step is selected to be 0.3 EV, the result of this call will be
+	aNegativeCompensation = -3 and aPositiveCompensation = 5.
+	as there can be only three full steps for negative compensation (1/0.3) and five for flash power boost (1.5/0.3).
+In this way developers, having pre-selected a step value from the supported set, would need to provide
+just the multplier (in steps) and the direction (the sign). Steps are always assumed integers.
+	@param  aNegativeCompensation
+	        reference to an integer returning the maximum number of steps available for negative compensation.
+	@param aPositiveCompensation
+	        reference to an integer returning the maximum number of steps available for positive compensation.
+	*/
+	virtual void GetFlashCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const=0;
+	/**
+	@deprecated Use TInt GetFlashCompensation(TInt& aFlashCompensation);
+	Get the current flash compensation value as integer steps. Positive values boost flash power,
+	negative reduce flash power. The change is not cumulative i.e. the change is stateless.
+	Each call assumes no previous compensation has been performed i.e. that there is a zero compensation.
+	@note if returned value is 2 (compensation steps) and the current flash compensation step is 0.3 EV,
+	then the actual compensation effect will be 0.6 EV.
+	@return  the current number compensation steps as an integer.
+	*/
+	virtual TInt FlashCompensation() const=0;
+	/**
+	Get the current flash compensation value as integer steps. Positive values boost flash power,
+	negative reduce flash power. The change is not cumulative i.e. the change is stateless.
+	Each call assumes no previous compensation has been performed i.e. that there is a zero compensation.
+	@note if retrieved value is 2 (compensation steps) and the current flash compensation step is 0.3 EV,
+	then the actual compensation effect will be 0.6 EV.
+	@param   aFlashCompensation
+			 Reference to the current number of compensation steps as an integer.
+	@return  system wide error code.
+	*/
+	virtual TInt GetFlashCompensation(TInt& aFlashCompensation) const=0;
+	/**
+	Set the current flash compensation value as integer steps.
+	Positive values increase power, negative reduce power. The change is not cumulative i.e. the change is stateless.
+	Each call assumes no previous compensation has been performed i.e. that there is a zero compensation.
+	Triggers a KUidECamEventCameraSettingFlashCompensation event.
+	@param 	aFlashCompensationSteps
+	        a required compensation steps - negative value reduce the flash power
+	        positive boosts up the flash power.
+	*/
+	virtual void SetFlashCompensation(TInt aFlashCompensationSteps)=0;
+	/**
+	Check whether there is an external flash source.
+	@return ETrue if an external flash source is present, EFalse otherwise
+	*/
+	virtual TBool IsExternalFlashPresent() const=0;
+	/**
+	Gets the current discrete manual flash power levels supported by the device in range 0-100
+	as a percentage of maximum power level.
+	@param  aManualFlashPowerLevels
+	        An empty array of TInt which would be populated by the implementation with
+	        the specific supported values. If the array is empty on return,
+	        the camera does not support this functionality.
+	@param  aInfo
+	        a reference to TValueInfo, which establishes the type of the returned data.
+	@leave KErrNoMemory Out of memory.
+	@note  When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive,
+		   and the corresponding getter/setters for this feature should not be used.
+		   When camera device is incapable of revealing the manual flash power levels supported,
+		   it has to be assumed that camera will work only on the parmanently set value. If this value is not known, empty
+		   array should be returned and TValueInfo should be ENotActive, and the corresponding getter/setters for this feature should not be used.
+	*/
+virtual void GetManualFlashPowerLevelsL(RArray<TInt>& aManualFlashPowerLevels, TValueInfo& aInfo) const=0;
+/**
+Gets the current manual flash power level on the device.
+	@return the current manual flash power level as a value in the range [0:100].
+	@note  In case there is an error, a negative error value from system wide error should be returned.
+	*/
+virtual TInt ManualFlashPowerLevel() const=0;
+/**
+Sets the current manual flash power level on the device.
+Triggers a KUidECamEventCameraSettingFlashManualPower event to all MCameraObserver2 clients.
+	@param  aManualFlashPowerLevel
+	        one of the values returned in GetManualFlashPowerLevelsL().
+	*/
+virtual void SetManualFlashPowerLevel(TInt aManualFlashPowerLevel)=0;
+	/**
+	Get Supported exposure modes - bitfields of CCamera::TExposure
+	@return the set of supported exposure modes.
+	*/
+	virtual TInt SupportedExposureModes() const=0;
+	/**
+	Gets the currently set exposure setting value.
+	@return  The currently set exposure setting value.
+	*/
+	virtual CCamera::TExposure ExposureMode() const=0;
+	/**
+	Sets the exposure mode of the device.
+	Triggers a KUidECamEventCameraSettingExposureMode event to all MCameraObserver2 clients.
+	@param  aExposureMode
+	        The required exposure adjustment.
+	*/
+	virtual void SetExposureMode(CCamera::TExposure aExposureMode)=0;
+	/**
+	Get exposure compensation steps as integers multiplied by KECamFineResolutionFactor.
+	For example 0.3 EV is 30.
+	@param aExposureCompensationSteps
+	       an RArray of integers which is populated to reflect the supported
+	       exposure compensation steps, all values have been multiplied by KECamFineResolutionFactor before
+	       truncated to integers.
+	@param aInfo
+		   a reference to TValueInfo, which establishes the type of the returned data.
+	@leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+	@note  When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive,
+		   and the corresponding getter/setters for this feature should not be used.
+		   When camera device is incapable of revealing the exposure compensation steps supported,
+		   it has to be assumed that camera will work only on the parmanently set value. If this value is not known, empty
+		   array should be returned and TValueInfo should be ENotActive, and the corresponding getter/setters for this feature should not be used.
+	*/
+	virtual void GetExposureCompensationStepsL(RArray<TInt>& aExposureCompensationSteps, TValueInfo& aInfo) const=0;
+	/**
+	@deprecated Use TInt GetExposureCompensationStep(TInt& aExposureCompensationStep);
+	Get current exposure compensation step.
+	@return current exposure compensation step.
+	*/
+	virtual TInt ExposureCompensationStep() const=0;
+	/**
+	Get current exposure compensation step.
+	@param aExposureCompensationStep
+		   Reference to the current exposure compensation step.
+	@return system wide error code.
+	*/
+	virtual TInt GetExposureCompensationStep(TInt& aExposureCompensationStep) const=0;
+	/**
+	Set current exposure compensation step as an integer multiplied by KECamFineResolutionFactor.
+	All MCameraObserver2 clients receive a KUidECamEventCameraSettingExposureCompensationStep event,
+	when the value has changed.
+	@param aExposureCompensationStep
+	       a new value for the exposure compensation step.
+	*/
+	virtual void SetExposureCompensationStep(TInt aExposureCompensationStep)=0;
+	/**
+	Get current exposure compensation range in steps. It depends on the previously
+	selected exposure compensation step.
+	@param  aNegativeCompensation
+	        reference to an integer returning the maximum number of steps
+	        available for negative compensation.
+	@param aPositiveCompensation
+	        reference to an integer returning the maximum number of steps
+	        available for positive compensation.
+	@see GetFlashCompensationRangeInSteps()
+	*/
+	virtual void GetExposureCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const=0;
+	/**
+	@deprecated Use TInt GetExposureCompensation(TInt& aExposureCompensation);
+	Get the current exposure compensation value as integer steps. Positive values increase exposure times,
+	negative reduce exposure times. The change is not cumulative i.e. the change is stateless.
+	Each call assumes no previous compensation has been performed i.e. that there is a zero compensation.
+	@note if returned value is 2 (compensation steps) and the current exposure compensation step is 0.3 EV,
+	then the actual compensation effect will be 0.6 EV.
+	@return  current number compensation steps as an integer.
+	*/
+	virtual TInt ExposureCompensation() const=0;
+	/**
+	Get the current exposure compensation value as integer steps. Positive values increase exposure times,
+	negative reduce exposure times. The change is not cumulative i.e. the change is stateless.
+	Each call assumes no previous compensation has been performed i.e. that there is a zero compensation.
+	@note if retrieved value is 2 (compensation steps) and the current exposure compensation step is 0.3 EV,
+	then the actual compensation effect will be 0.6 EV.
+	@param aExposureCompensation
+		   Reference to the current number of compensation steps as an integer.
+	@return  system wide error code.
+	*/
+	virtual TInt GetExposureCompensation(TInt& aExposureCompensation) const=0;
+	/**
+	Set the current exposure compensation value as integer steps.
+	Triggers a KUidECamEventCameraSettingExposureCompensation event to all MCameraObserver2 clients.
+	@param 	aExposureCompensationSteps
+	        a required compensation value negative value reduce the exposure time
+	        positive increases the exposure time.
+	*/
+	virtual void SetExposureCompensation(TInt aExposureCompensationSteps)=0;
+/**
+Gets camera supported set of white balance adjustments.
+@return bitfield of all supported CCamera::TWhiteBalance values.
+*/
+	virtual TInt SupportedWhiteBalanceModes() const=0;
+	/**
+	Gets the current white balance value.
+	@return  The current white balance value.
+	*/
+	virtual CCamera::TWhiteBalance WhiteBalanceMode() const=0;
+	/**
+	Sets the white balance adjustment of the device.
+	No effect if this is not supported, see TCameraInfo::iWhiteBalanceModesSupported.
+	Triggers a KUidECamEventCameraSettingWhiteBalanceMode event to all MCameraObserver2 clients.
+	@param  aWhiteBalanceMode
+	        The required white balance mode.
+	*/
+	virtual void SetWhiteBalanceMode(CCamera::TWhiteBalance aWhiteBalanceMode)=0;
+/**
+Gets the current state for aperture and exposure lock.
+@return ETrue if aperture and exposure values are locked together,
+EFalse if these are not locked.
+*/
+	virtual TBool ApertureExposureLockOn() const=0;
+	/**
+Sets the current state for aperture and exposure lock.
+Triggers a KUidECamEventAELock event to all MCameraObserver2 clients.
+@param aAELock
+a value whether to lock exposure and aperture together.
+*/
+	virtual void SetApertureExposureLockOn(TBool aAELock)=0;
+	/**
+	Gets the current state for button clicking sound effect.
+	@return  boolean, ETrue to switch clicking sound on, EFalse sound off
+	*/
+	virtual TBool ShootClickOn() const=0;
+	/**
+	Sets the button clicking sound effect on /off. Triggers a KUidECamEventSoundClick event
+	to all MCameraObserver2 clients.
+	@param aShootClickOn
+	       boolean, ETrue to switch clicking sound on, EFalse sound is switched off.
+	*/
+	virtual void SetShootClickOn(TBool aShootClickOn)=0;
+	/**
+	Get camera supported timer values. Active only when drive mode EDriveModeTimed.
+	Time is in microseconds. As time interval is expected to be relatively short,
+	integer value is considered sufficient.
+	@param aTimerIntervals
+	       an RArray of integers which is populated to reflect the supported
+	       timer interval steps.
+	@param aInfo
+	       an TValueInfo reference, which establishes the organization of
+		   the returned data.
+	@see TValueInfo
+	@note  When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive,
+		   and the corresponding getter/setters for this feature should not be used.
+	*/
+	virtual void GetTimerIntervalsL(RArray<TInt>& aTimerIntervals, TValueInfo& aInfo) const=0;
+	/**
+	Get current timer value. Active only when drive mode is EDriveModeTimed.
+	Timer resolution is in microseconds.
+	@return current time interval value.
+	@note  In case there is an error, a negative error value from system wide error should be returned.
+	*/
+virtual TInt TimerInterval() const=0;
+/**
+	Set current timer value. Active only when drive mode EDriveModeTimed.
+	This is the time interval (delay) in microseconds between user pressing the button and image is taken.
+	The setting of the value triggers a KUidECamEventCameraSettingTimerInterval event
+	to all MCameraObserver2 clients.
+	@param aTimerInterval
+	       The selected timer interval in microseconds
+	*/
+virtual void SetTimerInterval(TInt aTimerInterval)=0;
+	/**
+	Get camera supported time lapse period range. Active only when drive mode EDriveModeTimeLapse.
+	The time lapse is denoted as the uniform time period between consecutive frames.
+	@param aTimeLapseMin
+	       The minimum time value.
+	@param aTimeLapseMax
+	       The maximum time value.
+	*/
+	virtual void GetTimeLapsePeriodRange(TTime& aTimeLapseMin, TTime& aTimeLapseMax) const=0;
+	/**
+	Get current time lapse value. Active only when drive mode EDriveModeTimeLapse.
+	The time lapse is denoted as the uniform time period
+	between consecutive frames and operation is configurable by its start, end and a fixed interval.
+	@param aStart
+			the start of the  timelapse period
+	@param aEnd
+			the end of the  timelapse period; start < end.
+	@param aInterval
+			the set parameter between two successive snapshots.
+	*/
+virtual void GetTimeLapse(TTime& aStart, TTime& aEnd, TTime& aInterval) const=0;
+/**
+	Set current time lapse value. Active only when drive mode EDriveModeTimeLapse.
+	The time lapse is denoted as the uniform time period between consecutive frames.
+	Setting triggers a KUidECamEventCameraSettingTimeLapse event to all MCameraObserver2 camera clients.
+	@param aStart
+			the start of the timelapse period.
+	@param aEnd
+			the end of the timelapse period; start < end.
+	@param aInterval
+			the set parameter between two successive snapshots.
+	*/
+virtual void SetTimeLapse(const TTime& aStart, const TTime& aEnd, const TTime& aInterval)=0;
+	/**
+	Get current picture orientation.
+	@return a TPictureOrientation value.
+	*/
+virtual CCamera::CCameraAdvancedSettings::TPictureOrientation PictureOrientation() const=0;
+/**
+Set a new picture orientation
+This triggers a KUidECamEventCameraSettingPictureOrientation event to all MCameraObserver2 clients.
+@param aOrientation
+a value of TPictureOrientation denoting the new orientation.
+*/
+virtual void SetPictureOrientation(CCamera::CCameraAdvancedSettings::TPictureOrientation aOrientation)=0;
+/**
+	Get supported pixel aspect ratio.
+	@return a bitfield of all supported TPixelAspectRatio values.
+	*/
+virtual TInt SupportedPixelAspectRatios() const=0;
+	/**
+	Get current pixel aspect ratio.
+	@return a TPixelAspectRatio value.
+	*/
+virtual CCamera::CCameraAdvancedSettings::TPixelAspectRatio PixelAspectRatio() const=0;
+/**
+Set a new pixel aspect ratio.
+This triggers a KUidECamEventPixelAspectRatio event to all MCameraObserver2 clients.
+@param aPixelAspectRatio
+a value of TPixelAspectRatio denoting the new pixel aspect ratio.
+*/
+virtual void SetPixelAspectRatio(CCamera::CCameraAdvancedSettings::TPixelAspectRatio aPixelAspectRatio)=0;
+	/**
+	Get supported YUV ranges.
+	@return a bitfileld of all supported TYuvRange values.
+	*/
+virtual TInt SupportedYuvRanges() const=0;
+	/**
+	Get the current YUV range.
+	@return a TYuvRange value.
+	*/
+virtual CCamera::CCameraAdvancedSettings::TYuvRange YuvRange() const=0;
+/**
+Set a new YUV range.
+This triggers a KUidECamEventYuvRange event to all MCameraObserver2 clients.
+@param aYuvRange
+a value of TYuvRange denoting the new YUV range.
+*/
+virtual void SetYuvRange(CCamera::CCameraAdvancedSettings::TYuvRange aYuvRange)=0;
+	/**
+	Get the number of images captured normally under EDriveModeBurst condition.
+	@note: due to memory or image size limitations the actual number may be less.
+	@return the number of images set to capture in burst mode.
+	*/
+virtual TInt BurstImages() const=0;
+/**
+Set the number of images captured normally under EDriveModeBurst condition.
+Triggers a KUidECamEventBurstImages event to all MCameraObserver2 clients.
+	@note: due to memory or image size limitations the actual number may be less.
+	@param aImages
+		   the number of images set to capture in burst mode.
+	@note  Unless reduced Latency scheme is not used (ie CaptureImageL(TInt aSequenceNumber) or PerformantStopVideoCaptureL())
+	   	   if an image/video capture is still outstanding, this method may report error KErrInUse.
+*/
+virtual void SetBurstImages(TInt aImages)=0;
+/**
+	Gets the optical zoom levels.
+	@param  aOpticalZoomSteps
+	        Array to hold optical zoom values multiplied by KECamFineResolutionFactor to retain precision.
+	        So that if zoom is not supported the array will return a single element of value
+	        KECamFineResolutionFactor.
+	@param  aInfo
+			a reference to TValueInfo, which establishes the type of the returned data.
+	@note   Such approach allows for support for both linear and non-linear zoom steps.
+			When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive,
+			and the corresponding getter/setters for this feature should not be used.
+	@leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+	*/
+	virtual void GetOpticalZoomStepsL(RArray<TInt>& aOpticalZoomSteps, TValueInfo& aInfo) const=0;
+	/**
+	Gets the currently set zoom value.
+	@return  The currently set optical zoom value. The value is multiplied by
+			 KECamFineResolutionFactor to retain precision.
+	@note  In case there is an error, a negative error value from system wide error should be returned.
+	*/
+	virtual TInt OpticalZoom() const=0;
+	/**
+	Sets the zoom using a specific value. Triggers a KUidECamEventCameraSettingOpticalZoom
+	event to all MCameraObserver2 clients.
+	@param aOpticalZoom
+	       Required zoom value.
+	*/
+	virtual void SetOpticalZoom(TInt aOpticalZoom)=0;
+	/**
+	Gets the digital zoom levels.
+	@param  aDigitalZoomSteps
+	        Array to hold digital zoom values multiplied by KECamFineResolutionFactor to retain precision.
+	        So that if zoom is not supported the array will return a single element of value
+	        KECamFineResolutionFactor.
+	@param  aInfo
+			a reference to TValueInfo, which establishes the type of the returned data.
+	@note   Such approach allows for support for both linear and non-linear zoom steps.
+			When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive
+			and the corresponding getter/setters for this feature should not be used.
+	@leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+	*/
+	virtual void GetDigitalZoomStepsL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo) const=0;
+	/**
+	Gets the currently set digital zoom value.
+	@return  The currently set digital zoom value. The value is multiplied by
+			 KECamFineResolutionFactor to retain precision.
+	@note  In case there is an error, a negative error value from system wide error should be returned.
+	*/
+	virtual TInt DigitalZoom() const=0;
+	/**
+	Sets the digital zoom value. Triggers a KUidECamEventCameraSettingDigitalZoom event
+	 to all MCameraObserver2 clients.
+	@param aDigitalZoom
+	       Required zoom value.
+	*/
+	virtual void SetDigitalZoom(TInt aDigitalZoom)=0;
+	/**
+	Checks whether exposure value is locked or not.
+	@return whether exposure value is locked or not.
+			ETrue if locked, EFalse otherwise.
+	*/
+	virtual TBool ExposureLockOn() const=0;
+	/**
+	Sets exposure lock state. Triggers a KUidECamEventCameraSettingExposureLock event
+	 to all MCameraObserver2 clients.
+	@param aState
+	       Required new state.
+	*/
+	virtual void SetExposureLockOn(TBool aState)=0;
+	/**
+	Checks whether AutoFocus value is locked or not.
+	@return whether AutoFocus value is locked or not.
+			ETrue if locked, EFalse otherwise.
+	*/
+	virtual TBool AutoFocusLockOn() const=0;
+	/**
+	Sets autofocus lock state. Triggers a KUidECamEventCameraSettingAutoFocusLock event
+	to all MCameraObserver2 clients.
+	@param aState
+	       Required new state.
+	*/
+	virtual void SetAutoFocusLockOn(TBool aState)=0;
+	/**
+	Gets an array of all the advanced settings parameters supported by the device.
+	These are identified by UIDs and relate to the set or subset of it of all defined settings UIDs.
+	@param  aSettings
+	        An empty array of TUids which would be populated by the implementation with
+	        the UIDs of the supported parameters. If the array is empty on return,
+	        the camera does not support any settings.
+	@leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+	*/
+virtual void GetSupportedSettingsL(RArray<TUid>& aSettings) const=0;
+/**
+	Gets an array of all the advanced settings parameters currently active on the device.
+	These are identified by UIDs and relate to the set or subset of it of all supported
+	settings UIDs.
+	@param  aActiveSettings
+	        An empty array of TUids which would be populated by the implementation with
+	        the active setting UIDs. If the array is empty on return,
+	        the camera does not support any settings.
+	@leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+	*/
+virtual void GetActiveSettingsL(RArray<TUid>& aActiveSettings) const=0;
+/**
+	Gets an array of all the advanced settings parameters currently disabled on the device.
+	These are identified by UIDs and relate to the set or subset of it of all supported
+	settings UIDs.
+	@param  aDisabledSettings
+	        An empty array of TUids which would be populated by the implementation with
+	        the disabled setting UIDs. If the array is empty on return,
+	        the camera does not support any settings.
+	@leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+	*/
+virtual void GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const=0;
+	/**
+	Retrieves the state for automatic size selection option. Default value is EFalse.
+	@return ETrue if the automatic selection is switched on. Default value is EFalse.
+	*/
+	virtual TBool AutomaticSizeSelectionChangeOn() const=0;
+	/**
+	Allow camera to proactively change image size due external factors.
+	Default value is EFalse. Triggers a KUidECamEventCameraSettingAutomaticSizeSelection event notification.
+	@param aSetOn
+	       whether the option should be switched on
+	 */
+	virtual void SetAutomaticSizeSelectionChangeOn(TBool aSetOn)=0;
+/**
+Retrieves the timeout values camera supported by the camera when in continuous auto focus mode.
+Timeouts are in microseconds.
+	@param  aTimeouts
+	        An empty array to hold timeout values.
+	@param  aInfo
+			a reference to TValueInfo, which establishes the type of the returned data.
+	@leave  KErrNoMemory Out of memory. May also leave as a result of other system errors.
+	@note   When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive
+			and the corresponding getter/setters for this feature should not be used.
+*/
+virtual void GetSupportedContinuousAutoFocusTimeoutsL(RArray<TInt>& aTimeouts, TValueInfo& aInfo) const=0;
+/**
+Gets the current value for continuous autofocus timeout. Timeouts are in microseconds.
+@return  the timeout value in microseconds.
+@note  In case there is an error, a negative error value from system wide error should be returned.
+*/
+virtual TInt ContinuousAutoFocusTimeout() const=0;
+/**
+Sets new value for continuous autofocus timeout. Timeouts are in microseconds.
+All MCameraObserver2 clients of the camera receive a
+KUidECamEventCameraSettingsContinuousAutoFocusTimeout
+event notification when timeout value is changed.
+@param  aTimeout
+	        a new timeout value in microseconds.
+*/
+virtual void SetContinuousAutoFocusTimeout(TInt aTimeout)=0;
+/**
+Gets all supported stabilization effects on the device.
+@return an integer - a bitfield of all supported TStabilizationEffect values.
+*/
+	virtual TInt SupportedStabilizationEffects() const=0;
+/**
+Gets current active stabilization effect on the device.
+@return a TStabilizationEffect value.
+*/
+	virtual CCamera::CCameraAdvancedSettings::TStabilizationEffect StabilizationEffect() const=0;
+/**
+Sets a specific stabilization effect on the device.
+When a value is set, MCameraObserver2 clients for that camera will receive a
+KUidECamEventCameraSettingsStabilizationEffect event notification.
+@param aEffect
+stabilization effect selection of type TStabilizationEffect.
+*/
+virtual void SetStabilizationEffect(CCamera::CCameraAdvancedSettings::TStabilizationEffect aEffect)=0;
+/**
+Gets all supported stabilization algorithm values on the device.
+@return an integer - a bitfield of all supported TStabilizationAlgorithmComplexity values.
+*/
+	virtual TInt SupportedStabilizationComplexityValues() const=0;
+/**
+Gets current active stabilization algorithm selection on the device.
+@return a TStabilizationAlgorithmComplexity value.
+*/
+	virtual CCamera::CCameraAdvancedSettings::TStabilizationAlgorithmComplexity StabilizationComplexity() const=0;
+/**
+Sets a specific stabilization algorithm on the device.
+When a value is set, MCameraObserver2 clients for that camera will receive a
+KUidECamEventSettingsStabilizationAlgorithmComplexity event notification.
+@param aComplexity
+stabilization effect selection of type TStabilizationAlgorithmComplexity.
+*/
+	virtual void SetStabilizationComplexity(CCamera::CCameraAdvancedSettings::TStabilizationAlgorithmComplexity aComplexity)=0;
+/**
+Gets the units in which the white balance is measured on the device. The methods used to get
+or set these differ depending on the supported unit type.
+It is expected that a device will support only a single type or none.
+@return a value of TWBUnits type.
+*/
+virtual CCamera::CCameraAdvancedSettings::TWBUnits SupportedWBUnits() const=0;
+/**
+Get white balance value represented as a RGB triplet (TRgb)
+@param aValue
+	   a reference to TRgb object which will contain the current white balance.
+*/
+	virtual void GetWBRgbValue(TRgb& aValue) const=0;
+/**
+Set white balance value using a RGB triplet (TRgb).
+Change in value causes an event notification KUidECamEventCameraSettingsWBValue
+to be sent to all MCameraObserver2 clients of this camera.
+@param aValue
+	   a const reference to TRgb object, which contains the new white balance.
+*/
+virtual void SetWBRgbValue(const TRgb& aValue)=0;
+/**
+Get the white balance values, as temperature measured in Kelvin, supported on the device.
+	@param  aWBColorTemperatures
+	A reference to an empty array of TInt which would be populated by the implementation with
+	the specific supported values.
+	@param  aInfo
+	        a reference to TValueInfo, which establishes the type of the returned data.
+	@note   When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive,
+			and the corresponding getter/setters for this feature should not be used.
+*/
+	virtual void GetWBSupportedColorTemperaturesL(RArray<TInt>& aWBColorTemperatures, TValueInfo& aInfo) const=0;
+/**
+Get the white balance as a temperature in Kelvin.
+@return current white balance value as a temperature in Kelvins.
+@note  In case there is an error, a negative error value from system wide error should be returned.
+*/
+	virtual TInt WBColorTemperature() const=0;
+	/**
+Set white balance value using a temperature, measured in Kelvin.
+Change in value causes an event notification KUidECamEventCameraSettingsWBValue
+to be sent to all MCameraObserver2 clients of this camera.
+@param aWBColorTemperature
+	   the new white balance value in Kelvin.
+*/
+	virtual void SetWBColorTemperature(TInt aWBColorTemperature)=0;
+	};
+/**
+Mixin class for implementation by providers of some enhanced functionalities of the
+Advanced Settings Camera Extension API.
+@publishedPartner
+@released
+*/
+class MCameraAdvancedSettings2
+	{
+public:
+	/**
+	Releases the interface.
+	*/
+	virtual void Release()=0;
+	/**
+	Checks whether the flash is ready.
+@param 	aReady
+		A reference to a boolean set by the implementation to ETrue if the flash is ready,
+		EFalse otherwise.
+	@return KErrNotSupported if the implementation of this method is not supported.
+	*/
+	virtual TInt IsFlashReady(TBool& aReady) const=0;
+	/**
+Get the number of focus steps for current focus mode.
+	@param  aFocusModeSteps
+	A reference to an empty array of TInt which would be populated by the implementation with
+	the specific supported values.
+	@param  aInfo
+	        a reference to TValueInfo, which establishes the type of the returned data.
+	@leave  KErrNotSupported if the implementation of this method is not supported. May also leave as a result of other system errors.
+@note   When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive,
+and the corresponding getter/setters for this feature should not be used.
+*/
+	virtual void GetCurrentFocusModeStepsL(RArray<TInt>& aFocusModeSteps, TValueInfo& aInfo) const=0;
+	};
+/**
+Mixin class for implementation by providers of 'some of the enhanced functionalities' of the
+Advanced Settings Camera Extension API.
+@publishedPartner
+@released
+*/
+class MCameraAdvancedSettings3
+	{
+public:
+	/**
+	Releases the interface.
+	*/
+	virtual void Release()=0;
+	/**
+	Gets all supported ISO types on the device.
+	@param  aSupportedISORateTypes
+			A reference to an integer which is a bitfield of all supported TISORateType values.
+			EISONone means feature is not supported.
+	@leave  May leave as a result of some error.
+	*/
+	virtual void GetSupportedISORateTypeL(TInt& aSupportedISORateTypes) const=0;
+	/**
+	Set the type of ISO rate and the exposure parameter or value specified.
+	@param 	aISORateType
+			The type of ISO rate to be set.
+	@param  aParam
+			Depending on the value of aISORateType, possible values of aParam are one of the following:-
+			The value of ISO rate to be used in case of manual type of ISO rate (EISOManual).
+			OR
+			Redundant parameter in case of unprioritised type of auto ISO (EISOAutoUnPrioritised). It is left to the camera hardware/firmware
+			to decide how the ISO rate is selected. No priority regarding exposure is specified.
+			OR
+			Highest ISO rate to be picked by the camera while deciding for the best exposure in case of ISO prioritised
+			type of auto ISO (EISOAutoISOPrioritised). ISO rate closest to this (and lower) may be used so that best possible exposure is achieved.
+			OR
+			Slowest shutter speed to be picked by the camera while deciding for the best exposure in case of shutter speed
+			prioritised type of auto ISO (EISOAutoShutterSpeedPrioritised). After using this shutter speed, ISO rate is chosen by the camera to achieve
+			proper exposure. Shutter speed closest to this (and faster) may be used so that best possible exposure is achieved.
+			OR
+			Minimum aperture opening (deepest depth of field) to be picked by the camera while deciding
+			for the best exposure in case of aperture prioritised type of auto ISO (EISOAutoAperturePrioritised). After using this aperture opening, ISO
+			rate is chosen by the camera to achieve proper exposure. Aperture opening closest to this (and wider) may be
+			used to achieve best possible exposure.
+	@note   Triggers KUidECamEventCameraSettingIsoRateType to all MCameraObserver2 clients of the camera.
+			Uses HandleEvent to report the result or any possible error.
+	*/
+	virtual void SetISORate(CCamera::CCameraAdvancedSettings::TISORateType aISORateType, TInt aParam)=0;
+	/**
+	Get the type of ISO rate, exposure parameter and value set.
+	@param 	aISORateType
+			A reference to the type of ISO rate set. EISONone means feature is not supported.
+	@param  aParam
+			Depending on the value of aISORateType, possible values of aParam are one of the following:-
+			A reference to the redundant parameter in case of manual type of ISO rate(EISOManual)
+			OR
+			A reference to the redundant parameter in case of unprioritised type of auto ISO(EISOAutoUnPrioritised)
+			OR
+		A reference to the highest ISO rate that may be picked up in case of ISO prioritised type of auto ISO(EISOAutoISOPrioritised)
+		OR
+			A reference to the slowest shutter speed that may be picked up in case of shutter speed prioritised type of auto ISO(EISOAutoShutterSpeedPrioritised)
+			OR
+			A reference to the minimum aperture opening that may be picked up in case of aperture prioritised type of auto ISO(EISOAutoAperturePrioritised)
+	@param  aISORate
+			A reference to the value of ISO rate currently being used, if camera device is capable of doing that.
+			Otherwise KErrNotFound should be retrieved indicating the incapability of camera.
+	@leave  May leave as a result of some other error.
+	@note   Since camera hardware may be incapable of providing the actual ISO value when one of the auto ISO type has
+			been set, then, in these cases, the 3rd argument should be retrieved as KErrNotFound.
+	*/
+	virtual void GetISORateL(CCamera::CCameraAdvancedSettings::TISORateType& aISORateType, TInt& aParam, TInt& aISORate) const=0;
+	/**
+	Provide reference screen for orientation information.
+	@param  aScreenDevice
+			A reference to the screen device.
+	@note	For consistency, when DSA view finder runs, it also provides a screen device. So, the DSA view finder's internal implementation
+			should call this method with the screen device passed ( 2nd argument to DSA view finder) to avoid disparity in knowing the refeence screen.
+			Triggers KUidECamEventCameraSettingReferenceScreen to all MCameraObserver2 clients of the camera.
+			Uses HandleEvent to report the result or any possible error.
+	*/
+	virtual void SetReferenceScreen(CWsScreenDevice& aScreenDevice)=0;
+	/**
+	Get the digital zoom steps for the still image when a particular image format and size are specified.
+	@param  aDigitalZoomSteps
+			A reference to an empty array of TInt to hold digital zoom step values for still image and multiplied by
+			KECamFineResolutionFactor to retain precision. If list returned is empty, this means feature is not supported.
+	@param  aInfo
+			A reference to TValueInfo, which establishes the type of the returned data.
+	@param  aSizeIndex
+			A value providing the size index which must be in the range 0 to TCameraInfo::iNumImageSizesSupported-1
+			inclusive.
+	@param  aFormat
+			A value providing the image format which must be one of the formats supported. (see
+			TCameraInfo::iImageFormatsSupported)
+	@param  aIsInfluencePossible
+			If True, signals that digital zoom step values may be influenced by some hardware factor like stabilization etc.
+			If False, no influence possible.
+	@leave  KErrNoMemory Out of memory. May leave with any other error code.
+	@note   This method retrieves the supported digital zoom steps irrespective of any stabilization influence.
+			In case of stabilization etc. influence, the setting function should set the best possible digital zoom value
+			and return error KErrECamDigitalZoomLimited along with dedicated event.
+	@note	When camera device doesn't support this feature, empty array should be returned and TValueInfo should be ENotActive,
+			and the corresponding getter/setters for this feature should not be used.
+	@note	Implementation recommendation for old methods which are used to retrieve the supported digital zoom values, is
+			to provide only safe values suitable in every cases.
+	*/
+	virtual void GetDigitalZoomStepsForStillL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo, TInt aSizeIndex,
+					CCamera::TFormat aFormat, TBool& aIsInfluencePossible) const=0;
+	/**
+	Get the digital zoom steps for the video when a particular video frame format, size and rate are specified.
+	@param  aDigitalZoomSteps
+			A reference to an empty array of TInt to hold digital zoom step values for video and multiplied by
+			KECamFineResolutionFactor to retain precision. If list returned is empty, this means feature is not supported.
+	@param  aInfo
+			A reference to TValueInfo, which establishes the type of the returned data.
+	@param  aFrameRateIndex
+			A value providing the rate index must be in the range 0 to TCameraInfo::iNumVideoFrameRatesSupported-1
+	        inclusive.
+	@param  aSizeIndex
+			A value providing the size index which must be in the range 0 to TCameraInfo::iNumVideoFrameSizesSupported-1
+			inclusive.
+	@param  aFormat
+			A value providing the format which must be one of the video frame formats supported. (see
+	        TCameraInfo::iVideoFrameFormatsSupported)
+	@param  aIsInfluencePossible
+			If True, signals that digital zoom step values may be influenced by some hardware factor like stabilization etc.
+			If False, no influence possible.
+	@param  aExposure
+			The exposure mode.
+	@leave  KErrNoMemory Out of memory. May leave with any other error code.
+	@note   This method retrieves the supported digital zoom steps irrespective of any stabilization influence.
+			In case of stabilization etc. influence, the setting function should set the best possible digital zoom value
+			and return error KErrECamDigitalZoomLimited along with dedicated event.
+	@note	When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive,
+			and the corresponding getter/setters for this feature should not be used.
+	@note	Implementation recommendation for old methods which are used to retrieve the supported digital zoom values, is
+			to provide only safe values suitable in every cases.
+	*/
+	virtual void GetDigitalZoomStepsForVideoL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo, TInt aFrameRateIndex,
+					TInt aSizeIndex, CCamera::TFormat aFormat, TBool& aIsInfluencePossible, CCamera::TExposure aExposure) const=0;
+	/**
+	Retrieves the pre capture warnings supported for a given camera mode
+	@param  aCameraMode
+			Desired camera mode for which the supported pre capture warnings may be retrieved.
+	@param 	aPreCaptureWarningSupported
+			A bitfield of all supported TPreCaptureWarning to be issued in the given camera mode.
+			If no pre capture warning supported for the given camera mode, EPCWNone is retrieved.
+	@leave  May leave with any error.
+	*/
+	virtual void GetPreCaptureWarningSupportedL(CCamera::CCameraAdvancedSettings::TCameraMode aCameraMode, TInt& aPreCaptureWarningSupported) const=0;
+	/**
+	Subscribe in order to receive event which indicates warnings on occurrence of some specific unfavourable
+	conditions before image/video capture.
+	@param  aPreCaptureWarning
+			A bitfield specifying all the TPreCaptureWarning types to be subscribed for.
+	@note	When any of the subscribed warnings (represented by aPreCaptureWarning) get generated by the camera device,
+			event KUidECamEventCameraSettingPreCaptureWarning is issued. TECAMEvent2 class should be used in order to
+			provide the status of every PreCaptureWarning.
+	@leave  May leave with any error.
+	*/
+	virtual void SubscribeToPreCaptureWarningL(TInt aPreCaptureWarning)=0;
+	/**
+	Unsubscribe so that further events are not received when warnings get issued.
+	@leave  May leave with any error.
+	*/
+	virtual void UnSubscribePreCaptureWarningL()=0;
+	/**
+	Get the status of every warnings defined.
+	@param  aPreCaptureWarning
+			A reference to the integer - bitfield  representing all the TPreCaptureWarning types issued.
+	@leave  May leave with any error.
+	@note   This method may be called after receiving the event KUidECamEventCameraSettingPreCaptureWarning OR
+			user may also opt for polling on this.
+	*/
+	virtual void GetPreCaptureWarningL(TInt& aPreCaptureWarning) const=0;
+	/**
+	Retrieve the different supported AF assistant light.
+	@param  aSupportedAFAssistantLight
+	        A reference to integer - bitfield indicating the supported AF assistant light.
+		    If EAFAssistantLightOff, this means AF assistant light is not supported.
+		    If EAFAssistantLightManualOn, then manual AF assistant light is supported.
+		    If EAFAssistantLightAuto, auto assistant light is supported.
+		    If combination of EAFAssistantLightManualOn||EAFAssistantLightAuto , then both manual and Auto assistant light are supported.
+	@leave  May leave with any error.
+	*/
+	virtual void GetSupportedAFAssistantLightL(TInt& aSupportedAFAssistantLight) const=0;
+	/**
+	Get the type ( and state) of AF assistant light currently set.
+	@param  aAFAssistantLight
+			A reference to AF assistant light.
+			If EAFAssistantLightOff, then manual and auto assistant light are switched off.
+			If EAFAssistantLightManualOn, manual assistant light is switched on.
+			If EAFAssistantLightAuto, AF assistant light is set to auto.
+	@leave  May leave with any error.
+	*/
+	virtual void GetAFAssistantLightL(CCamera::CCameraAdvancedSettings::TAFAssistantLight& aAFAssistantLight) const=0;
+	/**
+	Set a particular type ( and state) of AF assistant light.
+	@param  aAFAssistantLight
+			Type of AF assistant light to be set.
+			If EAFAssistantLightOff, switch off the manual or auto assistant light.
+			If EAFAssistantLightManualOn, manually switch on the assistant light.
+			If EAFAssistantLightAuto, camera will automatically switch it on/off as per the conditions.
+	@note   Triggers KUidECamEventCameraSettingAFAssistantLight to all MCameraObserver2 clients of the camera.
+			Uses HandleEvent to report the result or any possible error.
+	*/
+	virtual void SetAFAssistantLight(CCamera::CCameraAdvancedSettings::TAFAssistantLight aAFAssistantLight)=0;
+	};
+/**
+Mixin class for implementation by providers of 'advanced camera feature extensions' of the
+Advanced Settings Camera Extension API.
+@publishedPartner
+@prototype
+*/
+class MCameraAdvancedSettings4
+	{
+public:
+	/**
+	Releases the interface.
+	*/
+	virtual void Release()=0;
+	/**
+	Retrieves the supported continuous zoom types.
+	@param  aSupportedContinuousZoomType
+			Retrieves a bitfield of TUint which indicates the supported continuous zoom type as given by
+			CCamera::CCameraAdvancedSettings::TContinuousZoomType
+	@leave  May leave with any error code.
+	*/
+	virtual void GetSupportedContinuousZoomTypeL(TUint& aSupportedContinuousZoomType) const=0;
+	/**
+	Retrieves the minimum, current and maximum focal length in millimeters. This information is useful to find out
+	which zoom directions can be used on the fly.
+	@param  aMinFocalLength
+			Minimum focal length if positive.
+			Error value if negative (for example, KErrNotFound if information not available).
+	@param  aCurrentFocalLength
+			Current focal length if positive.
+			Error value if negative (for example, KErrNotFound if information not available).
+	@param  aMaxFocalLength
+			Maximum focal length if positive.
+			Error value if negative (for example, KErrNotFound if information not available).
+	@leave  May leave with any error code.
+	*/
+	virtual void GetFocalLengthInfoL(TInt& aMinFocalLength, TInt& aCurrentFocalLength, TInt& aMaxFocalLength) const=0;
+	/**
+	Retrieves the total number of operation preferences supported by the implementation. Operation preferences are
+	specified in terms of performance vectors, that is, speed, quality, low memory consumption and low power consumption.
+	@param  aNumOperationPreferenceSupported
+			Retrieves the number of operation preferences supported.
+	@leave  May leave with any error code.
+	*/
+	virtual void GetNumOperationPreferenceL(TUint& aNumOperationPreferenceSupported) const=0;
+	/**
+	Enumerate the available operation preferences.
+	@param  aOperationPreferenceIndex
+			A particular index which represents an operation preference. The level of different performance vectors may be known
+			through other arguments. This varies from 0 to n-1, where n is given by GetNumOperationPreferenceL(n).
+	@param  aSpeedLevel
+			A TPerformanceLevel which specifies the speed level related to the index aOperationPreferenceIndex.
+	@param  aQualityLevel
+			A TPerformanceLevel which specifies the quality level related to the index aOperationPreferenceIndex.
+	@param  aLowMemoryConsumptionLevel
+			A TPerformanceLevel which specifies the low memory consumption level related to the index aOperationPreferenceIndex.
+			The lower the memory consumption, the higher the level.
+	@param  aLowPowerConsumptionLevel
+			A TPerformanceLevel which specifies the low power consumption level related to the index aOperationPreferenceIndex.
+			The lower the power consumption, the higher the level.
+	@note   It is up to the implementation how the performance levels are achieved. For example, shutter opening, JPEQ quality
+			and parallel buffering in case of streamed image output can be controlled in order to provide the desired
+			performance.
+	@leave  May leave with any error code.
+	*/
+	virtual void EnumerateOperationPreferenceL(TUint aOperationPreferenceIndex, CCamera::CCameraAdvancedSettings::
+						TPerformanceLevel& aSpeedLevel, CCamera::CCameraAdvancedSettings::TPerformanceLevel& aQualityLevel,
+						CCamera::CCameraAdvancedSettings::TPerformanceLevel& aLowMemoryConsumptionLevel,
+						CCamera::CCameraAdvancedSettings::TPerformanceLevel& aLowPowerConsumptionLevel) const=0;
+	/**
+	Set a particular operation preference.
+	@param  aOperationPreferenceIndex
+			An index which reveals a set of levels to be used for performance vectors, that is, speed, quality, low memory
+			consumption and low power consumption.
+	@note   Event KUidECamEventCameraSettingOperationPreference is used to notify clients about setting an operation preference.
+	*/
+	virtual void SetOperationPreference(TUint aOperationPreferenceIndex)=0;
+	/**
+	Get the current operation preference being used.
+	@param  aOperationPreferenceIndex
+			Currently used operation preference index.
+	@leave  May leave with any error code.
+	*/
+	virtual void GetOperationPreferenceL(TInt& aOperationPreferenceIndex) const=0;
+	/**
+	Retrieves the event uids which the underlying implementation supports. The client may use these events notifications as
+	milestones in their application.
+	@param  aSupportedEvents
+			Retrieves as array of TUid. Every member of the array represents a supported event uid. These events are ECAM
+			component wide.
+	@leave  May leave with any error code.
+	@note   This method may retrieve unrecognized events which may be introduced later on.
+	*/
+	virtual void GetSupportedEventsL(RArray<TUid>& aSupportedEvents) const=0;
+	/**
+	Retrieves the indirect feature changes which occur because of a particular requested feature change.
+	Since the camera setting operation is asynchronous in nature, changing a particular camera feature, in certain cases,
+	involves indirectly changing another feature. In order to notify the ECam client about this indirect feature change,
+	event KUidECamEvent2IndirectFeatureChange is issued. After this notification, the client may use this method to retrieve
+	the	full list of indirect feature changes.
+	@param  aRequestedSetting
+			The actual requested feature change. This uid is supposed to be ECAM component wide and not restricted to
+			advanced camera settings.
+	@param  aIndirectFeatureChanges
+			An array of uids which retrieves the indirect feature changes. These uids are supposed to be ECAM component wide
+			and not restricted to advanced camera settings.
+	@leave  May leave with any error code.
+	*/
+	virtual void GetIndirectFeatureChangesL(TUid aRequestedSetting, RArray<TUid>& aIndirectFeatureChanges) const=0;
+	/**
+	Retrieves the concrete factory handle for the continuous zoom implementation.
+	@param  aImplFactoryPtr
+		    The concrete factory handle for the continuous zoom implementation.
+	@leave  May leave with any error code.
+	*/
+	virtual void CreateContinuousZoomImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const=0;
+	};
+/**
+Mixin class for implementation by providers of the Presets Camera Extension API.
+This API is used to simplify user - camera interaction by allowing simultaneous
+setting of various advanced camera hardware settings using a single parameter.
+A preset is identified by a single UID and relates to a known predefined outcome.
+For example the 'Night' Preset is used to set the camera into a night mode
+so that the user can take photos in dark conditions.
+The settings associated with a particular preset and their specific values and ranges
+are specific to each type of camera hardware and are therefore not defined by the API.
+@publishedPartner
+@released
+*/
+class MCameraPresets
+	{
+public:
+	/**
+	Releases the interface.
+	*/
+virtual void Release()=0;
+	/**
+	Gets the presets supported by the device. These are identified by UIDs
+	and relate to a known expected outcome.
+	The settings associated with a particular preset and their specific values and ranges are
+	specific to each type of camera hardware and are therefore not defined by the API.
+	@param  aPresets
+	        An empty array of TUids which the API implementation must populate with the specific supported preset values. If the array is empty on return,
+	the camera does not support presets.
+	@leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+	*/
+virtual void GetSupportedPresetsL(RArray<TUid>& aPresets) const=0;
+/**
+	Sets a specific preset supported by the camera.
+	All clients, implementing the MCameraObserver2 interface will receive a notification
+	with the UID of the specific preset, signalling a new preset has been selected.
+	@param  aPreset
+	        The UID of the new requested preset.
+	@note A particular preset is only active if it was established (through a call to
+	MCameraPresets ::SetPreset()) as the most recent operation affecting camera settings.
+	If some other camera setting is changed after calling MCameraPresets ::SetPreset()
+	then the preset is no longer active.
+	*/
+virtual void SetPreset(TUid aPreset)=0;
+/**
+	Gets the preset that was established by the last call to MCameraPresets ::SetPreset()
+	@return  The UID of the preset. If there is no active preset then the
+	         returned value is KNullUid.
+	@note A particular preset is only active if it was established (through a call to
+	MCameraPresets ::SetPreset()) as the most recent operation affecting camera settings.
+	If some other camera setting is changed after calling MCameraPresets ::SetPreset()
+	then the preset is no longer active.
+	*/
+virtual TUid Preset() const=0;
+/**
+Gets all settings affected by the current preset. All settings that are related to
+the preset in question will be included in the list, including any whose values
+have not changed as a result of applying the preset.
+@param  aSettings
+	        An empty array of TUids which the API implementation must populate with the specific settings.
+	@leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+	*/
+virtual void GetAffectedSettingsL(RArray<TUid>& aSettings) const=0;
+/**
+Gets all settings associated with a specific preset. This function does not require a preset to have been set prior the call as in
+GetAffectedSettingsL() function.
+The returned array will contain the UIDs of all settings which are associated and
+potentially affected by that particular preset.
+@param  aPreset
+the UID of the preset in question.
+@param  aSettings
+	        An empty array of TUids which would be populated by the implementation with
+	        the UIDs of the settings associated with that preset.
+	@leave KErrArgument if the preset UID is not recognised
+	@leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+	*/
+virtual void GetAssociatedSettingsL(TUid aPreset, RArray<TUid>& aSettings) const=0;
+	};
+/**
+Mixin class for implementation of extra methods of the Presets Camera Extension API.
+@publishedPartner
+@prototype
+*/
+class MCameraPresets2
+	{
+public:
+	/**
+	Releases the interface.
+	*/
+virtual void Release()=0;
+/**
+Retrieves those settings for which ranges have been restricted in order to let the camera work in a given preset mode.
+The client will be notified of range restrictions through uid KUidECamEventRangeRestricted. After receiving this
+notification, the client may use this method to retrieve those settings whose ranges have been restricted.
+@param  aRangeRestrictedSettings
+		An array of uid which represents those settings whose ranges have been restricted. These settings are ECam
+		component wide. For each of the settings, the client can query about the restricted range as per the usual way.
+@leave  May leave with any error code.
+*/
+virtual void GetRangeRestrictedSettingsL(RArray<TUid>& aRangeRestrictedSettings) const=0;
+/**
+Retrieves those settings which have been restricted (settings no longer supported) in order to let the camera work in a given preset mode.
+The client will be notified of feature restrictions through uid KUidECamEventFeatureRestricted. After receiving this
+notification, the client may use this method to retrieve these settings.
+@param  aFeatureRestrictedSettings
+		An array of uid which represents those settings which have been restricted. These settings are ECam
+		component wide.
+@leave  May leave with any error code.
+*/
+virtual void GetFeatureRestrictedSettingsL(RArray<TUid>& aFeatureRestrictedSettings) const=0;
+/**
+Retrieves information about whether the preset unlock feature is supported or not. Unlocking the preset helps in making some
+further changes in the setting after the camera works in a particular preset mode
+@param  aUnlockSupported
+		ETrue indicates preset unlock feature is supported.
+		EFalse indicates preset lock feature is not supported.
+@leave  May leave with any error code.
+*/
+virtual void IsPresetUnlockSupportedL(TBool& aUnlockSupported) const=0;
+	/**
+	Locks the preset for any further setting changes.
+	@note   Event KUidECamEventPresetLocked is used to notify clients that the preset has been locked.
+	*/
+	virtual void LockPreset()=0;
+	/**
+	Unlocks the preset to apply further setting changes.
+	@note   Event KUidECamEventPresetUnlocked is used to notify clients that the preset has been unlocked.
+	*/
+	virtual void UnlockPreset()=0;
+	};
+/**
+Mixin class for implementation of extra methods of the Continuous Zoom API.
+@internalTechnology
+@prototype
+*/
+class MCameraContinuousZoom
+	{
+public:
+	/**
+	Passes both the continuous zoom observer and pointer to the continuous zoom class to the implementation so callbacks
+	can be sent to the client along with the continuous zoom handle.
+	@param  aObserver
+			The reference to the continuous zoom observer.
+	@param  aContinuousZoomHandle
+			The pointer to the continuous zoom class object.
+	@see    MContinuousZoomObserver
+	*/
+	virtual void SetContinuousZoomObserverAndHandle(MContinuousZoomObserver& aObserver, CCamera::CCameraContinuousZoom* aContinuousZoomHandle)=0;
+	/**
+	Starts the continuous zoom operation. Clients will receive MContinuousZoomObserver::ContinuousZoomProgress() callback for intermediate zoom factors
+	achieved. It is up to the implementation to choose the zoom factors for which it will issue this callback. Implementation will not use this callback to notify
+	reaching the target zoom factor. This will be done via MContinuousZoomObserver::ContinuousZoomComplete() callback.
+	@param  aContinuousZoomParameters
+			The desired parameters to be used for the continuous zoom operation.
+	@note  If the implementation does not support re-configuring of zoom parameters whilst an existing continuous zoom operation is active then
+		   StartContinuousZoomL() will leave with KErrInUse.
+	@note  If client has selected EDirectionTele zoom direction and the current zoom factor is greater than the target zoom factor, StartContinuousZoomL()
+		   will leave with KErrArgument. Similarly, StartContinuousZoomL() will also leave with KErrArgument if client has selected EDirectionWide zoom
+		   direction and current zoom factor is less than target zoom factor.
+	@leave  May leave with any error code.
+	*/
+	virtual void StartContinuousZoomL(CCamera::CCameraAdvancedSettings::TContinuousZoomParameters aContinuousZoomParameters)=0;
+	/**
+	Stop any exisiting continuous zoom operation.
+	Since this method is synchronous, no callback shall be issued for the concerned continuous zoom operation.
+	*/
+	virtual void StopContinuousZoom()=0;
+	/**
+	Retrieves information about the supported settings related to continuous zoom support.
+	@param  aContinuousZoomInfo
+			The information of supported continuous zoom functionality.
+	@leave  May leave with any error code.
+	*/
+	virtual void GetContinuousZoomSupportInfoL(CCamera::CCameraAdvancedSettings::TContinuousZoomSupportInfo& aContinuousZoomInfo) const=0;
+	/**
+	Retrieves the unique id of the continuous zoom object.
+	This is used to identify the continuous zoom handle returned to clients via the MContinuousZoomObserver callback.
+	@param  aZoomId
+			The unique id of this Continuous Zoom object.
+	*/
+	virtual void GetContinuousZoomId(TInt& aZoomId) const=0;
+	/**
+	Releases the interface.
+	*/
+	virtual void Release()=0;
+	};
+#endif // ECAMADVSETTINGSINTF_H