// 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:

 //

 #include <ecam/ecamadvsettingsintf.h>

 #include "ecamversion.h"

 #include <ecam/ecamconstants.h>

 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

 #include <ecamadvsettingsconst.h>

 #include <ecamadvsettingsdef.h>

 #endif

 #include <ecam/implementationfactoryintf.h>

 const TInt KBaselinedFocusRanges = 0x1F;

 const TInt KBaselinedWhiteBalanceModes = 0x01FF;

 const TUint KBaselinedPixelAspectsMask = (CCamera::CCameraAdvancedSettings::EEPixelAspect59To54 << 1) - 1;

 const TUint KBaselinedFlashModeMask = (CCamera::EFlashManual << 1) - 1;

 const TUint KBaselinedPreCaptureWarning = (CCamera::CCameraAdvancedSettings::EPCWGeneralWarning << 1) - 1;

 const TUint KBaselinedDriveMode = (CCamera::CCameraAdvancedSettings::EDriveModeBurst << 1) - 1;

 /**

 Factory function for creating the CCameraPresets object.

 @param aCamera 

 	   a reference to a CCamera object providing the settings.

 @return a pointer to a fully constructed CCameraPresets object.

 @leave KErrNoMemory Out of memory Or any other system-wide error code.

 @note  Clients using MCameraObserver are not recommended to use this extension class since they cannot handle events.

 */

 EXPORT_C CCamera::CCameraPresets* CCamera::CCameraPresets::NewL(CCamera& aCamera)

 	{

 	CCamera::CCameraPresets* self = new (ELeave)CCamera::CCameraPresets(aCamera); 

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self; 

 	}

 /**	

 CCameraPresets Constructor.

 @param aOwner

        a reference to a CCamera object providing the settings. 

 */

 EXPORT_C CCamera::CCameraPresets::CCameraPresets(CCamera& aOwner):iOwner(aOwner), iImpl(NULL), iImpl2(NULL)

 	{

 	}

 /**

 CCameraPresets second phase constructor. 

 Function used to initialise internal state of the object. Uses reference to the camera to retrieve 

 Camera presets interface pointer.

 @leave KErrNoMemory Out of memory. 

 */ 

 EXPORT_C void CCamera::CCameraPresets::ConstructL() 

 	{

 	iImpl = static_cast<MCameraPresets*>(iOwner.CustomInterface(KECamMCameraPresetsUid));

 	if (iImpl == NULL)

 		{

 		User::Leave(KErrNotSupported);

 		}

 	iImpl2 = static_cast<MCameraPresets2*>(iOwner.CustomInterface(KECamMCameraPresets2Uid));

 	}

 /**

 Destructor

 */	

 EXPORT_C CCamera::CCameraPresets::~CCameraPresets()

 	{

 	if (iImpl != NULL)

 		{

 		iImpl->Release();	

 		}

 	if (iImpl2 != NULL)

 		{

 		iImpl2->Release();	

 		}

 	}	

 /** 

 Gets the presets supported by the camera. These are identified by UIDs 

 and relate to a known predefined 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 would be populated by the implementation with 

         the specific supported values. If the array is empty on return, 

     	the camera does not support presets.   

 @leave KErrNoMemory Out of memory. 

 @note   if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

 	    application is not prepared to receive extra added uid values (new presets added). So, any extra uid value(unrecognised)

 	    passed from the implementation will be filtered at this point.

 	    To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

 	    to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values.

 @note   Any preset uid, if added in future, has to have a uid value greater than KUidECamPresetFactoryDefaultUidValue

 	    otherwise unrecognized preset uids could not be checked.

 */

 EXPORT_C void CCamera::CCameraPresets::GetSupportedPresetsL(RArray<TUid>& aPresets) const

 	{

 	iImpl->GetSupportedPresetsL(aPresets);

     /* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

     application is not prepared to receive extra added uid values (new presets added). So, any extra uid value(unrecognised)

     passed from the implementation will be filtered at this point.

     To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

     to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */

     FilterUnrecognisedUids(aPresets, KUidECamPresetFactoryDefaultUidValue);

 	}

 /** 

 Sets a specific preset supported by the device.  

 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.

 */

 EXPORT_C void CCamera::CCameraPresets::SetPreset(TUid aPreset)

 	{

 	iImpl->SetPreset(aPreset);	

 	}

 /** 

 Gets the current preset set on the camera.

 @return  The UID of the current preset. If there is no active preset then the 

          returned value is KNullUid. 

 @note   if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that application is not 

 		prepared to receive extra added uid values (new presets added). So, any extra uid(unrecognised) value received from the 

 		implementation will be mapped to KUidECamPresetFactoryDefault at this point.

 	    To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

 	    to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values

 */

 EXPORT_C TUid CCamera::CCameraPresets::Preset() const

 	{

 	TUid preset = iImpl->Preset();

 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that application is not 

 	prepared to receive extra added uid values (new presets added). So, any extra uid(unrecognised) value received from the 

 	implementation will be mapped to KUidECamPresetFactoryDefault at this point.

     To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

     to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */

 	if(iOwner.CameraVersion() == KCameraDefaultVersion)

 		{

 		if(preset.iUid > KUidECamPresetFactoryDefaultUidValue)

 			{

 			preset = KUidECamPresetFactoryDefault;

 			}

 		}

 	return preset;	

 	}

 /**

 Get all settings affected by the current preset. This is to say that all settings which 

 are related to the preset in question will be included in the list, even though the value might 

 not have changed. 

 @param  aSettings

         An empty array of TUids which would be populated by the implementation with 

         the specific settings.

 @leave KErrNoMemory Out of memory. 

 @note   if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

 	    application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed 

 	    from the implementation will be filtered at this point.

 	    To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

 	    to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values

 */

 EXPORT_C void CCamera::CCameraPresets::GetAffectedSettingsL(RArray<TUid>& aSettings) const

 	{

 	iImpl->GetAffectedSettingsL(aSettings);

 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

     application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed 

     from the implementation will be filtered at this point.

     To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

     to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */

     FilterUnrecognisedUids(aSettings, KUidECamEventCameraSettingAutoFocusType2UidValue);

 	}

 /**

 Get all settings associated with a specific preset, identified by a UID. 

 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 provided preset UID is not recognised.

 @leave KErrNoMemory Out of memory. 

 @note  if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

 	   application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed 

 	   from the implementation will be filtered at this point.

 	   To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

 	   to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values

 */

 EXPORT_C void CCamera::CCameraPresets::GetAssociatedSettingsL(TUid aPreset, RArray<TUid>& aSettings) const

 	{

 	iImpl->GetAssociatedSettingsL(aPreset, aSettings);

 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

     application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed 

     from the implementation will be filtered at this point.

     To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

     to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */

     FilterUnrecognisedUids(aSettings, KUidECamEventCameraSettingAutoFocusType2UidValue);

 	}

 void CCamera::CCameraPresets::FilterUnrecognisedUids(RArray<TUid>& aUids, const TInt aBaselineUid) const

 	{

 	if(iOwner.CameraVersion() == KCameraDefaultVersion)

 		{

 		for(TInt index =0; index < aUids.Count(); index++)

 			{

 			/** aBaselineUid is the baseline. Any uid with greater uid value means that it has 

 			been added in later versions */

 			if(aUids[index].iUid > aBaselineUid)

 				{

 				aUids.Remove(index);

 				index--;

 				}

 			}

 		}

 	}

 /**

 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 ECAM event 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 uids 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 ranges in the usual way.

 		Empty array indicates that there are no range restricted settings for the given preset.

 @leave  May leave with any error code.

 @publishedPartner

 @prototype

 */

 EXPORT_C void CCamera::CCameraPresets::GetRangeRestrictedSettingsL(RArray<TUid>& aRangeRestrictedSettings) const

 	{

 	if(iImpl2 != NULL)

 		{

 		iImpl2->GetRangeRestrictedSettingsL(aRangeRestrictedSettings);	

 		}

 	else

 		{

 		User::Leave(KErrNotSupported);	

 		}	

 	}

 /**

 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 ECAM event KUidECamEventFeatureRestricted. After receiving 

 this notification, the client may use this method to retrieve these settings.

 @param  aFeatureRestrictedSettings

 		An array of uids which represents those settings which have been restricted. These settings are ECam 

 		component wide. Empty array indicates that there are no settings which have been been restricted for 

 		the given preset.

 @leave  May leave with any error code.

 @publishedPartner

 @prototype

 */

 EXPORT_C void CCamera::CCameraPresets::GetFeatureRestrictedSettingsL(RArray<TUid>& aFeatureRestrictedSettings) const

 	{

 	if(iImpl2 != NULL)

 		{

 		iImpl2->GetFeatureRestrictedSettingsL(aFeatureRestrictedSettings);	

 		}

 	else

 		{

 		User::Leave(KErrNotSupported);	

 		}	

 	}

 /**

 Retrieves information about whether the preset unlock feature is supported or not. Unlocking the preset helps in making

 further setting changes 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.

 @publishedPartner

 @prototype

 */

 EXPORT_C void CCamera::CCameraPresets::IsPresetUnlockSupportedL(TBool& aUnlockSupported) const

 	{

 	if(iImpl2 != NULL)

 		{

 		iImpl2->IsPresetUnlockSupportedL(aUnlockSupported);	

 		}

 	else

 		{

 		User::Leave(KErrNotSupported);	

 		}		

 	}

 /**

 Locks the preset for any further setting changes.

 @note   Event KUidECamEventPresetLocked is used to notify clients that the preset has been locked.

 @publishedPartner

 @prototype

 */

 EXPORT_C void CCamera::CCameraPresets::LockPresetL()

 	{

 	if(iImpl2 != NULL)

 		{

 		iImpl2->LockPreset();	

 		}

 	else

 		{

 		User::Leave(KErrNotSupported);	

 		}	

 	}

 /**

 Unlocks the preset to apply further setting changes.

 @note   Event KUidECamEventPresetUnlocked is used to notify clients that the preset has been unlocked.

 @publishedPartner

 @prototype

 */

 EXPORT_C void CCamera::CCameraPresets::UnlockPresetL()

 	{

 	if(iImpl2 != NULL)

 		{

 		iImpl2->UnlockPreset();	

 		}

 	else

 		{

 		User::Leave(KErrNotSupported);	

 		}

 	}

 /**

 Factory function for creating the CCameraAdvancedSettings object.

 @param aCamera 

 	a reference to a CCamera object providing the settings.

 @return a pointer to a fully constructed CCameraAdvancedSettings object.

 @leave KErrNoMemory Out of memory or any other system-wide error code.

 @note  Clients using MCameraObserver are not recommended to use this extension class since they cannot handle events.

 */

 EXPORT_C CCamera::CCameraAdvancedSettings* CCamera::CCameraAdvancedSettings::NewL(CCamera& aCamera)

 	{

 	CCamera::CCameraAdvancedSettings* self = new (ELeave)CCamera::CCameraAdvancedSettings(aCamera); 

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self; 

 	}

 /**	

 CCameraAdvancedSettings Constructor.

 @param aOwner

        a reference to a CCamera object providing the settings. 

 */

 EXPORT_C CCamera::CCameraAdvancedSettings::CCameraAdvancedSettings(CCamera& aOwner) : iOwner(aOwner), iImpl(NULL), iImpl2(NULL), iImpl3(NULL), iImpl4(NULL)

 	{

 	}

 /**

 CCameraAdvancedSettings second phase constructor.

 Function used to initialise internal state of the object. Uses reference to the camera to retrieve 

 Camera advanced settings interface pointer.

 @leave KErrNoMemory Out of memory.

 */ 

 EXPORT_C void CCamera::CCameraAdvancedSettings::ConstructL() 

 	{

 	iImpl = static_cast<MCameraAdvancedSettings*>(iOwner.CustomInterface(KECamMCameraAdvancedSettingsUid));

 	if (iImpl == NULL)

 		{

 		User::Leave(KErrNotSupported);

 		}

 	iImpl2 = static_cast<MCameraAdvancedSettings2*>(iOwner.CustomInterface(KECamMCameraAdvancedSettings2Uid));

 	iImpl3 = static_cast<MCameraAdvancedSettings3*>(iOwner.CustomInterface(KECamMCameraAdvancedSettings3Uid));

 	iImpl4 = static_cast<MCameraAdvancedSettings4*>(iOwner.CustomInterface(KECamMCameraAdvancedSettings4Uid));

 	}

 /**

 Destructor

 */	

 EXPORT_C CCamera::CCameraAdvancedSettings::~CCameraAdvancedSettings()

 	{

 	if (iImpl != NULL)

 		{

 		iImpl->Release();	

 		}

 	if (iImpl2 != NULL)

 		{

 		iImpl2->Release();	

 		}

 	if (iImpl3 != NULL)

 		{

 		iImpl3->Release();	

 		}

 	if (iImpl4 != NULL)

 		{

 		iImpl4->Release();	

 		}

 	}

 /** 

 Gets the type of this camera. 

 @see TCameraType

 @return the type of this camera 

 */	

 EXPORT_C CCamera::CCameraAdvancedSettings::TCameraType CCamera::CCameraAdvancedSettings::CameraType() const

 	{

 	return iImpl->CameraType();

 	}

 /** 

 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. 

 @see TCameraType

 @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.

 */

 EXPORT_C CCamera::CCameraAdvancedSettings::TCameraType CCamera::CCameraAdvancedSettings::CameraType(TInt aCameraIndex) 

 	{

 	return iImpl->CameraType(aCameraIndex);

 	}

 /** 

 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.   

 */	

 EXPORT_C TBool CCamera::CCameraAdvancedSettings::IsCameraPresent() const

 	{

 	return iImpl->IsCameraPresent();

 	}

 /** 

 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. 

 */	

 EXPORT_C TBool CCamera::CCameraAdvancedSettings::IsCameraPresent(TInt aCameraIndex) 

 	{

 	return iImpl->IsCameraPresent(aCameraIndex);

 	}

 /**

 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].

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::CameraIndex() const

 	{

 	return iImpl->CameraIndex(); 

 	}

 /** 

 Gets all of the supported stabilization modes on the camera. The result is a bitfield

 of the valid TStabilizationMode flags. 

 @see TStabilizationMode

 @return a bitfield of all supported stabilization modes. 

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedStabilizationModes() const

 	{

 	return iImpl->SupportedStabilizationModes();

 	}

 /** 

 Gets current stabilization mode on the camera. 

 The result is a valid TStabilizationMode value. 

 @return current stabilization mode of type TStabilizationMode. 

 */

 EXPORT_C CCamera::CCameraAdvancedSettings::TStabilizationMode CCamera::CCameraAdvancedSettings::StabilizationMode() const

 	{

 	return iImpl->StabilizationMode();

 	}

 /** 

 Sets a specific stabilization mode on the camera.

 Stabilization mode change fires a KUidECamEventCameraSettingStabilizationMode

 event to all MCameraObserver2 clients of this specific camera.

 @param aStabilizationMode

        new stabilization mode of TStabilizationMode type.

 */	

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetStabilizationMode(CCamera::CCameraAdvancedSettings::TStabilizationMode aStabilizationMode)

 	{

 	iImpl->SetStabilizationMode(aStabilizationMode);

 	}

 /** 

 Gets all of the supported focus modes on the camera. The result is a bitfield

 of the valid TFocusMode flags. 

 @see TFocusMode 

 @return a bitfield of all supported focus modes. 

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedFocusModes() const

 	{

 	return iImpl->SupportedFocusModes();

 	}

 /** 

 Gets current focus mode on the camera. 

 The result is a valid TFocusMode value. 

 @return current focus mode. 

 */

 EXPORT_C CCamera::CCameraAdvancedSettings::TFocusMode CCamera::CCameraAdvancedSettings::FocusMode() const

 	{

 	return iImpl->FocusMode();

 	}

 /** 

 Sets a specific focus mode on the camera.

 Focus mode change fires a KUidECamEventCameraSettingFocusMode event

 to all MCameraObserver2 clients of the camera.

 @param aFocusMode 

        new focus mode of TFocusMode type.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetFocusMode(CCamera::CCameraAdvancedSettings::TFocusMode aFocusMode)

 	{

 	iImpl->SetFocusMode(aFocusMode);

 	}

 /** 

 Gets all supported focus ranges on the camera.

 @return an integer - a bitfield of all supported TFocusRange values.

 @note  if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

 	   application is not prepared to receive extra added enum values. So, any extra enum value passed 

 	   from the implementation will be filtered at this point.

 	   To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

 	   to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values 

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedFocusRanges() const

 	{

 	TInt supportedFocusRanges = iImpl->SupportedFocusRanges();

 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

 	   application is not prepared to receive extra added enum values. So, any extra enum value passed 

 	   from the implementation will be filtered at this point.

 	   To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

 	   to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */

 	if(iOwner.CameraVersion() == KCameraDefaultVersion)

 		{

 		supportedFocusRanges &= KBaselinedFocusRanges;

 		}

 	return supportedFocusRanges;

 	}

 /** 

 Gets current focus range on the camera.

 @return the current TFocusRange value. 

 @note  if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

 	   application is not prepared to receive extra added enum values. So, any extra enum value received 

 	   from the implementation will be dropped and EFocusRangeAuto would be passed instead.

 	   To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

 	   to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values

 */	

 EXPORT_C CCamera::CCameraAdvancedSettings::TFocusRange CCamera::CCameraAdvancedSettings::FocusRange() const

 	{

 	CCamera::CCameraAdvancedSettings::TFocusRange focusRange = iImpl->FocusRange();

 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

 	   application is not prepared to receive extra added enum values. So, any extra enum value received 

 	   from the implementation will be dropped and EFocusRangeAuto would be passed instead.

 	   To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

 	   to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */

 	if(iOwner.CameraVersion() == KCameraDefaultVersion)

 		{

 		if(static_cast<TInt>(focusRange) > KBaselinedFocusRanges)

 			{

 			focusRange = CCamera::CCameraAdvancedSettings::EFocusRangeAuto;

 			}

 		}

 	return focusRange;

 	}

 /** 

 Sets a specific focus range on the camera.

 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.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetFocusRange(CCamera::CCameraAdvancedSettings::TFocusRange aFocusRange)

 	{

 	iImpl->SetFocusRange(aFocusRange);

 	}

 /** 

 Gets all supported auto focus types on the camera.

 @return an integer - a bitfield of all supported TAutoFocusType values. 

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedAutoFocusTypes() const

 	{

 	return iImpl->SupportedAutoFocusTypes();

 	}

 /** 

 Gets current auto focus type on the camera. 

 @see TAutoFocusType

 @return a CCamera::TAutoFocusType value. 

 */	

 EXPORT_C CCamera::CCameraAdvancedSettings::TAutoFocusType CCamera::CCameraAdvancedSettings::AutoFocusType() const

 	{

 	return iImpl->AutoFocusType();

 	}

 /** 

 Sets a specific auto focus type on the camera.

 The focus type change fires both, KUidECamEventCameraSettingAutoFocusType and 

 KUidECamEventCameraSettingAutoFocusType2 event to all MCameraObserver2 clients of the camera.

 @see KUidECamEventCameraSettingAutoFocusType

 @param aAutoFocusType

        Autofocus selection.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetAutoFocusType(CCamera::CCameraAdvancedSettings::TAutoFocusType aAutoFocusType)

 	{

 	iImpl->SetAutoFocusType(aAutoFocusType);

 	}

 /** 

 Gets all supported auto focus areas on the camera.

 @return an integer - a bitfield of al supported TAutoFocusArea values. 

 */	

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedAutoFocusAreas() const

 	{

 	return iImpl->SupportedAutoFocusAreas();

 	}

 /** 

 Gets current chosen auto focus area on the camera.

 @return a CCamera::TAutoFocusArea value. 

 */

 EXPORT_C CCamera::CCameraAdvancedSettings::TAutoFocusArea CCamera::CCameraAdvancedSettings::AutoFocusArea() const

 	{

 	return iImpl->AutoFocusArea();

 	}

 /** 

 Sets a specific auto focus area on the camera.

 Focus area change fires a KUidECamEventCameraSettingAutoFocusArea event

 to all MCameraObserver2 clients of the camera.

 @param aAutoFocusArea

        Autofocus area selection.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetAutoFocusArea(CCamera::CCameraAdvancedSettings::TAutoFocusArea aAutoFocusArea)

 	{

 	iImpl->SetAutoFocusArea(aAutoFocusArea);

 	}

 /**

 Get focus distance in millimetres.

 @return the current focus distance in millimetres, directly from user setting of lenses.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::FocusDistance() const

 	{

 	return iImpl->FocusDistance();

 	}

 /**

 Set focus distance in millimetres. Focus distance change fires a KUidECamEventCameraSettingFocusDistance event

 to all MCameraObserver2 clients of the camera.

 @param aDistance 

 	   the new distance value in millimetres.

 @note  KUidECamEvent2CameraSettingFocusDistance may be used to provide the focussing feedback as well. This means that 

 	   the feedback will state whether the proper focussing has been achieved after setting the given focus distance.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetFocusDistance(TInt aDistance)

 	{

 	iImpl->SetFocusDistance(aDistance);

 	}

 /**

 Get minimum focus distance in millimetres 

 @return the minimum (35 camera equivalent) focal length of a camera. 

 @note Current Focal length is calculated as focalLength = opticalZoom * minFocalLength;  

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::GetMinFocalLength() const

 	{

 	return iImpl->GetMinFocalLength();

 	}

 /**

 Gets the set of camera supported ISO rates.

 @param aSupportedIsoRates

        an array of integers which gets filled 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 permanently set value. If this value is not known, empty array may be 

 	   returned; corresponding getter/setters for this feature should not be used in such a case.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetSupportedIsoRatesL(RArray<TInt>& aSupportedIsoRates) const

 	{

 	iImpl->GetSupportedIsoRatesL(aSupportedIsoRates);

 	}

 /**

 Gets current ISO rate.

 @return current ISO rate as a TInt value. 

 		Negative value returned means error case (system wide error code) and positive value means current ISO rate.

 @note The returned value may be checked with the list of supported ISO rates. If value returned does not belong to 

 	  this list, then it may be treated as an error case.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::IsoRate() const

 	{

 	return iImpl->IsoRate();

 	}

 /**

 Set current ISO rate for the camera.

 Triggers KUidECamEventCameraSettingIsoRate to all MCameraObserver2 clients of the camera.

 @param aRate

 	   required new ISO rate.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetIsoRate(TInt aRate)

 	{

 	iImpl->SetIsoRate(aRate);

 	}

 /** 

 Gets the current discrete aperture steps (F-stops) supported by the camera.

 @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 may be 

 	   returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetAperturesL(RArray<TInt>& aFStops, TValueInfo& aInfo) const

 	{

 	iImpl->GetAperturesL(aFStops, aInfo);

 	}

 /** 

 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. 

 	    Negative value returned means error case (system wide error code) and positive value means current aperture.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::Aperture() const

 	{

 	return iImpl->Aperture();

 	}

 /** 

 Set a new aperture value. 

 All MCameraObserver2 clients of the camera receive a KUidECamEventCameraSettingAperture 

 event notification when aperture value is changed.

 @param aFStop 

 	   a new aperture value in the supported by the camera range.       

 @note The aperture parameter value is an integer, multiplied by KECamFineResolutionFactor. 

 	  For example to set an aperture of F2.8, call SetAperture(280).

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetAperture(TInt aFStop) 

 	{

 	iImpl->SetAperture(aFStop); 

 	}

 /**

 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 camera.

 @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 may be 

 	   returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetShutterSpeedsL(RArray<TInt>& aShutterSpeeds, TValueInfo& aInfo) const 

 	{

 	iImpl->GetShutterSpeedsL(aShutterSpeeds, aInfo);

 	}

 /**

 Gets the current shutter speed

 @return the current shutter speed in microseconds. 

 		Negative value returned means error case (system wide error code) and positive value means current shutter speed.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::ShutterSpeed() const 

 	{

 	return iImpl->ShutterSpeed();

 	}

 /**

 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.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetShutterSpeed(TInt aShutterSpeed) 

 	{

 	iImpl->SetShutterSpeed(aShutterSpeed); 

 	}

 /**

 Get all supported metering modes on this camera represented as bitfield of type TMeteringMode.

 @return the set of supported metering modes.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedMeteringModes() const

 	{

 	return iImpl->SupportedMeteringModes();

 	}

 /**

 Get current metering mode.

 @return a value of type TMeteringMode.

 */

 EXPORT_C CCamera::CCameraAdvancedSettings::TMeteringMode CCamera::CCameraAdvancedSettings::MeteringMode() const

 	{

 	return iImpl->MeteringMode();

 	}

 /**

 Set the current metering mode. When set, all MCameraObserver2 clients are notified 

 with a KUidECamEventCameraSettingMeteringMode event. 

 @param aMeteringMode

 		new selection for metering mode of type TMeteringMode.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetMeteringMode(CCamera::CCameraAdvancedSettings::TMeteringMode aMeteringMode)

 	{

 	iImpl->SetMeteringMode(aMeteringMode);

 	}

 /** 

 Get all supported drive modes as bitfields of TDriveMode type. 

 @return the set of supported drive modes.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedDriveModes() const

 	{

 	TInt supportedDriveModes = iImpl->SupportedDriveModes();

 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

   	application is not prepared to receive extra added enum values. So, any extra enum value passed 

    	from the implementation will be filtered at this point.

    	To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

    	to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */

 	if(iOwner.CameraVersion() == KCameraDefaultVersion)

 		{

 		supportedDriveModes &= KBaselinedDriveMode;

 		}

 	return supportedDriveModes;

 	}

 /** 

 Gets currently active drive mode.

 @return current drive mode.

 */

 EXPORT_C CCamera::CCameraAdvancedSettings::TDriveMode CCamera::CCameraAdvancedSettings::DriveMode() const

 	{

 	CCamera::CCameraAdvancedSettings::TDriveMode driveMode = iImpl->DriveMode();

 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

 	   application is not prepared to receive extra added enum values. So, any extra enum value received 

 	   from the implementation will be dropped and EDriveModeAuto would be passed instead.

 	   To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

 	   to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */

 	if(iOwner.CameraVersion() == KCameraDefaultVersion)

 		{

 		if(static_cast<TUint>(driveMode) > KBaselinedDriveMode)

 			{

 			driveMode = CCamera::CCameraAdvancedSettings::EDriveModeAuto;

 			}

 		}

 	return driveMode;

 	}

 /**

 Set the current metering mode. When set all MCameraObserver2 clients  are notified with 

 KUidECamEventCameraSettingDriveMode. 

 @param aDriveMode

 	   new selection for drive mode value of type TDriveMode.

 @note  Unless reduced Latency scheme is not used (ie CaptureImageL(TInt aSequenceNumber) or StartPerformantVideoCaptureL())

 	   if an image/video capture is still outstanding, this method may report error KErrInUse.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetDriveMode(CCamera::CCameraAdvancedSettings::TDriveMode aDriveMode)

 	{

 	iImpl->SetDriveMode(aDriveMode);

 	}

 /**

 Get all supported bracket modes as bitfields.

 @return the set of all supported bracket modes as an integer.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedBracketModes() const

 	{

 	return iImpl->SupportedBracketModes();

 	}

 /**

 Get current bracket mode.

 @return the current bracket mode TBracketMode.

 */

 EXPORT_C CCamera::CCameraAdvancedSettings::TBracketMode CCamera::CCameraAdvancedSettings::BracketMode() const

 	{

 	return iImpl->BracketMode();

 	}

 /**

 Set new bracket mode. All MCameraObserver2 clients are notified with 

 KUidECamEventCameraSettingBracketMode. 

 @param aBracketMode

 	   new selection for bracket mode of type TBracketMode.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetBracketMode(CCamera::CCameraAdvancedSettings::TBracketMode aBracketMode)

 	{

 	iImpl->SetBracketMode(aBracketMode);

 	}

 /**

 Get all supported bracket parameters as bitfields.

 @return the set of all currently supported bracket modes.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedBracketParameters() const

 	{

 	return iImpl->SupportedBracketParameters();

 	}

 /**

 Get current bracket parameter.

 @return the current bracket mode TBracketParameter.

 */

 EXPORT_C CCamera::CCameraAdvancedSettings::TBracketParameter CCamera::CCameraAdvancedSettings::BracketParameter() const

 	{

 	return iImpl->BracketParameter();

 	}

 /**

 Set new bracket parameter

 When set all clients are notified with 

 KUidECamEventCameraSettingBracketParameter. 

 @param aBracketParameter

 	   new selection for parameter type of type TBracketParameter.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetBracketParameter(CCamera::CCameraAdvancedSettings::TBracketParameter aBracketParameter)

 	{

 	iImpl->SetBracketParameter(aBracketParameter);

 	}

 /**

 Get all supported bracket steps as bitfields.

 @return the set of all supported bracket modes.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedBracketSteps() const

 	{

 	return iImpl->SupportedBracketSteps();

 	}

 /**

 Get current bracket step.

 @return the current bracket mode TBracketStep.

 */

 EXPORT_C CCamera::CCameraAdvancedSettings::TBracketStep CCamera::CCameraAdvancedSettings::BracketStep() const

 	{

 	return iImpl->BracketStep();

 	}

 /**

 Set new bracket step. All MCameraObserver2 clients are notified with 

 KUidECamEventCameraSettingBracketStep. 

 @param aBracketStep

 	   new selection for step of type TBracketStep.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetBracketStep(CCamera::CCameraAdvancedSettings::TBracketStep aBracketStep)	

 	{

 	iImpl->SetBracketStep(aBracketStep);

 	}

 /** 

 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 operation. 

 @param  aStartIndex

 		the index of the start frame, starts from 0.

 @param  aFrames

 		the number of frames to be merged.		

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetBracketMerge(TInt& aStartIndex, TInt& aFrames) const	

 	{

 	iImpl->GetBracketMerge(aStartIndex, aFrames);

 	}

 /** 

 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.		

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetBracketMerge(TInt aStartIndex, TInt aFrames)

 	{

 	iImpl->SetBracketMerge(aStartIndex, aFrames);

 	}

 /**

 Get camera all supported flash modes CCamera::TFlash

 @return the set of all supported flash modes as bitfields in an integer.

 @note Some of the flash modes are available only for clients using either CCamera::New2L() or CCamera::NewDuplicate2L()

 @see CCamera::TFlash

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedFlashModes() const

 	{

 	TInt modes = iImpl->SupportedFlashModes();

 	if (iOwner.CameraVersion() == KCameraDefaultVersion)

 	    {

 	    modes &= KBaselinedFlashModeMask;

 	    }

 	return modes;

 	}

 /** 

 Gets the currently set flash mode.

 @return  The currently set flash mode. 

 @note   Clients not using the CCamera::New2L() or CCamera::NewDuplicate2L() would be given CCamera::EFlashAuto 

         if current flash mode exceeds CCamera::EFlashManual 

 @see CCamera::TFlash

 */

 EXPORT_C CCamera::TFlash CCamera::CCameraAdvancedSettings::FlashMode() const

 	{

 	TInt mode = iImpl->FlashMode();

 	if (iOwner.CameraVersion() == KCameraDefaultVersion && mode > KBaselinedFlashModeMask)

 	    {

 	    mode = EFlashAuto;

 	    }

 	return static_cast<CCamera::TFlash>(mode);

 	}

 /** 

 Sets the flash mode.

 Triggers a KUidECamEventCameraSettingFlashMode event to all camera 

 MCameraObserver2 clients.

 @param  aMode

         The required flash mode. 

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetFlashMode(CCamera::TFlash aMode)

 	{

 	iImpl->SetFlashMode(aMode);

 	}

 /** 

 Gets whether the flash red eye reduction is switched on.

 @return The present state - ETrue for switched on and EFalse for switched off. 

 */

 EXPORT_C TBool CCamera::CCameraAdvancedSettings::RedEyeReduceOn() const

 	{

 	return iImpl->RedEyeReduceOn();

 	}

 /** 

 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. 

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetRedEyeReduceOn(TBool aState)

 	{

 	iImpl->SetRedEyeReduceOn(aState);

 	}

 /** 

 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 may be returned and TValueInfo may be ENotActive; 

 	   corresponding getter/setters for this feature should not be used in such a case. 

 @note  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 may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetFlashCompensationStepsL(RArray<TInt>& aFlashCompensationSteps, TValueInfo& aInfo) const

 	{

 	iImpl->GetFlashCompensationStepsL(aFlashCompensationSteps, aInfo);

 	}

 /** 

 @deprecated Use TInt GetFlashCompensationStep(TInt& aFlashCompensationStep); 

 Get current flash power compensation step.

 @return current flash compensation step.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::FlashCompensationStep() const

 	{

 	return iImpl->FlashCompensationStep();

 	}

 /** 

 Get current flash power compensation step.

 @param aFlashCompensationStep

 	   Reference to the current flash compensation step.

 @return system wide error code.

 @note  Use this method in place of deprecated TInt FlashCompensationStep()

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::GetFlashCompensationStep(TInt& aFlashCompensationStep) const

 	{

 	return iImpl->GetFlashCompensationStep(aFlashCompensationStep);

 	}

 /** 

 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.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetFlashCompensationStep(TInt aFlashCompensationStep)	

 	{

 	iImpl->SetFlashCompensationStep(aFlashCompensationStep);

 	}

 /**

 Get current flash power compensation range measured in a already selected compensation step magnitude.

 @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 multiplier (in steps) and the direction (the sign). Steps are always assumed integers.	

 @param aNegativeCompensation

        a reference to an integer returning the maximum number of steps available for negative compensation.

 @param aPositiveCompensation

        a reference to an integer returning the maximum number of steps available for positive compensation.     

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetFlashCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const

 	{

 	iImpl->GetFlashCompensationRangeInSteps(aNegativeCompensation, aPositiveCompensation);

 	}

 /** 

 @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 of compensation steps as an integer.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::FlashCompensation() const

 	{

 	return iImpl->FlashCompensation();

 	}

 /** 

 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.

 @note Use this method in place of deprecated TInt FlashCompensation()

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::GetFlashCompensation(TInt& aFlashCompensation) const

 	{

 	return iImpl->GetFlashCompensation(aFlashCompensation);

 	}

 /**  

 Set the current flash compensation value as integer steps. 

 Positive values increase power, negative reduce power. The change is not acumulative e.g. 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.         

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetFlashCompensation(TInt aFlashCompensationSteps)

 	{

 	iImpl->SetFlashCompensation(aFlashCompensationSteps);

 	}

 /**

 Check whether there is an external flash source.

 @return ETrue if an external flash source is present, EFalse otherwise  

 */ 

 EXPORT_C TBool CCamera::CCameraAdvancedSettings::IsExternalFlashPresent() const	

 	{

 	return iImpl->IsExternalFlashPresent();

 	}

 /** 

 Gets the current discrete manual flash power levels supported by the camera 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 may be returned and TValueInfo may be ENotActive;

 	   corresponding getter/setters for this feature should not be used in such a case. 

 	   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 permanently set value. If this value is not known, empty 

 	   array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetManualFlashPowerLevelsL(RArray<TInt>& aManualFlashPowerLevels, TValueInfo& aInfo) const

 	{

 	return iImpl->GetManualFlashPowerLevelsL(aManualFlashPowerLevels, aInfo);

 	}

 /**

 Gets the current manual flash power level on the camera.

 @return the current manual flash power level as a value in the range [0:100]. 

 		Negative value returned means error case (system wide error code) and positive value means current manual flash power level.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::ManualFlashPowerLevel() const

 	{

 	return iImpl->ManualFlashPowerLevel();

 	}

 /**

 Sets the current manual flash power level on the camera.

 Triggers a KUidECamEventCameraSettingFlashManualPower event to all MCameraObserver2 clients.

 @param  aManualFlashPowerLevel

         one of the values returned in GetManualFlashPowerLevelsL(). 

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetManualFlashPowerLevel(TInt aManualFlashPowerLevel)

 	{

 	iImpl->SetManualFlashPowerLevel(aManualFlashPowerLevel);

 	}

 /**

 Get Supported exposure modes - bitfields of CCamera::TExposure

 @return the set of supported exposure modes.  

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedExposureModes() const

 	{

 	return iImpl->SupportedExposureModes();

 	}

 /** 

 Gets the currently set exposure setting value.

 @return  The currently set exposure setting value. 

 */

 EXPORT_C CCamera::TExposure CCamera::CCameraAdvancedSettings::ExposureMode() const

 	{

 	return iImpl->ExposureMode();

 	}

 /** 

 Sets the exposure mode of the camera.

 Triggers a KUidECamEventCameraSettingExposureMode event to all MCameraObserver2 clients.

 @param  aExposureMode

         The required exposure adjustment. 	        

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetExposureMode(CCamera::TExposure aExposureMode)

 	{

 	iImpl->SetExposureMode(aExposureMode);

 	}

 /** 

 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. 

 @note  When camera device doesn't support this, empty array may be returned and TValueInfo may be ENotActive; 

 	   corresponding getter/setters for this feature should not be used in such a case.	 

 	   When camera device is incapable of revealing the exposure compensation steps supported, 

 	   it has to be assumed that camera will work only on the permanently set value. If this value is not known, empty 

 	   array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetExposureCompensationStepsL(RArray<TInt>& aExposureCompensationSteps, TValueInfo& aInfo) const

 	{

 	iImpl->GetExposureCompensationStepsL(aExposureCompensationSteps, aInfo);

 	}

 /** 

 @deprecated Use TInt GetExposureCompensationStep(TInt& aExposureCompensationStep); 

 Get current exposure compensation step.

 @return the current exposure compensation step.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::ExposureCompensationStep() const

 	{

 	return iImpl->ExposureCompensationStep();

 	}

 /** 

 Get current exposure compensation step.

 @param aExposureCompensationStep

 	   Reference to the current exposure compensation step.

 @return system wide error code.

 @note Use this method in place of deprecated TInt ExposureCompensationStep() 

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::GetExposureCompensationStep(TInt& aExposureCompensationStep) const

 	{

 	return iImpl->GetExposureCompensationStep(aExposureCompensationStep);

 	}

 /** 

 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.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetExposureCompensationStep(TInt aExposureCompensationStep)

 	{

 	iImpl->SetExposureCompensationStep(aExposureCompensationStep);

 	}

 /**

 Get current exposure compensation range in steps. It depends on the previously 

 selected exposure compensation step. 

 @see GetFlashCompensationRangeInSteps()

 @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, 

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetExposureCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const

 	{

 	iImpl->GetExposureCompensationRangeInSteps(aNegativeCompensation, aPositiveCompensation);

 	}

 /** 

 @deprecated Use TInt GetExposureCompensation(TInt& aExposureCompensation);  

 Get the current exposure compensation 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 of compensation steps as an integer.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::ExposureCompensation() const

 	{

 	return iImpl->ExposureCompensation();

 	}

 /** 

 Get the current exposure compensation 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.

 @note Use this method in place of deprecated TInt ExposureCompensation()

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::GetExposureCompensation(TInt& aExposureCompensation) const

 	{

 	return iImpl->GetExposureCompensation(aExposureCompensation);

 	}

 /** 

 Set the current exposure compensation value as integer steps.

 Triggers a KUidECamEventCameraSettingExposureCompensation event to all MCameraObserver2 clients.

 @param 	aExposureCompensationSteps  

         a required number of compensation steps - negative value reduce the exposure time

         positive increases the exposure time. 

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetExposureCompensation(TInt aExposureCompensationSteps)

 	{

 	iImpl->SetExposureCompensation(aExposureCompensationSteps);

 	}

 /**

 Gets camera supported set of white balance adjustments.

 @return bitfield of all supported CCamera::TWhiteBalance values.  

 @note  if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

 	   application is not prepared to receive extra added enum values. So, any extra enum value(unrecognised) passed 

 	   from the implementation will be filtered at this point.

 	   To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

 	   to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedWhiteBalanceModes() const

 	{

 	TInt supportedWhiteBalanceModes = iImpl->SupportedWhiteBalanceModes();

 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

 	   application is not prepared to receive extra added enum values. So, any extra enum value(unrecognised) passed 

 	   from the implementation will be filtered at this point.

 	   To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

 	   to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */

 	if(iOwner.CameraVersion() == KCameraDefaultVersion)

 		{

 		supportedWhiteBalanceModes &= KBaselinedWhiteBalanceModes;

 		}

 	return supportedWhiteBalanceModes;

 	}

 /** 

 Gets the current white balance value.

 @return The current white balance value.

 @note  if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

 	   application is not prepared to receive extra added enum values. So, any extra enum value(unrecognised) received 

 	   from the implementation will be dropped and EWBAuto would be passed instead.

 	   To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

 	   to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values

 */

 EXPORT_C CCamera::TWhiteBalance CCamera::CCameraAdvancedSettings::WhiteBalanceMode() const

 	{

 	CCamera::TWhiteBalance whiteBalance = iImpl->WhiteBalanceMode();

 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

 	   application is not prepared to receive extra added enum values. So, any extra enum value(unrecognised) received 

 	   from the implementation will be dropped and EWBAuto would be passed instead.

 	   To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

 	   to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */

 	if(iOwner.CameraVersion() == KCameraDefaultVersion)

 		{

 		if(static_cast<TInt>(whiteBalance) > KBaselinedWhiteBalanceModes)

 			{

 			whiteBalance = CCamera::EWBAuto;

 			}

 		}

 	return whiteBalance;

 	}

 /** 

 Sets the white balance adjustment of the camera.

 No effect if this is not supported, see TCameraInfo::iWhiteBalanceModesSupported.

 Triggers KUidECamEventCameraSettingWhiteBalanceMode event to all MCameraObserver2 clients.

 @param  aWhiteBalanceMode

         The required white balance mode.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetWhiteBalanceMode(CCamera::TWhiteBalance aWhiteBalanceMode)

 	{

 	iImpl->SetWhiteBalanceMode(aWhiteBalanceMode);

 	}

 /** 

 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. 

 */

 EXPORT_C TBool CCamera::CCameraAdvancedSettings::ApertureExposureLockOn() const

 	{

 	return iImpl->ApertureExposureLockOn();

 	}

 /** 

 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.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetApertureExposureLockOn(TBool aAELock)

 	{

 	iImpl->SetApertureExposureLockOn(aAELock);

 	}

 /**

 Gets the current state for button clicking sound effect. 

 @return  ETrue to switch clicking sound on, EFalse sound off  

 */

 EXPORT_C TBool CCamera::CCameraAdvancedSettings::ShootClickOn() const

 	{

 	return iImpl->ShootClickOn();

 	}

 /**

 Sets the button clicking sound on /off. Triggers a KUidECamEventSoundClick event 

 to all MCameraObserver2 clients. 

 @param aShootClickOn

        ETrue to switch clicking sound on, EFalse sound is switched off.  

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetShootClickOn(TBool aShootClickOn)

 	{

 	iImpl->SetShootClickOn(aShootClickOn);

 	}

 /**

 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 may be returned and TValueInfo may be ENotActive;

 	   corresponding getter/setters for this feature should not be used in such a case.	 

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetTimerIntervalsL(RArray<TInt>& aTimerIntervals, TValueInfo& aInfo) const

 	{

 	iImpl->GetTimerIntervalsL(aTimerIntervals, aInfo);

 	}

 /**

 Get current timer value. Active only when drive mode is EDriveModeTimed.

 Timer resolution is in microseconds. 

 @return current time interval value. 

 		Negative value returned means error case (system wide error code) and positive value means current timer interval.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::TimerInterval() const

 	{

 	return iImpl->TimerInterval();

 	}

 /**

 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.        

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetTimerInterval(TInt aTimerInterval)

 	{

 	iImpl->SetTimerInterval(aTimerInterval);

 	}

 /**

 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.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetTimeLapsePeriodRange(TTime& aTimeLapseMin, TTime& aTimeLapseMax) const

 	{

 	iImpl->GetTimeLapsePeriodRange(aTimeLapseMin, aTimeLapseMax); 

 	}

 /**

 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.		

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetTimeLapse(TTime& aStart, TTime& aEnd, TTime& aInterval) const

 	{

 	iImpl->GetTimeLapse(aStart, aEnd, aInterval);

 	}

 /**

 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.	

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetTimeLapse(const TTime& aStart, const TTime& aEnd, const TTime& aInterval)

 	{

 	iImpl->SetTimeLapse(aStart, aEnd, aInterval);

 	}

 /**

 Get current picture orientation

 @return a TPictureOrientation value.

 */

 EXPORT_C CCamera::CCameraAdvancedSettings::TPictureOrientation CCamera::CCameraAdvancedSettings::PictureOrientation() const

 	{

 	return iImpl->PictureOrientation();

 	}

 /**

 Set a new picture orientation

 This triggers a KUidECamEventCameraSettingPictureOrientation event to all MCameraObserver2 clients.

 @param aOrientation

        a value of TPictureOrientation denoting the new orientation.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetPictureOrientation(CCamera::CCameraAdvancedSettings::TPictureOrientation aOrientation)

 	{

 	iImpl->SetPictureOrientation(aOrientation);

 	}

 /**

 Get supported pixel aspect ratio.

 @return a bitfield of all supported TPixelAspectRatio values.

 @note Some of the pixel aspect ratios are available only for clients using either CCamera::New2L() or CCamera::NewDuplicate2L()

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedPixelAspectRatios() const	

 	{

 	TInt supportedRatios = iImpl->SupportedPixelAspectRatios();

 	/**

 	    Mask out new features for old clients

 	*/

 	if (iOwner.CameraVersion() == KCameraDefaultVersion)

 	    {

 	    supportedRatios &= KBaselinedPixelAspectsMask;

 	    }

 	return supportedRatios;

 	}

 /**

 Get current pixel aspect ratio.

 @return a TPixelAspectRatio value.

 @note Some of the pixel aspect ratios are available only for clients using either CCamera::New2L() or CCamera::NewDuplicate2L()

 */

 EXPORT_C CCamera::CCameraAdvancedSettings::TPixelAspectRatio CCamera::CCameraAdvancedSettings::PixelAspectRatio() const

 	{

 	TInt ratio = iImpl->PixelAspectRatio();

 	/**

 	    Mask out new features for old clients

 	*/

 	if (iOwner.CameraVersion() == KCameraDefaultVersion)

 	    {

 	    ratio &= KBaselinedPixelAspectsMask;

 	    }	

 	return static_cast<CCamera::CCameraAdvancedSettings::TPixelAspectRatio>( ratio );

 	}

 /**

 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.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetPixelAspectRatio(CCamera::CCameraAdvancedSettings::TPixelAspectRatio aPixelAspectRatio)

 	{

 	iImpl->SetPixelAspectRatio(aPixelAspectRatio);

 	}

 /**

 Get supported YUV ranges.

 @return a bitfileld of all supported TYuvRange values.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedYuvRanges() const

 	{

 	return iImpl->SupportedYuvRanges();

 	}

 /**

 Get current YUV range.

 @return a TYuvRange value.

 */

 EXPORT_C CCamera::CCameraAdvancedSettings::TYuvRange CCamera::CCameraAdvancedSettings::YuvRange() const

 	{

 	return iImpl->YuvRange();

 	}

 /**

 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.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetYuvRange(CCamera::CCameraAdvancedSettings::TYuvRange aYuvRange)

 	{

 	iImpl->SetYuvRange(aYuvRange);

 	}

 /**

 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. 

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::BurstImages() const

 	{

 	return iImpl->BurstImages();

 	}

 /**

 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 StartPerformantVideoCaptureL())

 	   if an image/video capture is still outstanding, this method may report error KErrInUse.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetBurstImages(TInt aImages)	

 	{

 	iImpl->SetBurstImages(aImages);

 	}

 /** 

 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 may be returned and TValueInfo may be ENotActive;

         corresponding getter/setters for this feature should not be used in such a case.

 @leave KErrNoMemory Out of memory. 

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetOpticalZoomStepsL(RArray<TInt>& aOpticalZoomSteps, TValueInfo& aInfo) const

 	{

 	iImpl->GetOpticalZoomStepsL(aOpticalZoomSteps, aInfo);

 	}

 /** 

 Gets the currently set zoom value.

 @return  The currently set optical zoom value. The value is multiplied by 

 		 KECamFineResolutionFactor to retain precision. 

 		 Negative value returned means error case (system wide error code) and positive value means current optical zoom.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::OpticalZoom() const

 	{

 	return iImpl->OpticalZoom();

 	}

 /** 

 Sets the zoom using a specific value. Triggers a KUidECamEventCameraSettingOpticalZoom 

 event to all MCameraObserver2 clients.

 @param aOpticalZoom 

        Required zoom value.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetOpticalZoom(TInt aOpticalZoom)

 	{

 	iImpl->SetOpticalZoom(aOpticalZoom);

 	}

 /** 

 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 may be returned and TValueInfo may be ENotActive;

 		corresponding getter/setters for this feature should not be used in such a case.

 @leave KErrNoMemory Out of memory. 

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetDigitalZoomStepsL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo) const

 	{

 	iImpl->GetDigitalZoomStepsL(aDigitalZoomSteps, aInfo);

 	}

 /** 

 Gets the currently set digital zoom value.

 @return  The currently set digital zoom value. The value is multiplied by 

 		 KECamFineResolutionFactor to retain precision. 

 		 Negative value returned means error case (system wide error code) and positive value means current digital zoom.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::DigitalZoom() const

 	{

 	return iImpl->DigitalZoom();

 	}

 /** 

 Sets the digital zoom value. Triggers a KUidECamEventCameraSettingDigitalZoom event

 to all MCameraObserver2 clients.

 @param aDigitalZoom 

        Required zoom value.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetDigitalZoom(TInt aDigitalZoom)

 	{

 	iImpl->SetDigitalZoom(aDigitalZoom);

 	}

 /** 

 Checks whether exposure value is locked or not.

 @return whether exposure value is locked or not. 

 		ETrue if locked, EFalse otherwise. 

 */

 EXPORT_C TBool CCamera::CCameraAdvancedSettings::ExposureLockOn() const

 	{

 	return iImpl->ExposureLockOn();

 	}

 /** 

 Sets exposure lock state. Triggers a KUidECamEventCameraSettingExposureLock event

  to all MCameraObserver2 clients.

 @param aState 

        Required new state.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetExposureLockOn(TBool aState)

 	{

 	iImpl->SetExposureLockOn(aState);

 	}

 /** 

 Checks whether AutoFocus value is locked or not.

 @return whether AutoFocus value is locked or not. 

 		ETrue if locked, EFalse otherwise. 

 */

 EXPORT_C TBool CCamera::CCameraAdvancedSettings::AutoFocusLockOn() const

 	{

 	return iImpl->AutoFocusLockOn();

 	}

 /** 

 Sets autofocus lock state. Triggers a KUidECamEventCameraSettingAutoFocusLock event

 to all MCameraObserver2 clients.

 @param aState 

        Required new state.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetAutoFocusLockOn(TBool aState)

 	{

 	iImpl->SetAutoFocusLockOn(aState);

 	}

 /** 

 Gets an array of all the advanced settings parameters supported by the camera. 

 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. 

 @note   if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

 	    application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed 

 	    from the implementation will be filtered at this point.

 	    To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

 	    to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const	

 	{

 	iImpl->GetSupportedSettingsL(aSettings); 

 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

     application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed 

     from the implementation will be filtered at this point.

     To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

     to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */

 	if(iOwner.CameraVersion() == KCameraDefaultVersion)

 		{

 		for(TInt index =0; index < aSettings.Count(); index++)

 			{

 			/** KUidECamEventCameraSettingAutoFocusType2UidValue is the baseline. Any settings with greater uid value means that it has 

 			been added in later versions */

 			if(aSettings[index].iUid > KUidECamEventCameraSettingAutoFocusType2UidValue)

 				{

 				aSettings.Remove(index);

 				index--;

 				}

 			}

 		}

 	}

 /** 

 Gets an array of all the advanced settings parameters currently active on the camera. 

 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.

 @note   if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

 	    application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed 

 	    from the implementation will be filtered at this point.

 	    To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

 	    to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const

 	{

 	iImpl->GetActiveSettingsL(aActiveSettings);

 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

     application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed 

     from the implementation will be filtered at this point.

     To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

     to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */

 	if(iOwner.CameraVersion() == KCameraDefaultVersion)

 		{

 		for(TInt index =0; index < aActiveSettings.Count(); index++)

 			{

 			/** KUidECamEventCameraSettingAutoFocusType2UidValue is the baseline. Any settings with greater uid value means that it has 

 			been added in later versions */

 			if(aActiveSettings[index].iUid > KUidECamEventCameraSettingAutoFocusType2UidValue)

 				{

 				aActiveSettings.Remove(index);

 				index--;

 				}

 			}

 		}

 	}

 /** 

 Gets an array of all the advanced settings parameters currently disabled on the camera. 

 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.

 @note   if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

 	    application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed 

 	    from the implementation will be filtered at this point.

 	    To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

 	    to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const	

 	{

 	iImpl->GetDisabledSettingsL(aDisabledSettings); 

 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

     application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed 

     from the implementation will be filtered at this point.

     To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

     to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */

 	if(iOwner.CameraVersion() == KCameraDefaultVersion)

 		{

 		for(TInt index =0; index < aDisabledSettings.Count(); index++)

 			{

 			/** KUidECamEventCameraSettingAutoFocusType2UidValue is the baseline. Any settings with greater uid value means that it has 

 			been added in later versions */

 			if(aDisabledSettings[index].iUid > KUidECamEventCameraSettingAutoFocusType2UidValue)

 				{

 				aDisabledSettings.Remove(index);

 				index--;

 				}

 			}

 		}

 	}

 /** 

 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.

 */

 EXPORT_C TBool CCamera::CCameraAdvancedSettings::AutomaticSizeSelectionChangeOn() const

 	{

 	return iImpl->AutomaticSizeSelectionChangeOn();

 	}

 /** 

 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

  */     

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetAutomaticSizeSelectionChangeOn(TBool aSetOn)

 	{

 	iImpl->SetAutomaticSizeSelectionChangeOn(aSetOn);

 	}

 /** 

 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.

 @note   When camera device doesn't support this, empty array may be returned and TValueInfo may be ENotActive;

 		corresponding getter/setters for this feature should not be used in such a case.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetSupportedContinuousAutoFocusTimeoutsL(RArray<TInt>& aTimeouts, TValueInfo& aInfo) const

 	{

 	iImpl->GetSupportedContinuousAutoFocusTimeoutsL(aTimeouts, aInfo);

 	}

 /**

 Gets the current value for continuous autofocus timeout. Timeouts are in microseconds.

 @return  the timeout value in microseconds. 

 		 Negative value returned means error case (system wide error code) and positive value means current value for 

 		 continuous autofocus timeout.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::ContinuousAutoFocusTimeout() const

 	{

 	return iImpl->ContinuousAutoFocusTimeout();

 	}

 /**

 Sets the current 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

 		the timeout value in microseconds. 

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetContinuousAutoFocusTimeout(TInt aTimeout)

 	{

 	iImpl->SetContinuousAutoFocusTimeout(aTimeout);

 	}

 /**

 Gets all supported stabilization effects on the camera.

 @return an integer - a bitfield of all supported TStabilizationEffect values. 

 */

 EXPORT_C CCamera::CCameraAdvancedSettings::TStabilizationEffect CCamera::CCameraAdvancedSettings::StabilizationEffect() const

 	{

 	return iImpl->StabilizationEffect();

 	}

 /**

 Gets the current stabilization effect on the camera.

 @return a TStabilizationEffect value.

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedStabilizationEffects() const

 	{

 	return iImpl->SupportedStabilizationEffects();

 	}

 /**

 Sets a specific stabilization effect on the camera. 

 When a value is set, MCameraObserver2 clients for that camera will receive a 

 KUidECamEventCameraSettingsStabilizationEffect event notification.

 @param aEffect

        stabilization effect selection of type TStabilizationEffect.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetStabilizationEffect(CCamera::CCameraAdvancedSettings::TStabilizationEffect aEffect)

 	{

 	iImpl->SetStabilizationEffect(aEffect);

 	}

 /**

 Gets all supported stabilization algorithm values on the camera.

 @return an integer - a bitfield of all supported TStabilizationAlgorithmComplexity values. 

 */

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedStabilizationComplexityValues() const

 	{

 	return iImpl->SupportedStabilizationComplexityValues();

 	}

 /**

 Gets current active stabilization algorithm selection on the camera.

 @return a TStabilizationAlgorithmComplexity value.

 */

 EXPORT_C CCamera::CCameraAdvancedSettings::TStabilizationAlgorithmComplexity CCamera::CCameraAdvancedSettings::StabilizationComplexity() const

 	{

 	return iImpl->StabilizationComplexity();

 	}

 /**

 Sets a specific stabilization algorithm on the camera. 

 When a value is set, MCameraObserver2 clients for that camera will receive a 

 KUidECamEventSettingsStabilizationAlgorithmComplexity event notification.

 @param aComplexity

        stabilization effect selection of type TStabilizationAlgorithmComplexity.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetStabilizationComplexity(CCamera::CCameraAdvancedSettings::TStabilizationAlgorithmComplexity aComplexity)

 	{

 	iImpl->SetStabilizationComplexity(aComplexity);

 	}

 /**

 Gets the units in which the white balance is measured on the camera. 

 @note The methods used to get or set these differ depending on the supported unit type.  

 It is expected that a camera will support only a single type or none.

 @return a value of TWBUnits type.   

 */

 EXPORT_C CCamera::CCameraAdvancedSettings::TWBUnits CCamera::CCameraAdvancedSettings::SupportedWBUnits()  const

 	{

 	return iImpl->SupportedWBUnits();

 	}

 /**

 Get white balance value represented as a RGB triplet. 

 @see TRgb

 @param aValue

 	   a reference to TRgb object which will contain the current white balance.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetWBRgbValue(TRgb& aValue) const

 	{

 	iImpl->GetWBRgbValue(aValue);

 	}

 /**

 Set white balance value using a RGB triplet.  

 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.

 @see TRgb

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetWBRgbValue(const TRgb& aValue)

 	{

 	iImpl->SetWBRgbValue(aValue);

 	}

 /**

 Get the white balance values, as temperature measured in Kelvin, supported on the camera.

 @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 may be returned and TValueInfo may be ENotActive; 

 		corresponding getter/setters for this feature should not be used in such a case.    

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetWBSupportedColorTemperaturesL(RArray<TInt>& aWBColorTemperatures, TValueInfo& aInfo) const

 	{

 	iImpl->GetWBSupportedColorTemperaturesL(aWBColorTemperatures, aInfo);

 	}

 /**

 Get the white balance as a temperature in Kelvin

 @return current white balance value as a temperature in Kelvins.

 		Negative value returned means error case (system wide error code) and positive value means current value for 

 		white balance as a temperature in Kelvin.

 */	

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::WBColorTemperature() const

 	{

 	return iImpl->WBColorTemperature();

 	}

 /**

 Set the white balance as a temperature in Kelvin

 @param aColorTemperature

 	   white balance value as a temperature in Kelvins.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetWBColorTemperature(TInt aColorTemperature)

 	{

 	iImpl->SetWBColorTemperature(aColorTemperature);

 	}

 /** 

 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.

 */	

 EXPORT_C TInt CCamera::CCameraAdvancedSettings::IsFlashReady(TBool& aReady) const

 	{

 	aReady = EFalse;

 	if(iImpl2 != NULL)

 		{

 		return iImpl2->IsFlashReady(aReady);

 		}

 	return KErrNotSupported;

 	}

 /**

 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 may be returned and TValueInfo may be ENotActive;

 		corresponding getter/setters for this feature should not be used in such a case.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetCurrentFocusModeStepsL(RArray<TInt>& aFocusModeSteps, TValueInfo& aInfo) const

 	{

 	if(iImpl2 != NULL)

 		{

 		iImpl2->GetCurrentFocusModeStepsL(aFocusModeSteps, aInfo);	

 		}

 	else

 		{

 		User::Leave(KErrNotSupported);	

 		}		

 	}

 /**

 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  KErrNotSupported if the implementation of this method is not present. May leave as a result of some other error. 

 @note   When concrete implementation is provided, but camera device does not support this feature, then aSupportedISORateTypes retrieves EISONone.

 */	

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetSupportedISORateTypeL(TInt& aSupportedISORateTypes) const

 	{

 	if(iImpl3 != NULL)

 		{

 		iImpl3->GetSupportedISORateTypeL(aSupportedISORateTypes);	

 		}

 	else

 		{

 		User::Leave(KErrNotSupported);	

 		}	

 	}

 /** 

 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.

 @leave  KErrNotSupported if the implementation of this method is not present.

 @note   Triggers KUidECamEventCameraSettingIsoRateType to all MCameraObserver2 clients of the camera. 

 		HandleEvent is used to report the result or any possible error. New setter functions leave only when 

 		implementation is not there.  

 */	

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetISORateL(CCamera::CCameraAdvancedSettings::TISORateType aISORateType, TInt aParam)

 	{

 	if(iImpl3 != NULL)

 		{

 		iImpl3->SetISORate(aISORateType, aParam);	

 		}

 	else

 		{

 		User::Leave(KErrNotSupported);	

 		}

 	}

 /** 

 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 is retrieved indicating the incapability of camera.

 @leave  KErrNotSupported if the implementation of this method is not present. 

 		May leave as a result of some other error. 

 @note   When concrete implementation is provided, but camera device does not support this feature, then aISORateType retrieves EISONone.

 @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 is retrieved as KErrNotFound.

 */	

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetISORateL(CCamera::CCameraAdvancedSettings::TISORateType& aISORateType, TInt& aParam, TInt& aISORate) const

 	{

 	if(iImpl3 != NULL)

 		{

 		iImpl3->GetISORateL(aISORateType, aParam, aISORate);	

 		}

 	else

 		{

 		User::Leave(KErrNotSupported);	

 		}	

 	}

 /**

 Provide reference screen for orientation information.

 @param  aScreenDevice

 		A reference to the screen device.

 @leave  KErrNotSupported if the implementation of this method is not present.

 @note	Triggers KUidECamEventCameraSettingReferenceScreen to all MCameraObserver2 clients of the camera. 

 		HandleEvent is used to report the result or any possible error. New setter functions leave only when 

 		implementation is not there.

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::SetReferenceScreenL(CWsScreenDevice& aScreenDevice)

 	{

 	if(iImpl3 != NULL)

 		{

 		iImpl3->SetReferenceScreen(aScreenDevice);	

 		}

 	else

 		{

 		User::Leave(KErrNotSupported);	

 		}

 	}

 /**

 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  KErrNotSupported if the implementation of this method is not present. 

 		KErrNoMemory if out of memory. May leave as a result of some other error. 

 @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 concrete implementation is provided, but camera device does not support this feature, empty array may be returned and 

 		TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case. 

 */

 EXPORT_C void CCamera::CCameraAdvancedSettings::GetDigitalZoomStepsForStillL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo, 

 						TInt aSizeIndex, CCamera::TFormat aFormat, TBool& aIsInfluencePossible) const

 	{

 	if(iImpl3 != NULL)

 		{

 		iImpl3->GetDigitalZoomStepsForStillL(aDigitalZoomSteps, aInfo, aSizeIndex, aFormat, aIsInfluencePossible);	

 		}

 	else

 		{

 		User::Leave(KErrNotSupported);	

 		}	

 	}

 /**

 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.