// Copyright (c) 2004-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 <ecom/ecom.h>

 #include <ecom/implementationproxy.h>

 #include <ecamuids.hrh>

 #include <ecam.h>

 #include "ECamUnitTestPluginUids.hrh"

 #include "AdvancedSettings.h"

 #include <ecamerrors.h>

 #include <ecamadvsettings.h>

 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

 #include <ecamadvsettingsconst.h>

 #include <ecamadvsettingsdef.h>

 #include <ecamimageprocessingconst.h>

 #include <ecamconst.h>

 #endif

 const TInt KContinuousAutoFocusTimeoutValue = 20000;

 const TInt KBrightnessAdjMinValue			= -50;

 const TInt KBrightnessAdjMaxValue			= 50;

 const TInt KDefaultShutterSpeed				= 0;

 const TInt KDefaultFocusDistance			= 0;

 const TInt KDefaultAperture					= 280;

 const TInt KBracketStartIndex				= 0;

 const TInt KBracketFrames					= 2;

 const TBool KDefaultRedEyeReduce			= EFalse;

 const TInt KFlashCompensationStep			= 2;

 const TInt KFlashCompensationInSteps		= 1;

 const TBool KExternalFlashPresentState		= EFalse;

 const TInt KManualFlashPowerLevel			= 0;

 const TInt KExposureCompensationStep		= 3;

 const TInt KExposureCompensationInSteps		= 2;

 const TBool KApertureExposureLockOn         = EFalse;

 const TBool KShootClickOn					= EFalse;

 const TInt KTimerInterval					= 0;

 const TInt KBurstImages						= 0;

 const TBool KExposureLockOn         		= EFalse;

 const TBool KAutoFocusLockOn         		= EFalse;

 const TBool KAutomaticSizeSelectionChangeOn	= EFalse;

 const TInt KWBColorTemperature				= 6000;

 const TBool KFlashReadyState				= EFalse;

 const TInt KSupportedISORateType			= 0x1F;

 const TBool KCapableActualISOValue			= EFalse;

 const TInt KAFAssistantLightManual			= 0x01;

 const TInt KConcurrentColorOpSupported		= 0x01;

 const TInt KDefault							= 0x01;

 const TInt KFocusRangeSupported				= 0x7F;

 const TInt KWhiteBalanceSupported			= 0x0FFF;

 //

 // CCamPresets

 //

 CCamPresets::CCamPresets(CCamUnitTestPlugin& aOwner): iOwner(aOwner)

 	{

 	iSupportedPresets[0] = KUidECamPresetOutdoor;

 	iSupportedPresets[1] = KUidECamPresetBeach;

 	iSupportedPresets[2] = KUidECamPresetNightPartyIndoor;

 	iSupportedPresets[3] = KUidECamPresetNone;

 	iCurrentPreset = KUidECamPresetNone;

 	iAffectedSettings[0] = KUidECamEventCameraSettingAperture;

 	iAffectedSettings[1] = KUidECamEventCameraSettingIsoRateType;

 	iAffectedSettings[2] = KUidECamEventCameraSettingIsoRate;

 	iRangeRestrictedSettings.Reset();

 	iIsPresetUnLockSupported = EFalse;

 	iIsPresetLocked = ETrue;

 	}

 CCamPresets::~CCamPresets()

 	{

 	Dll::FreeTls();

 	iRangeRestrictedSettings.Close();

 	}

 CCamPresets* CCamPresets::NewL(CCamUnitTestPlugin& aOwner)

 	{

 	CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());

 	if(!globalData)

 		{

 		globalData = new (ELeave) CDataGlobal;

 		CleanupStack::PushL(globalData);

 		globalData->iReferenceCount = 0;

 		globalData->iCamPresets = new (ELeave) CCamPresets(aOwner);

     	globalData->iCamPresets->iRefCount = 1;

 		TInt error = Dll::SetTls(globalData);

 		if (error)

 			{

 			delete globalData->iCamPresets;

 			User::Leave(error);

 			}

 		CleanupStack::Pop(globalData);

 		return static_cast <CCamPresets*> (globalData->iCamPresets);

 		}

 	else

 		{

 		CCamPresets* self = globalData->iCamPresets;

 		globalData->iReferenceCount++;

 		self->iRefCount = globalData->iReferenceCount + 1;

 		if (globalData->iReferenceCount == 1 )

 			{

 			delete globalData;

 			Dll::FreeTls();

 			}

 		else

 			{

 			TInt error = Dll::SetTls(globalData);

 			if (error)

 				{

 				delete globalData->iCamPresets;

 				User::Leave(error);

 				}	

 			}

 		return static_cast <CCamPresets*> (self);		

 		}

 	}

 void CCamPresets::Release()

 	{

 	iRefCount--; 

 	if(!iRefCount)

 		{

 		delete this;

 		}

 	}	

 void CCamPresets::GetSupportedPresetsL(RArray<TUid>& aPresets) const

 	{

 	aPresets.Reset();

 	TInt count = sizeof(iSupportedPresets)/sizeof(TUid);

 	for (TInt i = 0; i < count; i++)

 		{

 		aPresets.AppendL(iSupportedPresets[i]);

 		}	

 	}

 void CCamPresets::SetPreset(TUid aPreset)

 	{

 	TInt response = KErrECamParameterNotInRange;

 	for (TInt i = 0; i < KSupportedPresetsNumber; i++)

 		{

 		if (iSupportedPresets[i] == aPreset)

 			{

 			iCurrentPreset = aPreset;

 			response = KErrNone;

 			switch(aPreset.iUid)

 				{

 				case KUidECamPresetOutdoorUidValue:

 					{

 					response = iRangeRestrictedSettings.Append(KUidECamEventCameraSettingIsoRate);

 					if(iOwner.iSupportedISORates.Count() == KNumSupportedIsoRate)

 						{

 						iOwner.iSupportedISORates.Remove(KNumSupportedIsoRate-1);

 						if(iOwner.iIsoRate == KMaxIsoRate)

 							{

 							iOwner.iIsoRate = KIsoRate5;

 							}

 						}

 					iIsPresetUnLockSupported = ETrue;

 					break;

 					}

 				//fall through

 				case KUidECamPresetBeachUidValue:

 				case KUidECamPresetNightPartyIndoorUidValue:

 				case KUidECamPresetNoneUidValue:

 				default:

 					{

 					if(iOwner.iSupportedISORates.Count() == KNumSupportedIsoRate-1)

 						{

 						iOwner.iSupportedISORates.AppendL(KMaxIsoRate);

 						}

 					iIsPresetUnLockSupported = EFalse;

 					break;	

 					}

 				}

 			break;

 			}

 		}

 	iOwner.Notify(aPreset, response);

 	if(aPreset == KUidECamPresetOutdoor)

 		{

 		iOwner.Notify(KUidECamEventRangeRestricted, KErrNone);

 		}

 	}

 TUid CCamPresets::Preset() const

 	{

 	return iCurrentPreset;

 	}

 void CCamPresets::GetAffectedSettingsL(RArray<TUid>& aSettings) const

 	{

 	aSettings.Reset();

 	if (iCurrentPreset!=KUidECamPresetNone)

 		{

 		TInt count = sizeof(iAffectedSettings)/sizeof(TUid);

 		for (TInt i = 0; i < count; i++)

 			{

 			aSettings.AppendL(iAffectedSettings[i]);

 			}

 		}

 	}

 void CCamPresets::GetAssociatedSettingsL(TUid aPreset, RArray<TUid>& aSettings) const

 	{

 	aSettings.Reset();

 	if (aPreset == KUidECamPresetNone)

 		{

 		User::Leave(KErrArgument);

 		}

 	TInt count = sizeof(iAffectedSettings)/sizeof(TUid);

 	for (TInt i = 0; i < count; i++)

 		{

 		aSettings.AppendL(iAffectedSettings[i]);

 		}

 	}

 void CCamPresets::GetRangeRestrictedSettingsL(RArray<TUid>& aRangeRestrictedSettings) const

 	{

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

 		{

 		aRangeRestrictedSettings.AppendL(iRangeRestrictedSettings[index]);

 		}

 	}

 void CCamPresets::GetFeatureRestrictedSettingsL(RArray<TUid>& aFeatureRestrictedSettings) const

 	{

 	aFeatureRestrictedSettings.Reset();

 	}

 void CCamPresets::IsPresetUnlockSupportedL(TBool& aUnlockSupported) const

 	{

 	aUnlockSupported = iIsPresetUnLockSupported;	

 	}

 void CCamPresets::LockPreset()

 	{

 	iIsPresetLocked = ETrue;

 	iOwner.Notify(KUidECamEventPresetLocked, KErrNone);

 	}

 void CCamPresets::UnlockPreset()

 	{

 	TInt error = KErrNotSupported;

 	if(iIsPresetUnLockSupported)

 		{

 		iIsPresetLocked = EFalse;

 		error = KErrNone;

 		}

 	iOwner.Notify(KUidECamEventPresetUnlocked, error);

 	}

 //

 // CCamImgProc

 //

 CCamImgProc::CCamImgProc(CCamUnitTestPlugin& aOwner): iOwner(aOwner)

 	{

 	}

 CCamImgProc::~CCamImgProc()

 	{

 	Dll::FreeTls();

 	iActiveSequence.Close();

 	iSupportedTransformations.Close();

 	}

 CCamImgProc* CCamImgProc::NewL(CCamUnitTestPlugin& aOwner)

 	{

 	CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());

 	if(!globalData)

 		{

 		globalData = new (ELeave) CDataGlobal;

 		CleanupStack::PushL(globalData);

 		globalData->iReferenceCount = 0;

 		globalData->iCamImgProc = new (ELeave) CCamImgProc(aOwner);

 		CleanupStack::PushL(globalData->iCamImgProc);

 		globalData->iCamImgProc->ConstructL();

     	globalData->iCamImgProc->iRefCount = 1;

     	CleanupStack::Pop(globalData->iCamImgProc);

 		TInt error = Dll::SetTls(globalData);

 		if (error)

 			{

 			delete globalData->iCamImgProc;

 			User::Leave(error);

 			}

 		CleanupStack::Pop(globalData);

 		return static_cast <CCamImgProc*> (globalData->iCamImgProc);

 		}

 	else

 		{

 		CCamImgProc* self = globalData->iCamImgProc;

 		globalData->iReferenceCount++;

 		self->iRefCount = globalData->iReferenceCount + 1;

 		if (globalData->iReferenceCount == 2 )

 			{

 			delete globalData;

 			Dll::FreeTls();

 			}

 		else

 			{

 			TInt error = Dll::SetTls(globalData);

 			if (error)

 				{

 				delete globalData->iCamImgProc;

 				User::Leave(error);

 				}	

 			}

 		return static_cast <CCamImgProc*> (self);		

 		}

 	}

 void CCamImgProc::Release()

 	{

 	iRefCount--; 

 	if(!iRefCount)

 		{

 		delete this;

 		}

 	}	

 void CCamImgProc::ConstructL()

 	{

 	iSupportedTransformations.AppendL(KUidECamEventImageProcessingAdjustBrightness);

 	iSupportedTransformations.AppendL(KUidECamEventImageProcessingAdjustContrast);

 	iSupportedTransformations.AppendL(KUidECamEventImageProcessingEffect);

 	iBrightnessRange[0] = KBrightnessAdjMinValue; // min 

 	iBrightnessRange[1] = KBrightnessAdjMaxValue; // max value, step assumed 1

 	iSupportedColorSwapCapabilities.iSupportedSourceRepresentation  = KDefault;

 	iSupportedColorSwapCapabilities.iSupportedTargetRepresentation  = KDefault;	

 	iSupportedColorSwapCapabilities.iSupportedSourceRgbGroupingMode = KDefault;

 	iSupportedColorSwapCapabilities.iSupportedTargetRgbGroupingMode = KDefault;

 	iSupportedColorSwapCapabilities.iIsCapabilityUniform = ETrue;

 	iSupportedColorAccentCapabilities.iSupportedSourceRepresentation   = KDefault;

 	iSupportedColorAccentCapabilities.iSupportedSourceRgbGroupingMode  = KDefault;

 	iSupportedColorAccentCapabilities.iIsCapabilityUniform = ETrue;

 	}

 void CCamImgProc::GetSupportedTransformationsL(RArray<TUid>& aTransformations) const

 	{

 	aTransformations.Reset();

 	if (iOwner.iCameras[iOwner.iCameraIndex])

 		{

 		for (TInt i=0; i<iSupportedTransformations.Count(); i++)

 			{

 			aTransformations.AppendL(iSupportedTransformations[i]);

 			}

 		}

 	}

 void CCamImgProc::GetActiveTransformationsL(RArray<TUid>& aTransformations) const

 	{

 	aTransformations.Reset();

 	if (iOwner.iCameras[iOwner.iCameraIndex])

 		{

 		for (TInt i=0; i<iSupportedTransformations.Count(); i++)

 			{

 			aTransformations.AppendL(iSupportedTransformations[i]);

 			}

 		}

 	}

 void CCamImgProc::GetTransformationSupportedValuesL(TUid aTransformation, RArray<TInt>& aValues, TValueInfo& aInfo) const

 	{

 	if (iSupportedTransformations.Find(aTransformation)==KErrNotFound)

 		{

 		aValues.Reset();

 		aInfo = ENotActive;

 		}

 	else

 		{

 		if (aTransformation == KUidECamEventImageProcessingAdjustBrightness)

 			{

 			aValues.AppendL(iBrightnessRange[0]);

 			aValues.AppendL(iBrightnessRange[1]);

 			aInfo = EContinuousRangeMinMax;

 			}

 		else

 			{

 			if(aTransformation == KUidECamEventImageProcessingEffect)

 				{

 				aValues.AppendL(CCamera::CCameraImageProcessing::EEffectColorSwap | CCamera::CCameraImageProcessing::EEffectColorAccent);

 				aInfo = EBitField;

 				}

 			else

 				{

 				aInfo = EDiscreteSteps;

 				if (aTransformation == iTransformation)

 					{

 					aValues.AppendL(iValue);

 					}

 				else

 					{

 					aValues.AppendL(KECamImageProcessingDefaultValue);

 					}	

 				}

 			}

 		}

 	}

 TInt CCamImgProc::TransformationValue(TUid aTransformation) const

 	{

 	if (iSupportedTransformations.Find(aTransformation) == KErrNotFound)

 		{

 		return KErrNotFound;

 		}

 	else

 		{

 		if (aTransformation == iTransformation)

 			{

 			return iValue;

 			}

 		else

 			{

 			return KECamImageProcessingDefaultValue;

 			}

 		}

 	}

 TInt CCamImgProc::GetTransformationValue(TUid aTransformation, TInt& aTransformationValue) const

 	{

 	if (iSupportedTransformations.Find(aTransformation) == KErrNotFound)

 		{

 		return KErrNotFound;

 		}

 	else

 		{

 		if (aTransformation == iTransformation)

 			{

 			aTransformationValue = iValue;

 			}

 		else

 			{

 			aTransformationValue = KECamImageProcessingDefaultValue;

 			}

 		return KErrNone;

 		}

 	}

 void CCamImgProc::SetTransformationValue(TUid aTransformation, TInt aValue)

 	{

 	TInt response;

 	if (iSupportedTransformations.Find(aTransformation) == KErrNotFound)

 		{

 		response = KErrECamSettingDisabled;

 		}

 	else

 		{

 		if (aTransformation == KUidECamEventImageProcessingAdjustBrightness)

 			{

 			// if outside the range 

 			if (aValue < iBrightnessRange[0] || aValue > iBrightnessRange[1])

 				{

 				response = KErrECamParameterNotInRange;

 				}

 			else

 				{

 				response = KErrNone;

 				}

 			}

 		else

 			{

 			response = KErrNone;

 			if(aTransformation == KUidECamEventImageProcessingEffect)

 				{

 				if(aValue == CCamera::CCameraImageProcessing::EEffectColorSwap)

 					{

 					iColorSwapParameter.iEntryStatus = ENotActive;

 					}

 				else

 					{

 					if(aValue == CCamera::CCameraImageProcessing::EEffectColorAccent)	

 						{

 						iColorAccentParameter.iEntryStatus = ENotActive;

 						}

 					else

 						{

 						response = KErrArgument;	

 						}

 					}

 				}

 			}

 		if (response == KErrNone)

 			{

 			iTransformation = aTransformation;

 			iValue = aValue;

 			}

 		}

 	iOwner.Notify(aTransformation, response);

 	}

 void CCamImgProc::GetActiveTransformSequenceL(RArray<TUid>& aTransformSequence) const

 	{

 	aTransformSequence.Reset();

 	if (iOwner.iCameras[iOwner.iCameraIndex])

 		{

 		for (TInt i = 0; i < iActiveSequence.Count(); i++)

 			{

 			aTransformSequence.AppendL(iActiveSequence[i]);

 			}

 		}		

 	}

 void CCamImgProc::SetActiveTransformSequenceL(RArray<TUid>& aNewTransformSequence)

 	{

 	iActiveSequence.Reset();

 	if (iOwner.iCameras[iOwner.iCameraIndex])

 		{

 		for (TInt i=0; i<aNewTransformSequence.Count(); i++)

 			{

 			iActiveSequence.AppendL(aNewTransformSequence[i]);

 			}

 		}	

 	}

 void CCamImgProc::SetSourceRect( const TRect& aRect)

 	{

 	iSourceRect = aRect;	

 	}

 void CCamImgProc::GetSourceRect(TRect& aRect) const

 	{

 	aRect = iSourceRect;	

 	}

 void CCamImgProc::GetConcurrentColorSwappingsSupportedL(TInt& aConcurrentColorSwappingSupported) const

 	{

 	aConcurrentColorSwappingSupported = KConcurrentColorOpSupported;

 	}

 void CCamImgProc::GetColorSwapCapabilitiesL(TInt aIndex, CCamera::CCameraImageProcessing::TColorOperationCapabilities& aColorSwapCapabilities) const

 	{

 	if(aIndex <0 || aIndex > KConcurrentColorOpSupported-1)

 		{

 		User::Leave(KErrArgument);

 		}

 	if(aColorSwapCapabilities.Size() != sizeof(CCamera::CCameraImageProcessing::TColorOperationCapabilities) ||

 	   aColorSwapCapabilities.Version() != KECamColorOperationCapabilitiesCurrentVersion)

 		{

 		// new app. running on old impl.

 		User::Leave(KErrNotSupported);

 		}

 	else

 		{

 		aColorSwapCapabilities = iSupportedColorSwapCapabilities;

 		}	

 	}

 void CCamImgProc::SetColorSwapEntry(TInt aIndex, const CCamera::CCameraImageProcessing::TColorOperationEntry& aColorSwapParameters)

 	{

 	TInt response = KErrNone;

 	if(aColorSwapParameters.Size() != sizeof(CCamera::CCameraImageProcessing::TColorOperationEntry) ||

 	aColorSwapParameters.iNumBitsIgnored.Size() != sizeof(CCamera::CCameraImageProcessing::TBitsIgnore) ||

 	aColorSwapParameters.Version() != KECamColorOperationEntryCurrentVersion ||

 	aColorSwapParameters.iNumBitsIgnored.Version() != KECamBitsIgnoreCurrentVersion

 	)

 		{

 		// new app. running on old impl.

 		iOwner.Notify2(KUidECamEvent2CIPSetColorSwapEntry, KErrNotSupported, aIndex);

 		}

 	else

 		{

 		if(aIndex <0 || aIndex > KConcurrentColorOpSupported-1)

 			{

 			iOwner.Notify2(KUidECamEvent2CIPSetColorSwapEntry, KErrArgument, aIndex);

 			}

 		else

 			{

 			if(!CheckColorSwapEntry(aColorSwapParameters))

 				{

 				// if color operation entry is different from what is supported....

 				iOwner.Notify2(KUidECamEvent2CIPSetColorSwapEntry, KErrArgument, aIndex);

 				}

 			else

 				{

 				iColorSwapParameter = aColorSwapParameters;

 				iColorSwapParameter.iEntryStatus = EDiscreteSteps;

 				iOwner.Notify2(KUidECamEvent2CIPSetColorSwapEntry, response, aIndex);	

 				}

 			}

 		}

 	}

 void CCamImgProc::RemoveColorSwapEntry(TInt aIndex)

 	{

 	TInt response = KErrNone;

 	if(aIndex <0 || aIndex > KConcurrentColorOpSupported-1)

 		{

 		iOwner.Notify2(KUidECamEventCIPRemoveColorSwapEntry, KErrArgument, aIndex);

 		}

 	else

 		{

 		iColorSwapParameter.iEntryStatus = ENotActive;

 		iOwner.Notify2(KUidECamEventCIPRemoveColorSwapEntry, response, aIndex);	

 		}

 	}

 void CCamImgProc::GetColorSwapEntryL(TInt aIndex, CCamera::CCameraImageProcessing::TColorOperationEntry& aColorSwapParameters) const

 	{

 	if(aIndex <0 || aIndex > KConcurrentColorOpSupported-1)

 		{

 		User::Leave(KErrArgument);

 		}

 	if(aColorSwapParameters.Size() != sizeof(CCamera::CCameraImageProcessing::TColorOperationEntry) ||

 	aColorSwapParameters.iNumBitsIgnored.Size() != sizeof(CCamera::CCameraImageProcessing::TBitsIgnore))

 		{

 		// new app. running on old impl.

 		User::Leave(KErrNotSupported);

 		}	

 	else

 		{

 		aColorSwapParameters = iColorSwapParameter;

 		}		

 	}

 void CCamImgProc::StartColorSwapping()

 	{

 	TInt response = KErrNone;

 	iOwner.Notify(KUidECamEventCIPStartColorSwap, response);

 	}

 void CCamImgProc::CancelColorSwappingL()

 	{

 	}

 void CCamImgProc::GetConcurrentColorAccentSupportedL(TInt& aConcurrentColorAccentSupported) const

 	{

 	aConcurrentColorAccentSupported = KConcurrentColorOpSupported;

 	}

 void CCamImgProc::GetColorAccentCapabilitiesL(TInt aIndex, CCamera::CCameraImageProcessing::TColorOperationCapabilities& aColorAccentCapabilities) const

 	{

 	if(aIndex <0 || aIndex > KConcurrentColorOpSupported-1)

 		{

 		User::Leave(KErrArgument);

 		}

 	if(aColorAccentCapabilities.Size() != sizeof(CCamera::CCameraImageProcessing::TColorOperationCapabilities))

 		{

 		// new app. running on old impl.

 		User::Leave(KErrNotSupported);

 		}

 	else

 		{

 		aColorAccentCapabilities = iSupportedColorAccentCapabilities;

 		}	

 	}

 void CCamImgProc::SetColorAccentEntry(TInt aIndex, const CCamera::CCameraImageProcessing::TColorOperationEntry& aColorAccentParameters)

 	{

 	TInt response = KErrNone;

 	if(aColorAccentParameters.Size() != sizeof(CCamera::CCameraImageProcessing::TColorOperationEntry) ||

 	aColorAccentParameters.iNumBitsIgnored.Size() != sizeof(CCamera::CCameraImageProcessing::TBitsIgnore))

 		{

 		// new app. running on old impl.

 		iOwner.Notify2(KUidECamEventCIPSetColorAccentEntry, KErrNotSupported, aIndex);

 		}

 	else

 		{

 		if(aIndex <0 || aIndex > KConcurrentColorOpSupported-1)

 			{

 			iOwner.Notify2(KUidECamEventCIPSetColorAccentEntry, KErrArgument, aIndex);

 			}

 		else

 			{

 			if(!CheckColorAccentEntry(aColorAccentParameters))

 				{

 				// if color operation entry is different from what is supported....

 				iOwner.Notify2(KUidECamEventCIPSetColorAccentEntry, KErrArgument, aIndex);

 				}

 			else

 				{

 				iColorAccentParameter = aColorAccentParameters;

 				iColorAccentParameter.iEntryStatus = EDiscreteSteps;

 				iOwner.Notify2(KUidECamEventCIPSetColorAccentEntry, response, aIndex);	

 				}

 			}

 		}

 	}

 void CCamImgProc::RemoveColorAccentEntry(TInt aIndex)

 	{

 	TInt response = KErrNone;

 	if(aIndex <0 || aIndex > KConcurrentColorOpSupported-1)

 		{

 		iOwner.Notify2(KUidECamEventCIPRemoveColorAccentEntry, KErrArgument, aIndex);

 		}

 	else

 		{

 		iColorAccentParameter.iEntryStatus = ENotActive;

 		iOwner.Notify2(KUidECamEventCIPRemoveColorAccentEntry, response, aIndex);	

 		}

 	}

 void CCamImgProc::GetColorAccentEntryL(TInt aIndex, CCamera::CCameraImageProcessing::TColorOperationEntry& aColorAccentParameters) const

 	{

 	if(aIndex <0 || aIndex > KConcurrentColorOpSupported-1)

 		{

 		User::Leave(KErrArgument);

 		}

 	if(aColorAccentParameters.Size() != sizeof(CCamera::CCameraImageProcessing::TColorOperationEntry) ||

 	aColorAccentParameters.iNumBitsIgnored.Size() != sizeof(CCamera::CCameraImageProcessing::TBitsIgnore))

 		{

 		// new app. running on old impl.

 		User::Leave(KErrNotSupported);

 		}	

 	else

 		{

 		aColorAccentParameters = iColorAccentParameter;

 		}

 	}

 void CCamImgProc::StartColorAccent()

 	{

 	TInt response = KErrNone;

 	iOwner.Notify(KUidECamEventCIPStartColorAccent, response);

 	}

 void CCamImgProc::CancelColorAccentL()

 	{

 	}

 TBool CCamImgProc::CheckColorSwapEntry(const CCamera::CCameraImageProcessing::TColorOperationEntry& aColorSwapParameters) const

 	{

 	if(aColorSwapParameters.iSourceColorRepresentation != KDefault)

 		{

 		return EFalse;

 		}

 	if(aColorSwapParameters.iTargetColorRepresentation != KDefault)

 		{

 		return EFalse;

 		}

 	if(aColorSwapParameters.iColorOperationSourceRgbGroupingMode != KDefault)

 		{

 		return EFalse;

 		}

 	if(aColorSwapParameters.iColorOperationTargetRgbGroupingMode != KDefault)

 		{

 		return EFalse;

 		}

 	if(aColorSwapParameters.iNumBitsIgnored.iRedBitsIgnore != 0)

 		{

 		return EFalse;

 		}	

 	if(aColorSwapParameters.iNumBitsIgnored.iGreenBitsIgnore != 0)

 		{

 		return EFalse;

 		}	

 	if(aColorSwapParameters.iNumBitsIgnored.iBlueBitsIgnore != 0)

 		{

 		return EFalse;

 		}		  	

 	if(aColorSwapParameters.iNumBitsIgnored.iAlphaBitsIgnore != 0)

 		{

 		return EFalse;

 		}	   

 	return ETrue;		 

 	}

 TBool CCamImgProc::CheckColorAccentEntry(const CCamera::CCameraImageProcessing::TColorOperationEntry& aColorAccentParameters) const

 	{

 	if(aColorAccentParameters.iSourceColorRepresentation != KDefault)

 		{

 		return EFalse;

 		}

 	if(aColorAccentParameters.iColorOperationSourceRgbGroupingMode != KDefault)

 		{

 		return EFalse;

 		}

 	if(aColorAccentParameters.iNumBitsIgnored.iRedBitsIgnore != 0)

 		{

 		return EFalse;

 		}	

 	if(aColorAccentParameters.iNumBitsIgnored.iGreenBitsIgnore != 0)

 		{

 		return EFalse;

 		}	

 	if(aColorAccentParameters.iNumBitsIgnored.iBlueBitsIgnore != 0)

 		{

 		return EFalse;

 		}		  	

 	if(aColorAccentParameters.iNumBitsIgnored.iAlphaBitsIgnore != 0)

 		{

 		return EFalse;

 		}	   

 	return ETrue;		 

 	}

 void CCamImgProc::GetSupportedRelativeOrientationOptionsL(CCamera::CCameraImageProcessing::TOrientationReference /*aOrientationReference*/, 

 			TUint& /*aSupportedRelativeRotation*/, TUint& /*aSupportedRelativeMirroring*/, TUint& /*aSupportedRelativeFlipping*/) const

 	{

 	User::Leave(KErrNotSupported);	

 	}

 void CCamImgProc::GetCurrentRelativeOrientationOptionsL(CCamera::CCameraImageProcessing::TOrientationReference& /*aOrientationReference*/, 

 			CCamera::CCameraImageProcessing::TRelativeRotation& /*aRelativeRotation*/, CCamera::CCameraImageProcessing::

 			TRelativeMirror& /*aRelativeMirror*/, CCamera::CCameraImageProcessing::TRelativeFlipping& /*aRelativeFlipping*/) const

 	{

 	User::Leave(KErrNotSupported);	

 	}

 void CCamImgProc::SetRelativeOrientationOptions(CCamera::CCameraImageProcessing::TOrientationReference /*aOrientationReference*/, 

 			CCamera::CCameraImageProcessing::TRelativeRotation /*aRelativeRotation*/, CCamera::CCameraImageProcessing::

 			TRelativeMirror /*aRelativeMirror*/, CCamera::CCameraImageProcessing::TRelativeFlipping /*aRelativeFlipping*/) const

 	{

 	iOwner.Notify(KUidECamEventImageProcessingTransformRelativeOrientation, KErrNotSupported);

 	}

 //

 // CCamAdvSet

 //

 CCamAdvSet::CCamAdvSet(CCamUnitTestPlugin& aOwner): iOwner(aOwner)

 	{

 	Init();

 	}

 CCamAdvSet::~CCamAdvSet()

 	{

 	Dll::FreeTls();

 	}

 CCamAdvSet* CCamAdvSet::NewL(CCamUnitTestPlugin& aOwner)

 	{

 	CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());

 	if(!globalData)

 		{

 		globalData = new (ELeave) CDataGlobal;

 		CleanupStack::PushL(globalData);

 		globalData->iReferenceCount = 0;

 		globalData->iCamAdvSet = new (ELeave) CCamAdvSet(aOwner);

 		globalData->iCamAdvSet->iRefCount = 1;

 		TInt error =  Dll::SetTls(globalData);

 		if(error)

 			{

 			delete globalData->iCamAdvSet;

 			User::Leave(error);

 			}

 		CleanupStack::Pop(globalData);

 		return static_cast <CCamAdvSet*> (globalData->iCamAdvSet);

 		}

 	else

 		{

 		CCamAdvSet* self = globalData->iCamAdvSet;

 		globalData->iReferenceCount++;

 		self->iRefCount = globalData->iReferenceCount + 1;

 		if (globalData->iReferenceCount == 3 )

 			{

 			delete globalData;

 			Dll::FreeTls();

 			}

 		else

 			{

 			TInt error =  Dll::SetTls(globalData);

 			if(error)

 				{

 				delete globalData->iCamAdvSet;

 				User::Leave(error);

 				}

 			}

 		return static_cast <CCamAdvSet*> (self);		

 		}

 	}

 void CCamAdvSet::Release()

 	{

 	iRefCount--; 

 	if(!iRefCount)

 		{

 		delete this;

 		}

 	}	

 void CCamAdvSet::Init()

 	{

 	iShutterSpeed = KDefaultShutterSpeed;

 	iFocusDistance = KDefaultFocusDistance;

 	iAperture = KDefaultAperture;

 	iFocusRange = CCamera::CCameraAdvancedSettings::EFocusRangeAuto;

 	iWhiteBalance = CCamera::EWBAuto;

 	iISORateType = CCamera::CCameraAdvancedSettings::EISOManual;

 	iSupportedISORateType = KSupportedISORateType;

 	iIsCapableActualISOValue = KCapableActualISOValue;

 	iAutoISOIndex = -1;

 	iSupportedAFAssistantLight = KAFAssistantLightManual;

 	iAFAssistantLight = CCamera::CCameraAdvancedSettings::EAFAssistantLightOff;

 	iPixelAspectRatio = CCamera::CCameraAdvancedSettings::EPixelAspect1To1;

 	iFlashMode = CCamera::EFlashNone;

 	iSupportedDriveModes |= CCamera::CCameraAdvancedSettings::EDriveModeSingleShot;

 	iSupportedDriveModes |= CCamera::CCameraAdvancedSettings::EDriveModeBurst;

 	iSupportedDriveModes |= CCamera::CCameraAdvancedSettings::EDriveModeTimeNudgeCapture;

 	iDriveMode = CCamera::CCameraAdvancedSettings::EDriveModeAuto;

 	}

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

 	{

 	return iOwner.iCameraTypes[iOwner.iCameraIndex];	

 	}

 CCamera::CCameraAdvancedSettings::TCameraType CCamAdvSet::CameraType(TInt aCameraIndex) const

 	{

 	if (aCameraIndex >= KECamSetAvailableCameras)

 		{

 		return CCamera::CCameraAdvancedSettings::ECameraUnknown;	

 		}

 	else 

 		{

 		return iOwner.iCameraTypes[aCameraIndex];	

 		}

 	}

 TBool CCamAdvSet::IsCameraPresent() const

 	{

 	return iOwner.iCameras[iOwner.iCameraIndex];

 	}

 TBool CCamAdvSet::IsCameraPresent(TInt aCameraIndex) const

 	{

 	if (aCameraIndex >= KECamSetAvailableCameras)

 		{

 		return EFalse;

 		}

 	else

 		{

 		return iOwner.iCameras[aCameraIndex];

 		}

 	}

 TInt CCamAdvSet::CameraIndex() const

 	{

 	return iOwner.iCameraIndex;

 	}

 TInt CCamAdvSet::SupportedStabilizationModes() const

 	{

 	return 0;

 	}

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

 	{

 	return CCamera::CCameraAdvancedSettings::EStabilizationModeOff;

 	}

 void CCamAdvSet::SetStabilizationMode(CCamera::CCameraAdvancedSettings::TStabilizationMode /*aStabilizationMode*/)

 	{

 	}

 TInt CCamAdvSet::SupportedFocusModes() const

 	{

 	return 0;

 	}

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

 	{

 	return CCamera::CCameraAdvancedSettings::EFocusModeAuto;	

 	}

 void CCamAdvSet::SetFocusMode(CCamera::CCameraAdvancedSettings::TFocusMode /*aFocusMode*/)

 	{

 	TInt response = KErrNone;

 	RetrieveResult(response);

 	iOwner.Notify(KUidECamEventCameraSettingFocusMode, response);

 	}

 TInt CCamAdvSet::SupportedFocusRanges() const

 	{

 	return KFocusRangeSupported;

 	}

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

 	{

 	return iFocusRange;

 	}

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

 	{

 	TInt response = KErrNone;

 	RetrieveResult(response);

 	iFocusRange = aFocusRange;

 	iOwner.Notify(KUidECamEventCameraSettingFocusRange2, response);

 	iOwner.Notify(KUidECamEventCameraSettingFocusRange, response);

 	}

 TInt CCamAdvSet::SupportedAutoFocusTypes() const

 	{

 	return 0;

 	}

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

 	{

     return CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff;

 	}

 void CCamAdvSet::SetAutoFocusType(CCamera::CCameraAdvancedSettings::TAutoFocusType /*aAutoFocusType*/)

 	{

 	TInt response = KErrNone;

 	RetrieveResult(response);

 	iOwner.Notify(KUidECamEventCameraSettingAutoFocusType2, response);

 	iOwner.Notify(KUidECamEventCameraSettingAutoFocusType, response);

 	}

 TInt CCamAdvSet::SupportedAutoFocusAreas() const

 	{

 	return 0;

 	}

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

 	{

 	return CCamera::CCameraAdvancedSettings::EAutoFocusTypeAuto;

 	}

 void CCamAdvSet::SetAutoFocusArea(CCamera::CCameraAdvancedSettings::TAutoFocusArea /*aAutoFocusArea*/)

 	{

 	TInt response = KErrNone;

 	RetrieveResult(response);

 	iOwner.Notify(KUidECamEventCameraSettingAutoFocusArea, response);

 	}

 TInt CCamAdvSet::FocusDistance() const

 	{

 	return iFocusDistance;

 	}

 void CCamAdvSet::SetFocusDistance(TInt aDistance) 

 	{

 	TInt response = KErrNone;

 	if (aDistance >=0)

 		{

 		iFocusDistance = aDistance;

 		RetrieveResult(response);

 		}

 	else 

 		{

 		response = KErrNotSupported;

 		}

 	iOwner.Notify(KUidECamEventCameraSettingFocusDistance, response);

 	}

 TInt CCamAdvSet::GetMinFocalLength() const

 	{

 	return KErrNotSupported;

 	}

 void CCamAdvSet::GetSupportedIsoRatesL(RArray<TInt>& aSupportedIsoRates) const

 	{

 	//If no ISO is supported by camera, then leave

 	if(!iOwner.iSupportedISORates.Count())

 		{

 		User::Leave(KErrNotSupported);

 		}

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

 		{

 		aSupportedIsoRates.AppendL(iOwner.iSupportedISORates[index]);

 		}

 	}

 TInt CCamAdvSet::IsoRate() const

 	{

 	//this returned value may not be true if ISO type is other than manual and camera 

 	//has no capability to retrieve actual ISO rate.

 	return iOwner.iIsoRate; 

 	}

 void CCamAdvSet::SetIsoRate(TInt aRate)

 	{

 	TInt response;

 	//check whether the desired rate to be set is being supported or not.

 	if(iOwner.iSupportedISORates.Find(aRate) == KErrNotFound)

 		{

 		response = KErrECamParameterNotInRange;

 		}

 	else 

 		{

 		//set the ISO type to Manual

 		//this function should be called by SetISORateL as well after doing boundary checkings 

 		//SetISORate(CCamera::CCameraAdvancedSettings::EISOManual, aRate); 

 		iISORateType = CCamera::CCameraAdvancedSettings::EISOManual;			

 		iOwner.iIsoRate = aRate;

 		RetrieveResult(response);

 		}

 	iOwner.Notify(KUidECamEventCameraSettingIsoRate, response);

 	}

 void CCamAdvSet::GetSupportedISORateTypeL(TInt& aSupportedISORateTypes) const

 	{

 	aSupportedISORateTypes = iSupportedISORateType;	

 	}

 void CCamAdvSet::SetISORate(CCamera::CCameraAdvancedSettings::TISORateType aISORateType, TInt aParam)

 	{

 	TInt response = KErrNone;

 	if(!(aISORateType & iSupportedISORateType) || iOwner.iSupportedISORates.Count() == 0)

 		{

 		response = KErrNotSupported;

 		}

 	else

 		{

 		switch(aISORateType)

 			{

 			case CCamera::CCameraAdvancedSettings::EISOManual:

 				{

 				if(iOwner.iSupportedISORates.Find(aParam) == KErrNotFound)

 					{

 					response = KErrECamParameterNotInRange;

 					}

 				else

 					{

 					RetrieveResult(response);

 					}

 				break;

 				}

 			case CCamera::CCameraAdvancedSettings::EISOAutoUnPrioritised:

 				{

 				RetrieveResult(response);

 				break;	

 				}

 			case CCamera::CCameraAdvancedSettings::EISOAutoISOPrioritised:

 				{

 				if(iOwner.iSupportedISORates.Find(aParam) == KErrNotFound)

 					{

 					response = KErrECamParameterNotInRange;

 					}

 				else

 					{

 					RetrieveResult(response);

 					}

 				break;

 				}

 			case CCamera::CCameraAdvancedSettings::EISOAutoShutterSpeedPrioritised:

 				{

 				RetrieveResult(response);

 				break;	

 				}

 			case CCamera::CCameraAdvancedSettings::EISOAutoAperturePrioritised:

 				{

 				RetrieveResult(response);

 				break;	

 				}

 			default:

 				response = KErrNotSupported;

 			}

 		// this function should be called by SetISORate ,in old API, as well after doing boundary checkings 

 		// SetISORate(aISORateType, aParam); 	

 		// In real impl, following code should be handled by RunL when server responds to the setting request. Error may also occur.

 		iISORateType = aISORateType;

 		if(aISORateType == CCamera::CCameraAdvancedSettings::EISOManual)

 			{

 			if(response == KErrNone)

 				{

 				iOwner.iIsoRate = aParam;

 				}

 			}

 		else

 			{

 			if(response == KErrNone)

 				{

 				iAutoISOIndex = aParam;

 				}

 			}	

 		}	

 	iOwner.Notify(KUidECamEventCameraSettingIsoRateType, response);

 	}

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

 	{

 	//If camera has no ISO rate supported, then leave

 	if(iOwner.iSupportedISORates.Count() == 0)	

 		{

 		User::Leave(KErrNotSupported);

 		}

 	if(iISORateType == CCamera::CCameraAdvancedSettings::EISONone)

 		{

 		aISORateType = iISORateType;

 		}

 	else

 		{

 		if(iISORateType != CCamera::CCameraAdvancedSettings::EISOManual)

 			{

 			aParam = iAutoISOIndex;

 			//if camera is not capable to retrieve actual ISO value in auto ISO modes, KErrNotFound is returned in aISORate.

 			if(!iIsCapableActualISOValue)

 				{

 				aISORate = KErrNotFound;

 				}

 			else

 				{

 				aISORate = iOwner.iIsoRate;	

 				}

 			}

 		else

 			{

 			aISORate = iOwner.iIsoRate;	

 			}

 		aISORateType = iISORateType;	

 		}	

 	}

 void CCamAdvSet::GetAperturesL(RArray<TInt>& /*aFStops*/, TValueInfo& /*aInfo*/) const

 	{

 	}

 TInt CCamAdvSet::Aperture() const

 	{

 	return iAperture;

 	}

 void CCamAdvSet::SetAperture(TInt aFStop)

 	{

 	TInt response = KErrNone;

 	iAperture = aFStop;

 	RetrieveResult(response);

 	iOwner.Notify(KUidECamEventCameraSettingAperture, response);

 	}	

 void CCamAdvSet::GetShutterSpeedsL(RArray<TInt>& aShutterSpeeds, TValueInfo& aInfo) const

 	{

 	aShutterSpeeds.Reset();

 	aInfo =  ENotActive;

 	}

 TInt CCamAdvSet::ShutterSpeed() const

 	{

 	return iShutterSpeed;

 	}

 void CCamAdvSet::SetShutterSpeed(TInt aShutterSpeed)

 	{

 	TInt response = KErrNone;

 	if (aShutterSpeed >=0)

 		{

 		iShutterSpeed = aShutterSpeed;

 		RetrieveResult(response);

 		}

 	else 

 		{

 		response = KErrNotSupported;

 		}

 	iOwner.Notify(KUidECamEventCameraSettingShutterSpeed, response);

 	}

 TInt CCamAdvSet::SupportedMeteringModes() const

 	{

 	return CCamera::CCameraAdvancedSettings::EMeteringModeAuto;

 	}

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

 	{

 	return CCamera::CCameraAdvancedSettings::EMeteringModeAuto;

 	}

 void CCamAdvSet::SetMeteringMode(CCamera::CCameraAdvancedSettings::TMeteringMode /*aMeteringMode*/)

 	{

 	TInt response = KErrNone;

 	RetrieveResult(response);

 	iOwner.Notify(KUidECamEventCameraSettingMeteringMode, response);

 	}

 TInt CCamAdvSet::SupportedDriveModes() const

 	{

 	return iSupportedDriveModes;

 	}

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

 	{

 	return iDriveMode;

 	}

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

 	{

 	TInt response = KErrNone;

 	iDriveMode = aDriveMode;

 	RetrieveResult(response);

 	iOwner.Notify(KUidECamEventCameraSettingDriveMode, response);

 	}

 TInt CCamAdvSet::SupportedBracketModes() const

 	{

 	return CCamera::CCameraAdvancedSettings::EBracketModeOff;

 	}

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

 	{

 	return CCamera::CCameraAdvancedSettings::EBracketModeOff;

 	}

 void CCamAdvSet::SetBracketMode(CCamera::CCameraAdvancedSettings::TBracketMode /*aBracketMode*/)

 	{

 	TInt response = KErrNone;

 	RetrieveResult(response);

 	iOwner.Notify(KUidECamEventCameraSettingBracketMode, response);

 	}

 TInt CCamAdvSet::SupportedBracketParameters() const

 	{

 	return CCamera::CCameraAdvancedSettings::EBracketParameterNone;

 	}

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

 	{

 	return CCamera::CCameraAdvancedSettings::EBracketParameterNone;

 	}

 void CCamAdvSet::SetBracketParameter(CCamera::CCameraAdvancedSettings::TBracketParameter /*aBracketParameter*/)

 	{

 	}

 TInt CCamAdvSet::SupportedBracketSteps() const

 	{

 	return CCamera::CCameraAdvancedSettings::EBracketStepSmall;

 	}

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

 	{

 	return CCamera::CCameraAdvancedSettings::EBracketStepSmall;

 	}

 void CCamAdvSet::SetBracketStep(CCamera::CCameraAdvancedSettings::TBracketStep /*aBracketStep*/)

 	{

 	}

 void CCamAdvSet::GetBracketMerge(TInt& aStartIndex, TInt& aFrames) const

 	{

 	aStartIndex = KBracketStartIndex;

 	aFrames     = KBracketFrames;

 	}

 void CCamAdvSet::SetBracketMerge(TInt /*aStartIndex = 0*/, TInt /*aFrames = 2*/)

 	{

 	}

 TInt CCamAdvSet::SupportedFlashModes() const

 	{

 	return (CCamera::EFlashVideoLight << 1) - 1;

 	}

 CCamera::TFlash CCamAdvSet::FlashMode() const

 	{

 	return CCamera::TFlash(iFlashMode);

 	}

 void CCamAdvSet::SetFlashMode(CCamera::TFlash aMode)

 	{

     iFlashMode = aMode;

 	}

 TBool CCamAdvSet::RedEyeReduceOn() const

 	{

 	return KDefaultRedEyeReduce;

 	}

 void CCamAdvSet::SetRedEyeReduceOn(TBool /*aState*/)

 	{

 	}

 void CCamAdvSet::GetFlashCompensationStepsL(RArray<TInt>& /*aFlashCompensationSteps*/, TValueInfo& /*aInfo*/) const

 	{

 	}

 TInt CCamAdvSet::FlashCompensationStep() const

 	{

 	return KFlashCompensationStep;

 	}

 TInt CCamAdvSet::GetFlashCompensationStep(TInt& aFlashCompensationStep) const

 	{

 	aFlashCompensationStep = KFlashCompensationStep;

 	return KErrNone;

 	}

 void CCamAdvSet::GetFlashCompensationRangeInSteps(TInt& /*aNegativeCompensation*/, TInt& /*aPositiveCompensation*/) const

 	{

 	}

 void CCamAdvSet::SetFlashCompensationStep(TInt /*aFlashCompensationStep*/)

 	{

 	}

 TInt CCamAdvSet::FlashCompensation() const

 	{

 	return KFlashCompensationInSteps;

 	}

 TInt CCamAdvSet::GetFlashCompensation(TInt& aFlashCompensation) const

 	{

 	aFlashCompensation = KFlashCompensationInSteps;

 	return KErrNone;

 	}

 void CCamAdvSet::SetFlashCompensation(TInt /*aFlashCompensation*/)

 	{

 	}

 TBool CCamAdvSet::IsExternalFlashPresent() const

 	{

 	return KExternalFlashPresentState;

 	}

 void CCamAdvSet::GetManualFlashPowerLevelsL(RArray<TInt>& /*aManualFlashPowerLevels*/, TValueInfo& /*aInfo*/) const

 	{

 	}

 TInt CCamAdvSet::ManualFlashPowerLevel() const

 	{

 	return KManualFlashPowerLevel;

 	}

 void CCamAdvSet::SetManualFlashPowerLevel(TInt /*aManualFlashPowerLevel*/)

 	{

 	}

 TInt CCamAdvSet::SupportedExposureModes() const

 	{

 	return CCamera::EExposureAuto;

 	}

 CCamera::TExposure CCamAdvSet::ExposureMode() const

 	{

 	return CCamera::EExposureAuto;

 	}

 void CCamAdvSet::SetExposureMode(CCamera::TExposure /*aExposureMode = CCamera::EExposureAuto*/)

 	{

 	}

 void CCamAdvSet::GetExposureCompensationStepsL(RArray<TInt>& /*aExposureCompensationSteps*/, TValueInfo& /*aInfo*/) const

 	{

 	}

 void CCamAdvSet::GetExposureCompensationRangeInSteps(TInt& /*aNegativeCompensation*/, TInt& /*aPositiveCompensation*/) const

 	{

 	}

 TInt CCamAdvSet::ExposureCompensationStep() const

 	{

 	return KExposureCompensationStep;

 	}

 TInt CCamAdvSet::GetExposureCompensationStep(TInt& aExposureCompensationStep) const

 	{

 	aExposureCompensationStep = KExposureCompensationStep;

 	return KErrNone;

 	}

 void CCamAdvSet::SetExposureCompensationStep(TInt /*aExposureCompensationStep*/)

 	{

 	}

 TInt CCamAdvSet::ExposureCompensation() const

 	{

 	return KExposureCompensationInSteps;

 	}

 TInt CCamAdvSet::GetExposureCompensation(TInt& aExposureCompensation) const

 	{

 	aExposureCompensation = KExposureCompensationInSteps;

 	return KErrNone;

 	}

 void CCamAdvSet::SetExposureCompensation(TInt /*aExposureCompensation*/)

 	{

 	}

 TInt CCamAdvSet::SupportedWhiteBalanceModes() const

 	{

 	return KWhiteBalanceSupported;

 	}

 CCamera::TWhiteBalance CCamAdvSet::WhiteBalanceMode() const

 	{

 	return iWhiteBalance;

 	}

 void CCamAdvSet::SetWhiteBalanceMode(CCamera::TWhiteBalance aWhiteBalanceMode)

 	{

 	TInt response = KErrNone;

 	iWhiteBalance = aWhiteBalanceMode;

 	RetrieveResult(response);

 	iOwner.Notify(KUidECamEventCameraSettingsWBValue, response);

 	}

 TBool CCamAdvSet::ApertureExposureLockOn() const

 	{

 	return KApertureExposureLockOn;

 	}

 void CCamAdvSet::SetApertureExposureLockOn(TBool /*aAELock*/)

 	{

 	}

 TBool CCamAdvSet::ShootClickOn() const

 	{

 	return KShootClickOn;

 	}

 void CCamAdvSet::SetShootClickOn(TBool /*aShootClickOn*/)

 	{

 	}

 void CCamAdvSet::GetTimerIntervalsL(RArray<TInt>& /*aTimerIntervals*/, TValueInfo& /*aInfo*/) const

 	{

 	}

 TInt CCamAdvSet::TimerInterval() const

 	{

 	return KTimerInterval;

 	}

 void CCamAdvSet::SetTimerInterval(TInt /*aTimerInterval*/)

 	{

 	}

 void CCamAdvSet::GetTimeLapsePeriodRange(TTime& /*aTimeLapseMin*/, TTime& /*aTimeLapseMax*/) const

 	{

 	}

 void CCamAdvSet::GetTimeLapse(TTime& /*aStart*/, TTime& /*aEnd*/, TTime& /*aInterval*/) const

 	{

 	}

 void CCamAdvSet::SetTimeLapse(const TTime& /*aStart*/, const TTime& /*aEnd*/, const TTime& /*aInterval*/)

 	{

 	}

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

 	{

 	return CCamera::CCameraAdvancedSettings::EPictureOrientationUnknown;

 	}

 void CCamAdvSet::SetPictureOrientation(CCamera::CCameraAdvancedSettings::TPictureOrientation /*aOrientation*/)

 	{

 	}

 TInt CCamAdvSet::SupportedPixelAspectRatios() const

 	{

 	return (CCamera::CCameraAdvancedSettings::EEPixelAspect40To33 << 1) - 1;

 	}

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

 	{

 	return CCamera::CCameraAdvancedSettings::TPixelAspectRatio(iPixelAspectRatio);

 	}

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

 	{

 	iPixelAspectRatio = aPixelAspectRatio;

 	}

 TInt CCamAdvSet::SupportedYuvRanges() const

 	{

 	return CCamera::CCameraAdvancedSettings::EYuvRangeFull;

 	}

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

 	{

 	return CCamera::CCameraAdvancedSettings::EYuvRangeFull;

 	}

 void CCamAdvSet::SetYuvRange(CCamera::CCameraAdvancedSettings::TYuvRange /*aYuvRange*/)

 	{

 	}

 TInt CCamAdvSet::BurstImages() const

 	{

 	return KBurstImages;

 	}

 void CCamAdvSet::SetBurstImages(TInt /*aImages*/)

 	{

 	}

 void CCamAdvSet::GetOpticalZoomStepsL(RArray<TInt>& /*aOpticalZoomSteps*/, TValueInfo& /*aInfo*/)  const

 	{

 	}

 TInt CCamAdvSet::OpticalZoom() const

 	{

 	return KECamFineResolutionFactor;

 	}

 void CCamAdvSet::SetOpticalZoom(TInt /*aOpticalZoom*/)

 	{

 	}

 void CCamAdvSet::GetDigitalZoomStepsL(RArray<TInt>& /*aDigitalZoomSteps*/,

 								 TValueInfo& /*aInfo*/) const

 	{

 	}

 void CCamAdvSet::GetDigitalZoomStepsForStillL(RArray<TInt>& /*aDigitalZoomSteps*/, TValueInfo& /*aInfo*/, TInt /*aSizeIndex*/,

 								 CCamera::TFormat /*aFormat*/, TBool& /*aIsInfluencePossible*/) const

 	{

 	}

 void CCamAdvSet::GetDigitalZoomStepsForVideoL(RArray<TInt>& /*aDigitalZoomSteps*/, TValueInfo& /*aInfo*/, TInt /*aFrameRateIndex*/,

 								 TInt /*aSizeIndex*/, CCamera::TFormat /*aFormat*/, TBool& /*aIsInfluencePossible*/, CCamera::TExposure /*aExposure*/) const

 	{

 	}

 TInt CCamAdvSet::DigitalZoom() const

 	{

 	return KECamFineResolutionFactor;

 	}

 void CCamAdvSet::SetDigitalZoom(TInt /*aDigitalZoom*/)

 	{

 	}

 TBool CCamAdvSet::ExposureLockOn() const

 	{

 	return KExposureLockOn;		

 	}

 void CCamAdvSet::SetExposureLockOn(TBool /*aState*/)

 	{

 	}

 TBool CCamAdvSet::AutoFocusLockOn() const

 	{

 	return KAutoFocusLockOn;

 	}

 void CCamAdvSet::SetAutoFocusLockOn(TBool /*aState*/)

 	{	

 	}

 void CCamAdvSet::GetSupportedSettingsL(RArray<TUid>& aSettings) const

 	{

 	aSettings.Reset();

 	// if camera is present 

 	if (iOwner.iCameras[iOwner.iCameraIndex])

 		{

 		aSettings.AppendL(KUidECamEventCameraSettingStabilizationMode);

 		aSettings.AppendL(KUidECamEventCameraSettingFocusMode);

 		aSettings.AppendL(KUidECamEventCameraSettingIsoRateType);

 		}

 	}

 void CCamAdvSet::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const

 	{

 	aActiveSettings.Reset();

 	if (iOwner.iCameras[iOwner.iCameraIndex])

 		{

 		aActiveSettings.AppendL(KUidECamEventCameraSettingFocusMode);

 		aActiveSettings.AppendL(KUidECamEventCameraSettingAFAssistantLight);

 		}

 	}

 void CCamAdvSet::GetDisabledSettingsL(RArray<TUid>& aDisbledSettings) const

 	{

 	aDisbledSettings.Reset();

 	if (iOwner.iCameras[iOwner.iCameraIndex])

 		{

 		aDisbledSettings.AppendL(KUidECamEventCameraSettingStabilizationMode);

 		aDisbledSettings.AppendL(KUidECamEventCameraSettingReferenceScreen);

 		}

 	}

 void CCamAdvSet::SetAutomaticSizeSelectionChangeOn(TBool /*aSetOn = EFalse*/)

 	{

 	}

 TBool CCamAdvSet::AutomaticSizeSelectionChangeOn() const

 	{

 	return KAutomaticSizeSelectionChangeOn;

 	}

 void CCamAdvSet::GetSupportedContinuousAutoFocusTimeoutsL(RArray<TInt>& /*aTimeouts*/, TValueInfo& /*aInfo*/) const

 	{

 	}

 void CCamAdvSet::SetContinuousAutoFocusTimeout(TInt /*aTimeout*/)

 	{

 	}

 void CCamAdvSet::SetStabilizationEffect(CCamera::CCameraAdvancedSettings::TStabilizationEffect /*aEffect*/)

 	{

 	}

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

 	{

 	return CCamera::CCameraAdvancedSettings::EStabilizationOff;

 	}

 TInt CCamAdvSet::SupportedStabilizationEffects() const

 	{

 	return CCamera::CCameraAdvancedSettings::EStabilizationOff;

 	}

 TInt CCamAdvSet::SupportedStabilizationComplexityValues() const

 	{

 	return CCamera::CCameraAdvancedSettings::EStabilizationComplexityAuto;

 	}

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

 	{

 	return CCamera::CCameraAdvancedSettings::EStabilizationComplexityAuto;

 	}

 void CCamAdvSet::SetStabilizationComplexity(CCamera::CCameraAdvancedSettings::TStabilizationAlgorithmComplexity /*aComplexity*/)

 	{

 	}

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

 	{

 	return CCamera::CCameraAdvancedSettings::EWBColorTemperature;

 	}

 void CCamAdvSet::SetWBRgbValue(const TRgb& /*aValue*/)

 	{

 	}

 void CCamAdvSet::GetWBRgbValue(TRgb& /*aValue*/) const

 	{

 	}

 void CCamAdvSet::GetWBSupportedColorTemperaturesL(RArray<TInt>& /*aWBColorTemperatures*/, TValueInfo& /*aInfo*/) const

 	{

 	}

 void CCamAdvSet::SetWBColorTemperature(TInt /*aColorTemperature*/)

 	{

 	}

 TInt CCamAdvSet::WBColorTemperature() const

 	{

 	return KWBColorTemperature;

 	}

 TInt CCamAdvSet::ContinuousAutoFocusTimeout() const

 	{

 	return KContinuousAutoFocusTimeoutValue;

 	}

 TInt CCamAdvSet::IsFlashReady(TBool& aReady) const

 	{

 	aReady = KFlashReadyState;

 	return KErrNone;

 	}

 void CCamAdvSet::GetCurrentFocusModeStepsL(RArray<TInt>& /*aFocusModeSteps*/, TValueInfo& /*aInfo*/) const

 	{

 	}

 void CCamAdvSet::SetReferenceScreen(CWsScreenDevice& /*aScreenDevice*/)

 	{

 	TInt error = KErrNone;

 	RetrieveResult(error);

 	iOwner.Notify(KUidECamEventCameraSettingReferenceScreen, error);

 	}

 void CCamAdvSet::GetPreCaptureWarningSupportedL(CCamera::CCameraAdvancedSettings::TCameraMode /*aCameraMode*/, TInt& /*aPreCaptureWarningSupported*/) const

 	{

 	}

 void CCamAdvSet::SubscribeToPreCaptureWarningL(TInt /*aPreCaptureWarning*/)

 	{

 	}

 void CCamAdvSet::UnSubscribePreCaptureWarningL()

 	{

 	}

 void CCamAdvSet::GetPreCaptureWarningL(TInt& /*aPreCaptureWarning*/) const

 	{

 	}

 void CCamAdvSet::GetSupportedAFAssistantLightL(TInt& aSupportedAFAssistantLight) const

 	{

 	aSupportedAFAssistantLight = iSupportedAFAssistantLight;

 	}

 void CCamAdvSet::GetAFAssistantLightL(CCamera::CCameraAdvancedSettings::TAFAssistantLight& aAFAssistantLight) const

 	{

 	aAFAssistantLight = iAFAssistantLight;

 	}

 void CCamAdvSet::SetAFAssistantLight(CCamera::CCameraAdvancedSettings::TAFAssistantLight aAFAssistantLight)

 	{

 	TInt error = KErrNone;

 	iAFAssistantLight = aAFAssistantLight;

 	RetrieveResult(error);

 	iOwner.Notify(KUidECamEventCameraSettingAFAssistantLight, error);

 	}

 void CCamAdvSet::GetSupportedContinuousZoomTypeL(TUint& aSupportedContinuousZoomType) const

 	{

 	aSupportedContinuousZoomType = KSupportedContinuousZoomType;	

 	}

 void CCamAdvSet::GetFocalLengthInfoL(TInt& /*aMinFocalLength*/, TInt& /*aCurrentFocalLength*/, TInt& /*aMaxFocalLength*/) const

 	{

 	User::Leave(KErrNotSupported);	

 	}

 void CCamAdvSet::GetNumOperationPreferenceL(TUint& /*aNumOperationPreferenceSupported*/) const

 	{

 	User::Leave(KErrNotSupported);		

 	}

 void CCamAdvSet::EnumerateOperationPreferenceL(TUint /*aOperationPreferenceIndex*/, CCamera::CCameraAdvancedSettings::

 						TPerformanceLevel& /*aSpeedLevel*/, CCamera::CCameraAdvancedSettings::TPerformanceLevel& /*aQualityLevel*/, 

 						CCamera::CCameraAdvancedSettings::TPerformanceLevel& /*aLowMemoryConsumptionLevel*/, 

 						CCamera::CCameraAdvancedSettings::TPerformanceLevel& /*aLowPowerConsumptionLevel*/) const

 	{

 	User::Leave(KErrNotSupported);	

 	}

 void CCamAdvSet::SetOperationPreference(TUint /*aOperationPreferenceIndex*/)

 	{

 	iOwner.Notify(KUidECamEventCameraSettingOperationPreference, KErrNotSupported);

 	}

 void CCamAdvSet::GetOperationPreferenceL(TInt& /*aOperationPreferenceIndex*/) const

 	{

 	User::Leave(KErrNotSupported);		

 	}

 void CCamAdvSet::GetSupportedEventsL(RArray<TUid>& aSupportedEvents) const

 	{

 	aSupportedEvents.Reset();

 	}

 void CCamAdvSet::GetIndirectFeatureChangesL(TUid /*aRequestedSetting*/, RArray<TUid>& aIndirectFeatureChanges) const

 	{

 	aIndirectFeatureChanges.Reset();

 	}

 void CCamAdvSet::CreateContinuousZoomImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const

 	{

 	aImplFactoryPtr = CContinuousZoomFactory::NewL();

 	}

 void CCamAdvSet::RetrieveResult(TInt& aError)

 	{

 	//It is assumed that hardware retrieves this error

 	//Assumed that it returns no error

 	aError = KErrNone;

 	}

 /******************************************************/

 CCamManagement::CCamManagement(CCamUnitTestPlugin& aOwner): iOwner(aOwner)

 	{

 	}

 CCamManagement::~CCamManagement()

 	{

 	}

 void CCamManagement::Release()

 	{

 	delete this;

 	}

 CCamManagement* CCamManagement::NewL(CCamUnitTestPlugin& aOwner)

 	{

 	return new (ELeave) CCamManagement(aOwner);

 	}

 TBool CCamManagement::PlugCameraIn(TInt aIndex)

 	{

 	if (aIndex >= KECamSetAvailableCameras)

 		{

 		return EFalse;

 		}

 	else

 		{

 		TInt response = KErrNone;

 		TUid uid;

 		uid.iUid = (KUidECamEventGlobalCamera00PluggedInUidValue + aIndex);

 		iOwner.iCameras[aIndex] = ETrue;

 		iOwner.Notify(uid, response);

 		}

 	return ETrue;

 	}

 TBool CCamManagement::PlugCameraOut(TInt aIndex)

 	{

 	if (aIndex >= KECamSetAvailableCameras)

 		{

 		return EFalse;

 		}

 	else

 		{

 		TInt response = KErrNone;

 		TUid uid;

 		uid.iUid  = KUidECamEventGlobalCamera00PluggedOutUidValue + aIndex;

 		iOwner.iCameras[aIndex] = EFalse;

 		iOwner.Notify(uid, response);

 		}

 	return ETrue;

 	}

 //

 //Snapshot factory for Image

 CContinuousZoomFactory* CContinuousZoomFactory::NewL()

 	{

 	CContinuousZoomFactory* self = new(ELeave) CContinuousZoomFactory();

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop();

 	return self;

 	}

 void CContinuousZoomFactory::ConstructL()

 	{

 	}

 CContinuousZoomFactory::CContinuousZoomFactory() : iCamContinuousZoomImp(NULL)

 	{

 	}

 CContinuousZoomFactory::~CContinuousZoomFactory()

 	{

 	}

 TInt CContinuousZoomFactory::GetImpl(TAny*& /*aIfPtr*/, TUid /*aIfaceUid*/) const

 	{

 	return KErrNotSupported;

 	}

 TInt CContinuousZoomFactory::GetImpl1(TAny*& aIfPtr, TUid aIfaceUid, TECamImplFactoryParam aParam1) const

 	{

 	switch(aIfaceUid.iUid)	

 		{

 		case KECamMCameraContinuousZoomUidValue:

 			{

 			CCamera::CCameraAdvancedSettings::TContinuousZoomType zoomType = static_cast<CCamera::CCameraAdvancedSettings::TContinuousZoomType>(aParam1.iIntParam);

 			iCamContinuousZoomImp = CCamContinuousZoom::NewL(zoomType);

 			aIfPtr = static_cast<MCameraContinuousZoom*>(iCamContinuousZoomImp);

 			return KErrNone;	

 			}

 		default:

 			{

 			aIfPtr = NULL;

 			return KErrNotSupported;	

 			}

 		}	

 	}

 TInt CContinuousZoomFactory::GetImpl2(TAny*& /*aIfPtr*/, TUid /*aIfaceUid*/, TECamImplFactoryParam /*aParam1*/, TECamImplFactoryParam /*aParam2*/) const

 	{

 	return KErrNotSupported;	

 	}

 void CContinuousZoomFactory::Release()

 	{

 	delete this;

 	}

 CCamContinuousZoom* CCamContinuousZoom::NewL(CCamera::CCameraAdvancedSettings::TContinuousZoomType aContinuousZoomType)

 	{

 	CCamContinuousZoom* self = new (ELeave) CCamContinuousZoom(aContinuousZoomType);

 	return self;

 	}

 CCamContinuousZoom::CCamContinuousZoom(CCamera::CCameraAdvancedSettings::TContinuousZoomType aContinuousZoomType)

 	: iZoomType(aContinuousZoomType)

 	{

 	iInfo.iMaxSpeedSupported = 10;

 	iInfo.iMinAccelerationSupported = 0;

 	iInfo.iMaxAccelerationSupported = 0;

 	iInfo.iContinuousZoomMinLimit = 0;

 	iInfo.iContinuousZoomMaxLimit = 10;

 	}

 CCamContinuousZoom::~CCamContinuousZoom()

 	{

 	}

 void CCamContinuousZoom::SetContinuousZoomObserverAndHandle(MContinuousZoomObserver& aObserver, CCamera::CCameraContinuousZoom* aContinuousZoomHandle)

 	{

 	iObserver = &aObserver;

 	iContinuousZoomHandle = aContinuousZoomHandle;

 	}

 void CCamContinuousZoom::StartContinuousZoomL(CCamera::CCameraAdvancedSettings::TContinuousZoomParameters aContinuousZoomParameters)

 	{

 	if(aContinuousZoomParameters.Size() != sizeof(CCamera::CCameraAdvancedSettings::TContinuousZoomParameters) ||

 			aContinuousZoomParameters.Version() != KContinuousZoomParametersCurrentVersion)

 		{

 		User::Leave(KErrNotSupported);

 		}

 	if(aContinuousZoomParameters.iContinuousZoomSpeed > iInfo.iMaxSpeedSupported || 

 			aContinuousZoomParameters.iContinuousZoomAcceleration < iInfo.iMinAccelerationSupported || 

 			aContinuousZoomParameters.iContinuousZoomAcceleration > iInfo.iMaxAccelerationSupported || 

 			aContinuousZoomParameters.iContinuousZoomLimit < iInfo.iContinuousZoomMinLimit ||

 			aContinuousZoomParameters.iContinuousZoomLimit > iInfo.iContinuousZoomMaxLimit)

 		{

 		User::Leave(KErrArgument);

 		}

 	iParameters = aContinuousZoomParameters;

 	for(TInt i = 0; i < iParameters.iContinuousZoomLimit; i++)

 		{

 		iObserver->ContinuousZoomProgress(*iContinuousZoomHandle, i, KErrNone);

 		}

 	iObserver->ContinuousZoomCompleted(*iContinuousZoomHandle, iParameters.iContinuousZoomLimit, KErrNone);

 	}

 void CCamContinuousZoom::StopContinuousZoom()

 	{

 	return;

 	}

 void CCamContinuousZoom::GetContinuousZoomSupportInfoL(CCamera::CCameraAdvancedSettings::TContinuousZoomSupportInfo& aContinuousZoomInfo) const

 	{

 	if(aContinuousZoomInfo.Size() != sizeof(CCamera::CCameraAdvancedSettings::TContinuousZoomSupportInfo) ||

 			aContinuousZoomInfo.Version() != KContinuousZoomSupportInfoCurrentVersion)

 		{

 		User::Leave(KErrNotSupported);

 		}

 	aContinuousZoomInfo = iInfo;

 	}

 void CCamContinuousZoom::GetContinuousZoomId(TInt& aZoomId) const

 	{

 	aZoomId = (TInt)(this);

 	}

 void CCamContinuousZoom::Release()

 	{

 	delete this;

 	}