// 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);

	}